Feature: Doctrine Provider (#253)

This allow automatically provide an entity from database instead of
creating a new one, which will update values instead of generating a new
entity

This is rather a first simple implementation, but it should work for the
90% use case

Author: joelwurtz

.gitignore

@@ -8,4 +8,5 @@ tools/phpstan/cache/
 cache/
 site/
 .build/
-.castor*
+.castor*
+tests/Doctrine/db.sqlite

composer.json

@@ -30,9 +30,11 @@
     },
     "require-dev": {
         "api-platform/core": "^3.0.4 || ^4",
-        "doctrine/annotations": "~1.0",
+        "doctrine/annotations": "^2.0",
+        "doctrine/doctrine-bundle": "^2.15",
         "doctrine/collections": "^2.2",
         "doctrine/inflector": "^2.0",
+        "doctrine/orm": "^2.0 || ^3.0",
         "matthiasnoback/symfony-dependency-injection-test": "^5.1",
         "moneyphp/money": "^3.3.2",
         "phpunit/phpunit": "^9.0",

src/Attribute/MapProvider.php

@@ -8,11 +8,11 @@
 final readonly class MapProvider
 {
     /**
-     * @param ?string $source   from which source type this provider should apply
-     * @param string  $provider the provider class name or service identifier
+     * @param ?string      $source   from which source type this provider should apply
+     * @param false|string $provider the provider class name or service identifier, set false to disable any provider
      */
     public function __construct(
-        public string $provider,
+        public false|string $provider,
         public ?string $source = null,
     ) {
     }

src/AutoMapper.php

@@ -12,13 +12,15 @@
 use AutoMapper\Loader\FileLoader;
 use AutoMapper\Metadata\MetadataFactory;
 use AutoMapper\Metadata\MetadataRegistry;
+use AutoMapper\Provider\Doctrine\DoctrineProvider;
 use AutoMapper\Provider\ProviderInterface;
 use AutoMapper\Provider\ProviderRegistry;
 use AutoMapper\Symfony\ExpressionLanguageProvider;
 use AutoMapper\Transformer\PropertyTransformer\PropertyTransformerInterface;
 use AutoMapper\Transformer\PropertyTransformer\PropertyTransformerRegistry;
 use AutoMapper\Transformer\TransformerFactoryInterface;
 use Doctrine\Common\Annotations\AnnotationReader;
+use Doctrine\Persistence\ObjectManager;
 use Symfony\Component\EventDispatcher\EventDispatcher;
 use Symfony\Component\EventDispatcher\EventDispatcherInterface;
 use Symfony\Component\ExpressionLanguage\ExpressionLanguage;
@@ -148,6 +150,7 @@ public static function create(
         EventDispatcherInterface $eventDispatcher = new EventDispatcher(),
         iterable $providers = [],
         bool $removeDefaultProperties = false,
+        ?ObjectManager $objectManager = null,
     ): AutoMapperInterface {
         if (\count($transformerFactories) > 0) {
             trigger_deprecation('jolicode/automapper', '9.0', 'The "$transformerFactories" property will be removed in version 10.0, AST transformer factories must be included within AutoMapper.', __METHOD__);
@@ -176,6 +179,12 @@ public static function create(
             $classDiscriminatorFromClassMetadata = new ClassDiscriminatorFromClassMetadata($classMetadataFactory);
         }
 
+        $providers = iterator_to_array($providers);
+
+        if (null !== $objectManager) {
+            $providers[] = new DoctrineProvider($objectManager);
+        }
+
         $customTransformerRegistry = new PropertyTransformerRegistry($propertyTransformers);
         $metadataRegistry = new MetadataRegistry($configuration);
         $providerRegistry = new ProviderRegistry($providers);
@@ -192,6 +201,7 @@ public static function create(
             $expressionLanguage,
             $eventDispatcher,
             $removeDefaultProperties,
+            $objectManager,
         );
 
         $mapperGenerator = new MapperGenerator(

src/EventListener/ApiPlatform/JsonLdListener.php

@@ -68,7 +68,7 @@ public function __invoke(GenerateMapperEvent $event): void
         }
 
         if ($event->mapperMetadata->source === 'array' && $this->resourceClassResolver->isResourceClass($event->mapperMetadata->target)) {
-            $event->provider = IriProvider::class;
+            $event->provider ??= IriProvider::class;
         }
     }
 }

src/EventListener/Doctrine/DoctrineIdentifierListener.php

@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+namespace AutoMapper\EventListener\Doctrine;
+
+use AutoMapper\Event\PropertyMetadataEvent;
+use Doctrine\Persistence\ObjectManager;
+
+final readonly class DoctrineIdentifierListener
+{
+    public function __construct(
+        private ObjectManager $objectManager
+    ) {
+    }
+
+    public function __invoke(PropertyMetadataEvent $event): void
+    {
+        if ($event->mapperMetadata->target === 'array' || !$this->objectManager->getMetadataFactory()->hasMetadataFor($event->mapperMetadata->target)) {
+            return;
+        }
+
+        $metadata = $this->objectManager->getClassMetadata($event->mapperMetadata->target);
+
+        if ($metadata->isIdentifier($event->target->property)) {
+            $event->identifier = true;
+        }
+    }
+}

src/EventListener/Doctrine/DoctrineProviderListener.php

@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace AutoMapper\EventListener\Doctrine;
+
+use AutoMapper\Event\GenerateMapperEvent;
+use AutoMapper\Provider\Doctrine\DoctrineProvider;
+use Doctrine\Persistence\ObjectManager;
+
+final readonly class DoctrineProviderListener
+{
+    public function __construct(
+        private ObjectManager $objectManager
+    ) {
+    }
+
+    public function __invoke(GenerateMapperEvent $event): void
+    {
+        if ($event->mapperMetadata->target === 'array' || !$this->objectManager->getMetadataFactory()->hasMetadataFor($event->mapperMetadata->target)) {
+            return;
+        }
+
+        $event->provider ??= DoctrineProvider::class;
+    }
+}

src/EventListener/MapProviderListener.php

@@ -51,6 +51,16 @@ public function __invoke(GenerateMapperEvent $event): void
             }
         }
 
