Purely yes/no question: does this support dynmically added attributes on objects?

[raveren]

Despite the best rounded feature set of similar libraries, I cannot find any approach that would allow me to handle deserialization of what's called "superfluous" class attributes in the docs of this class..? The docs say I have two options: throw exception and ignore.

But my usecase demands that I create dynamic columns (for classes with #[AllowDynamicProperties])

Btw, the best approach in this department is by netresearch/jsonmapper

            $mapper->undefinedPropertyHandler = static function (object $object, string $propName, mixed $jsonValue) {
                $object->{$propName} = $jsonValue; // this line is my custom code
            };

[romm]

Hi @raveren, I'd recommend against the usage of dynamic properties, but if you really need to use it in your case, you can do the following (can be adapted to your needs, of course):

#[AllowDynamicProperties]
final class SomeObject {}

$object = (new \CuyZ\Valinor\MapperBuilder())
    ->registerConverter(
        static function (array $source): SomeObject {
            $object = new SomeObject();

            foreach ($source as $key => $value) {
                $object->$key = $value;
            }

            return $object;
        }
    )
    ->mapper()
    ->map(SomeObject::class, [
        'foo' => 'bar',
        'baz' => 'qux',
    ]);

[raveren]

Thank you, but that approach is for a specific class with known columns, it's nice, but I need an approach that accepts all classes and respects their #[AllowDynamicProperties].

To be clear, I am against dynamic properties as well, but if I ignore them - there will be lost data in production when eventually someone changes a class signature without proper procedure.

My approach is to validate and complain (via automatic bug reporting) but keep the dynamically defined data instead of throwing it out.

[romm]

This can do the job then. Use with precaution 😉

EDIT: I guess you should also add some verification not to override already filled properties.

#[\AllowDynamicProperties]
final class SomeObject {}

$object = (new \CuyZ\Valinor\MapperBuilder())
    ->allowSuperfluousKeys()
    ->registerConverter(
        /**
         * @template T of object
         * @param callable(array): T $next
         * @return T
         */
        static function (array $source, callable $next): object {
            $object = $next($source);

            if ((new ReflectionClass($object))->getAttributes(\AllowDynamicProperties::class) !== []) {
                foreach ($source as $key => $value) {
                    $object->$key = $value;
                }
            }

            return $object;
        }
    )
    ->mapper()
    ->map(SomeObject::class, [
        'foo' => 'bar',
        'baz' => 'qux',
    ]);

[raveren]

Thank you for your kind help! However what keeps it from fully working is this:

$object->$key = $value;

It assigns $key to an unmapped/unprocessed $value, and $object->$key = $next($value); does not work.

I.e. if $value is supposed to be a registered constructor object, it will NOT be "mapped".

BTW I mention this because it was way easier than the docs implied, I added support for Carbon with just:

    ...
    ->registerConstructor(fn(string $time): Carbon => new Carbon($time))

I really appreciate your help, but my time budget for this task is long exhausted, I went with netresearch/jsonmapper. For those looking for a quick working solution:

        $mapper                  = new JsonMapper();
        // accept arrays as `$data`
        $mapper->bEnforceMapType = false;
        // just try to instantiate class from its json-encoded version and hope for the best (works 
        // for BackedEnum and Carbon and that's all we care about atm)
        $mapper->bStrictObjectTypeChecking = false;

        if ($preserveDynamicallyDeclaredProperties) {
            $mapper->undefinedPropertyHandler = static function (object $object, string $propName, mixed $jsonValue) {
                // $propName is dynamically added, we can do additional processing on it here
                $object->{$propName} = $jsonValue;
            };
        } else {
            $mapper->bExceptionOnUndefinedProperty = true;
        }

        return $mapper->map($data, $targetClass);

[romm]

It assigns $key to an unmapped/unprocessed $value, and $object->$key = $next($value); does not work.

I'm sorry but I don't get it: how could you even know the type of a property that does not even exist? I'm missing something here. 😅

[raveren]

Yeah, sorry, good eye!

The solution you provided works perfectly!

However I must also provide a procedure of how to rename existing columns, and the problem I described is real to implement that.

Furthermore, I stumbled upon a pleasant, undocumented surprise, netresearch/jsonmapper allows to return string from undefinedPropertyHandler to do just that - it uses the new name for the column!

And since I was too lazy to explain why I need all of this, I opensourced it lol:

https://github.com/raveren/EloquentDataObject