Use Attribute to set type_map instead of config

[gabplch]

In new Symfony version a lot of configs are migrationg to attributes. What about to make smae this in this bundle?

E.g. wa have POPO model FooBar:

#[TypeMap('foo_bar')]
class FooBar {
     private string $someProperty;
}

[gabplch]

If this case is ok for you, I can make PR, when will have some free time

[dunglas]

Good idea. PR welcome!

[crazy-weasel]

Hi :)

I implemented basic support for attributes in one of my projects, with a custom compiler pass.

In my implementation I ignore the type_map and only use my own attribute, but for the general case I think it's best to merge these two. It could be useful, when some of the classes are not editable (e.g. because they are from a library,..)

Do you have any thoughts on that?

Maybe just like this:

$typeMap = array_merge($config['type_map'] ?? [], $this->loadTypeMapFromAttributes($container));

if ($typeMap) {
    $container->getDefinition('dunglas_doctrine_json_odm.type_mapper')->addArgument($config['type_map']);
} else {
    $container->removeDefinition('dunglas_doctrine_json_odm.type_mapper');
}

The attribute could be just a simple one with only one property called type, and for the loading:

private function loadTypeMapFromAttributes(ContainerBuilder $container): array
{
    $typeMap = [];

    foreach ($container->getDefinitions() as $id => $definition) {
        $class = $container->getReflectionClass($definition->getClass(), false);

        if ($class) {
            $typeMapAttr = $class->getAttributes(TypeMap::class);
            $typeMapAttrCount = count($typeMapAttr);

            if ($typeMapAttrCount === 1) {
                $typeMapAttr = $typeMapAttr[0]->newInstance();
                $typeMap[$typeMapAttr->name] = $definition->getClass();
            }
            elseif ($typeMapAttrCount > 1) {
                 throw new \Exception('only one TypeMap-attribute is allowed on class ' . $definition->getClass());
            }
        }
    }

    return $typeMap;
}

Greetings :)

[Arkemlar]

I implemented attributes support in my project, for those who needs that, here is the code:

Attribute

namespace App\Infrastructure\Persistence\Doctrine\JSON;

use Attribute;

#[Attribute(Attribute::TARGET_CLASS)]
class JSONType
{
    public function __construct(
        public string $serializedTypeName,
    ) {
    }
}

Click me

Custom TypeMapper

namespace App\Infrastructure\Persistence\Doctrine\JSON;

use Dunglas\DoctrineJsonOdm\TypeMapperInterface;

final class TypeMapper implements TypeMapperInterface
{
    public array $mapping = [];
    public array $reverseMapping = [];

    /** @param array<class-string, string> $mapping */
    public function __construct(array $mapping)
    {
        $this->mapping = $mapping;
        $this->reverseMapping = array_flip($mapping);
    }

    public function getTypeByClass(string $class): string
    {
        return $this->mapping[$class] ?? $class;
    }

    public function getClassByType(string $type): string
    {
        return $this->reverseMapping[$type] ?? $type;
    }
}

Compiler pass to collect attributes and put them to the TypeMapper

namespace App\Infrastructure\Persistence\Doctrine\JSON;

use ReflectionClass;
use Symfony\Component\DependencyInjection\ChildDefinition;
use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Reference;
use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;

final class DoctrineJSONObjectsConfigurator implements CompilerPassInterface
{
    public static array $typesMapping = [];

    public static function register(ContainerBuilder $container): void
    {
        /** @psalm-suppress ArgumentTypeCoercion */
        $container->registerAttributeForAutoconfiguration(
            JSONType::class,
            static function (
                ChildDefinition $definition,
                JSONType $attribute,
                ReflectionClass $reflector,
            ): void {
                self::$typesMapping[$reflector->name] = $attribute->serializedTypeName;
            },
        );
        $container->addCompilerPass(new self());
    }

    public function process(ContainerBuilder $container): void
    {
        $container->getDefinition(TypeMapper::class)->setArguments([self::$typesMapping]);

        $jsonOdmSerializer = $container->getDefinition('dunglas_doctrine_json_odm.serializer');
        $normalizers = [];
        foreach ($container->findTaggedServiceIds('odm.normalizer') as $serviceId => $tags) {
            if (is_subclass_of($container->getDefinition($serviceId)->getClass(), DenormalizerInterface::class)) {
                $normalizers[] = new Reference($serviceId);
            }
        }
        $jsonOdmSerializer->setArgument(0, array_merge($normalizers, $jsonOdmSerializer->getArgument(0)));
    }
}

Here above you can notice the odm.normalizer service tag that is usefult to add for specific normalizers with #[AutoconfigureTag('odm.normalizer')] attribute.
To register compiler pass you may do this:

namespace App;

class Kernel extends BaseKernel
{
    use MicroKernelTrait;

    protected function build(ContainerBuilder $container): void
    {
        DoctrineJSONObjectsConfigurator::register($container);
    }
}

And the last part is services.yaml

services:
    App\Infrastructure\Persistence\Doctrine\JSON\TypeMapper: ~
    dunglas_doctrine_json_odm.type_mapper: '@App\Infrastructure\Persistence\Doctrine\JSON\TypeMapper'

Hope I have not forget anything. If you like it, I can make PR.

[rvanlaak]

PR imho would be great @Arkemlar !