-        $event->provider ??= $provider ?? $defaultMapProvider;
+        $eventProvider = $provider ?? $defaultMapProvider;
+
+        if (null === $eventProvider) {
+            return;
+        }
+
+        if (false === $eventProvider) {
+            $event->provider = null;
+        } else {
+            $event->provider = $eventProvider;
+        }
     }
 }

src/GeneratedMapper.php

@@ -36,6 +36,11 @@ public function registerMappers(AutoMapperRegistryInterface $registry): void
     {
     }
 
+    public function getTargetIdentifiers(mixed $value): mixed
+    {
+        return null;
+    }
+
     public function getSourceHash(mixed $value): ?string
     {
         return null;

src/Generator/IdentifierHashGenerator.php

@@ -4,10 +4,14 @@
 
 namespace AutoMapper\Generator;
 
+use AutoMapper\Extractor\ReadAccessor;
 use AutoMapper\Metadata\GeneratorMetadata;
+use AutoMapper\Transformer\IdentifierHashInterface;
+use PhpParser\Builder;
 use PhpParser\Node\Arg;
 use PhpParser\Node\Expr;
 use PhpParser\Node\Name;
+use PhpParser\Node\Param;
 use PhpParser\Node\Scalar;
 use PhpParser\Node\Stmt;
 
@@ -16,7 +20,7 @@
     /**
      * @return list<Stmt>
      */
-    public function getStatements(GeneratorMetadata $metadata, bool $fromSource): array
+    private function getStatements(GeneratorMetadata $metadata, bool $fromSource): array
     {
         $identifiers = [];
 
@@ -97,4 +101,146 @@ public function getStatements(GeneratorMetadata $metadata, bool $fromSource): ar
 
         return $statements;
     }
+
+    /**
+     * Create the getSourceHash method for this mapper.
+     *
+     * ```php
+     * public function getSourceHash(mixed $source, mixed $target): ?string {
+     *    ... // statements
+     * }
+     * ```
+     */
+    public function getSourceHashMethod(GeneratorMetadata $metadata): ?Stmt\ClassMethod
+    {
+        $stmts = $this->getStatements($metadata, true);
+
+        if (empty($stmts)) {
+            return null;
+        }
+
+        return (new Builder\Method('getSourceHash'))
+            ->makePublic()
+            ->setReturnType('?string')
+            ->addParam(new Param(
+                var: new Expr\Variable('value'),
+                type: new Name('mixed'))
+            )
+            ->addStmts($stmts)
+            ->getNode();
+    }
+
+    /**
+     * Create the getTargetHash method for this mapper.
+     *
+     * ```php
+     * public function getTargetHash(mixed $source, mixed $target): ?string {
+     *    ... // statements
+     * }
+     * ```
+     */
+    public function getTargetHashMethod(GeneratorMetadata $metadata): ?Stmt\ClassMethod
+    {
+        $stmts = $this->getStatements($metadata, false);
+
+        if (empty($stmts)) {
+            return null;
+        }
+
+        return (new Builder\Method('getTargetHash'))
+            ->makePublic()
+            ->setReturnType('?string')
+            ->addParam(new Param(
+                var: new Expr\Variable('value'),
+                type: new Name('mixed'))
+            )
+            ->addStmts($stmts)
+            ->getNode();
+    }
+
+    /**
+     * Create the getTargetIdentifiers method for this mapper.
+     *
+     * ```php
+     * public function getTargetIdentifiers(mixed $source): mixed {
+     *    ... // statements
+     * }
+     * ```
+     */
+    public function getTargetIdentifiersMethod(GeneratorMetadata $metadata): ?Stmt\ClassMethod
+    {
+        $identifiers = [];
+
+        foreach ($metadata->propertiesMetadata as $propertyMetadata) {
+            if (!$propertyMetadata->identifier) {
+                continue;
+            }
+
+            if (null === $propertyMetadata->source->accessor) {
+                continue;
+            }
+
+            $identifiers[] = $propertyMetadata;
+        }
+
+        if (empty($identifiers)) {
+            return null;
+        }
+
+        $isUnique = \count($identifiers) === 1;
+
+        $identifiersVariable = new Expr\Variable('identifiers');
+        $valueVariable = new Expr\Variable('value');
+        $statements = [];
+
+        if (!$isUnique) {
+            $statements[] = new Stmt\Expression(new Expr\Assign($identifiersVariable, new Expr\Array_()));
+        }
+
+        // foreach property we check
+        foreach ($identifiers as $property) {
+            /** @var ReadAccessor $accessor */
+            $accessor = $property->source->accessor;
+
+            // check if the source is defined
+            if ($property->source->checkExists) {
+                $statements[] = new Stmt\If_($accessor->getIsUndefinedExpression($valueVariable), [
+                    'stmts' => [
+                        new Stmt\Return_(new Expr\ConstFetch(new Name('null'))),
+                    ],
+                ]);
+            }
+
+            $fieldValueExpr = $accessor->getExpression($valueVariable);
+            $transformer = $property->transformer;
+
+            if ($transformer instanceof IdentifierHashInterface) {
+                $fieldValueExpr = $transformer->getIdentifierExpression($fieldValueExpr);
+            }
+
+            if ($isUnique) {
+                $statements[] = new Stmt\Return_($fieldValueExpr);
+            } else {
+                $statements[] = new Stmt\Expression(new Expr\Assign(
+                    new Expr\ArrayDimFetch($identifiersVariable, new Scalar\String_($property->target->property)),
+                    $fieldValueExpr
+                ));
+            }
+        }
+
+        // return hash as string
+        if (!$isUnique) {
+            $statements[] = new Stmt\Return_($identifiersVariable);
+        }
+
+        return (new Builder\Method('getTargetIdentifiers'))
+            ->makePublic()
+            ->setReturnType('mixed')
+            ->addParam(new Param(
+                var: new Expr\Variable('value'),
+                type: new Name('mixed'))
+            )
+            ->addStmts($statements)
+            ->getNode();
+    }
 }