Potential issue with custom casting classes

[golonix]

Hi,

I'm using Castable class to cast value objects and I've noticed that, despite having implemented SerializesCastableAttributes interface in a caster class, when toArray method is called on the model, the casted attribute is not properly serialized (actually it is not serialized at all).

Castable class:

class Enumeration implements Castable
{
    public static function castUsing(array $arguments): EnumerationCast
    {
        return new EnumerationCast(static::class);
    }
}

Caster class:

class EnumerationCast implements CastsAttributes, SerializesCastableAttributes
{
    public function __construct(string $enumClass)
    {
        ///
    }

    public function get($model, string $key, $value, array $attributes): ?EnumerationObject
    {
        ///
    }

    public function set($model, string $key, $value, array $attributes)
    {
        //
    }

    public function serialize($model, string $key, $value, array $attributes)
    {
        //
    }
}

Example usage in model:

class MyModel extends Model
{
    protected $casts = [
        'enum' => Enumeration::class,
    ];
}

MyModel is using Enumeration class as a casting class which is delegating the casting to the EnumerationCast class (via castUsing). Value object set/get works as expected. The issue is with the serialize method.

From what I can tell, in the HasAttributes trait, there are following methods:

protected function addCastAttributesToArray(array $attributes, array $mutatedAttributes)
{
    //

    if ($attributes[$key] && $this->isClassSerializable($key)) {
        $attributes[$key] = $this->serializeClassCastableAttribute($key, $attributes[$key]);
    }

    //   
}

protected function isClassSerializable($key)
{
    return $this->isClassCastable($key) &&
           method_exists($this->parseCasterClass($this->getCasts()[$key]), 'serialize');
}

protected function serializeClassCastableAttribute($key, $value)
{
    return $this->resolveCasterClass($key)->serialize(
        $this, $key, $value, $this->attributes
    );
}

As you can see, isClassSerializable and serializeClassCastableAttribute use two different methods to check what is the caster class:

• parseCasterClass will return Enumeration (which does not have serialize method)
• resolveCasterClass will return EnumerationCast

So, method_exists($this->parseCasterClass($this->getCasts()[$key]), 'serialize'); will return false, therefore serialize method in EnumerationCast won't be invoked.

Current implementation forces to add serialize method actually to both classes: a castable one and a caster one (sorry, if the naming is kinda awkward). Is that intended behavior?

[henzeb]

I have noticed the same issue. I made a bugreport, but they won't fix it. #42658
for enums, I have solved this problem with a nasty workaround. See https://github.com/henzeb/enumhancer/blob/main/docs/casting.md

[trip-somers]

I am having this problem right now. I have basically built the Address value object from the Laravel docs because it fit our use-case perfectly, but when the model is serialized, the value object's serialize() method is never called.

We wanted the default serialization to result in a basic string "1234 Test Dr, Dallas, TX 75001", so I added a __toString() to the Address value object, and our serialize() method just returns (string) $value.

When the model is serialized, it comes back as JSON: {"address_line_1":"1234 Test Dr", "city":"Dallas","state":"TX","zip":"75001","address_line_2":null}.

I threw a dd($value) into my serialize() method to see if it's even being called, and it's not.

[trip-somers]

I had to implement JsonSerializable/jsonSerialize() and Arrayable/toArray() on my value object to get this to serialize properly even though the docs say you can do it by implementing SerializesCastableAttributes/serialize() in the cast class.