feat(mapper): allow to merge existing values by extracting identifiers

Author: joelwurtz

src/Attribute/MapIdentifier.php

@@ -0,0 +1,10 @@
+<?php
+
+declare(strict_types=1);
+
+namespace AutoMapper\Attribute;
+
+#[\Attribute(\Attribute::TARGET_PROPERTY | \Attribute::TARGET_METHOD | \Attribute::TARGET_PARAMETER)]
+final readonly class MapIdentifier
+{
+}

src/Event/PropertyMetadataEvent.php

@@ -32,6 +32,7 @@ public function __construct(
         public int $priority = 0,
         public readonly bool $isFromDefaultExtractor = false,
         public ?bool $extractTypesFromGetter = null,
+        public ?bool $identifier = null,
     ) {
     }
 }

src/Extractor/MappingExtractor.php

@@ -4,8 +4,10 @@
 
 namespace AutoMapper\Extractor;
 
+use AutoMapper\Attribute\MapIdentifier;
 use AutoMapper\Configuration;
 use AutoMapper\Event\PropertyMetadataEvent;
+use AutoMapper\Metadata\TargetPropertyMetadata;
 use Symfony\Component\PropertyInfo\PropertyInfoExtractorInterface;
 use Symfony\Component\PropertyInfo\PropertyReadInfo;
 use Symfony\Component\PropertyInfo\PropertyReadInfoExtractorInterface;
@@ -187,4 +189,72 @@ public function getDateTimeFormat(PropertyMetadataEvent $propertyMetadataEvent):
 
         return $this->configuration->dateTimeFormat;
     }
+
+    public function isIdentifier(?\ReflectionClass $targetReflectionClass, TargetPropertyMetadata $target): bool
+    {
+        if ($targetReflectionClass === null) {
+            return false;
+        }
+
+        // check on reflection property
+        if ($targetReflectionClass->hasProperty($target->property)) {
+            $reflectionProperty = $targetReflectionClass->getProperty($target->property);
+
+            if (\count($reflectionProperty->getAttributes(MapIdentifier::class)) > 0) {
+                return true;
+            }
+        }
+
+        // check on the getter to read, it may not be defined yet so we cannot skip this everytime
+        if ($target->readAccessor !== null) {
+            // check with read accessor on property
+            if ($target->readAccessor->type === ReadAccessor::TYPE_PROPERTY && $targetReflectionClass->hasProperty(
+                $target->readAccessor->property
+            )) {
+                $reflectionProperty = $targetReflectionClass->getProperty(
+                    $target->readAccessor->property
+                );
+
+                if (\count($reflectionProperty->getAttributes(MapIdentifier::class)) > 0) {
+                    return true;
+                }
+            }
+
+            // check with read accessor on method
+            if ($target->readAccessor->type === ReadAccessor::TYPE_METHOD && $targetReflectionClass->hasMethod(
+                $target->readAccessor->property
+            )) {
+                $reflectionMethod = $targetReflectionClass->getMethod(
+                    $target->readAccessor->property
+                );
+
+                if (\count($reflectionMethod->getAttributes(MapIdentifier::class)) > 0) {
+                    return true;
+                }
+            }
+        }
+
+        // same for the write mutator, we cannot globally skip this check as it may be defined latter
+        if ($target->writeMutator !== null) {
+            // check for property
+            if ($target->writeMutator->type === WriteMutator::TYPE_PROPERTY && $targetReflectionClass->hasProperty($target->writeMutator->property)) {
+                $reflectionProperty = $targetReflectionClass->getProperty(
+                    $target->writeMutator->property
+                );
+
+                if (\count($reflectionProperty->getAttributes(MapIdentifier::class)) > 0) {
+                    return true;
+                }
+            }
+
+            // check for parameter in constructor
+            if ($target->writeMutator->type === WriteMutator::TYPE_CONSTRUCTOR && $target->writeMutator->parameter !== null) {
+                if (\count($target->writeMutator->parameter->getAttributes(MapIdentifier::class)) > 0) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
 }

src/Extractor/MappingExtractorInterface.php

@@ -49,4 +49,9 @@ public function getReadAccessor(string $class, string $property): ?ReadAccessor;
      * @param array<string, mixed> $context
      */
     public function getWriteMutator(string $source, string $target, string $property, array $context = []): ?WriteMutator;
+
+    /**
+     * Check if a property is an identifier.
+     */
+    public function isIdentifier(?\ReflectionClass $targetReflectionClass, TargetPropertyMetadata $target): bool;
 }

src/Extractor/ReadAccessor.php

@@ -32,17 +32,24 @@ final class ReadAccessor
     public const TYPE_SOURCE = 4;
     public const TYPE_ARRAY_ACCESS = 5;
 
+    public const EXTRACT_IS_UNDEFINED_CALLBACK = 'extractIsUndefinedCallbacks';
+    public const EXTRACT_IS_NULL_CALLBACK = 'extractIsNullCallbacks';
+    public const EXTRACT_CALLBACK = 'extractCallbacks';
+    public const EXTRACT_TARGET_IS_UNDEFINED_CALLBACK = 'extractTargetIsUndefinedCallbacks';
+    public const EXTRACT_TARGET_IS_NULL_CALLBACK = 'extractTargetIsNullCallbacks';
+    public const EXTRACT_TARGET_CALLBACK = 'extractTargetCallbacks';
+
     /**
      * @param array<string, string> $context
      */
     public function __construct(
-        private readonly int $type,
-        private readonly string $accessor,
-        private readonly ?string $sourceClass = null,
-        private readonly bool $private = false,
-        private readonly ?string $property = null,
+        public readonly int $type,
+        public readonly string $accessor,
+        public readonly ?string $sourceClass = null,
+        public readonly bool $private = false,
+        public readonly ?string $property = null,
         // will be the name of the property if different from accessor
-        private readonly array $context = [],
+        public readonly array $context = [],
     ) {
         if (self::TYPE_METHOD === $this->type && null === $this->sourceClass) {
             throw new InvalidArgumentException('Source class must be provided when using "method" type.');
@@ -54,7 +61,7 @@ public function __construct(
      *
      * @throws CompileException
      */
-    public function getExpression(Expr $input): Expr
+    public function getExpression(Expr $input, bool $target = false): Expr
     {
         if (self::TYPE_METHOD === $this->type) {
             $methodCallArguments = [];
@@ -99,7 +106,7 @@ public function getExpression(Expr $input): Expr
                  * $this->extractCallbacks['method_name']($input)
                  */
                 return new Expr\FuncCall(
-                    new Expr\ArrayDimFetch(new Expr\PropertyFetch(new Expr\Variable('this'), 'extractCallbacks'), new Scalar\String_($this->property ?? $this->accessor)),
+                    new Expr\ArrayDimFetch(new Expr\PropertyFetch(new Expr\Variable('this'), $target ? self::EXTRACT_TARGET_CALLBACK : self::EXTRACT_CALLBACK), new Scalar\String_($this->property ?? $this->accessor)),
                     [
                         new Arg($input),
                     ]
@@ -124,7 +131,7 @@ public function getExpression(Expr $input): Expr
                  * $this->extractCallbacks['property_name']($input)
                  */
                 return new Expr\FuncCall(
-                    new Expr\ArrayDimFetch(new Expr\PropertyFetch(new Expr\Variable('this'), 'extractCallbacks'), new Scalar\String_($this->accessor)),
+                    new Expr\ArrayDimFetch(new Expr\PropertyFetch(new Expr\Variable('this'), $target ? self::EXTRACT_TARGET_CALLBACK : self::EXTRACT_CALLBACK), new Scalar\String_($this->accessor)),
                     [
                         new Arg($input),
                     ]
@@ -155,7 +162,7 @@ public function getExpression(Expr $input): Expr
         throw new CompileException('Invalid accessor for read expression');
     }
 
-    public function getIsDefinedExpression(Expr\Variable $input, bool $nullable = false): ?Expr
+    public function getIsDefinedExpression(Expr\Variable $input, bool $nullable = false, bool $target = false): ?Expr
     {
         // It is not possible to check if the underlying data is defined, assumes it is, php will throw an error if it is not
         if (!$nullable && \in_array($this->type, [self::TYPE_METHOD, self::TYPE_SOURCE])) {
@@ -172,7 +179,7 @@ public function getIsDefinedExpression(Expr\Variable $input, bool $nullable = fa
                  * !$this->extractIsUndefinedCallbacks['property_name']($input)
                  */
                 return new Expr\BooleanNot(new Expr\FuncCall(
-                    new Expr\ArrayDimFetch(new Expr\PropertyFetch(new Expr\Variable('this'), 'extractIsUndefinedCallbacks'), new Scalar\String_($this->accessor)),
+                    new Expr\ArrayDimFetch(new Expr\PropertyFetch(new Expr\Variable('this'), $target ? self::EXTRACT_TARGET_IS_UNDEFINED_CALLBACK : self::EXTRACT_IS_UNDEFINED_CALLBACK), new Scalar\String_($this->accessor)),
                     [
                         new Arg($input),
                     ]
@@ -212,7 +219,7 @@ public function getIsDefinedExpression(Expr\Variable $input, bool $nullable = fa
         return null;
     }
 
-    public function getIsNullExpression(Expr\Variable $input): Expr
+    public function getIsNullExpression(Expr\Variable $input, bool $target = false): Expr
     {
         if (self::TYPE_METHOD === $this->type) {
             $methodCallExpr = $this->getExpression($input);
@@ -236,7 +243,7 @@ public function getIsNullExpression(Expr\Variable $input): Expr
                  * $this->extractIsNullCallbacks['property_name']($input)
                  */
                 return new Expr\FuncCall(
-                    new Expr\ArrayDimFetch(new Expr\PropertyFetch(new Expr\Variable('this'), 'extractIsNullCallbacks'), new Scalar\String_($this->accessor)),
+                    new Expr\ArrayDimFetch(new Expr\PropertyFetch(new Expr\Variable('this'), $target ? self::EXTRACT_TARGET_IS_NULL_CALLBACK : self::EXTRACT_IS_NULL_CALLBACK), new Scalar\String_($this->accessor)),
                     [
                         new Arg($input),
                     ]
@@ -270,7 +277,7 @@ public function getIsNullExpression(Expr\Variable $input): Expr
         throw new CompileException('Invalid accessor for read expression');
     }
 
-    public function getIsUndefinedExpression(Expr\Variable $input): Expr
+    public function getIsUndefinedExpression(Expr\Variable $input, bool $target = false): Expr
     {
         if (\in_array($this->type, [self::TYPE_METHOD, self::TYPE_SOURCE])) {
             /*
@@ -289,7 +296,7 @@ public function getIsUndefinedExpression(Expr\Variable $input): Expr
                  * $this->extractIsUndefinedCallbacks['property_name']($input)
                  */
                 return new Expr\FuncCall(
-                    new Expr\ArrayDimFetch(new Expr\PropertyFetch(new Expr\Variable('this'), 'extractIsUndefinedCallbacks'), new Scalar\String_($this->accessor)),
+                    new Expr\ArrayDimFetch(new Expr\PropertyFetch(new Expr\Variable('this'), $target ? self::EXTRACT_TARGET_IS_UNDEFINED_CALLBACK : self::EXTRACT_IS_UNDEFINED_CALLBACK), new Scalar\String_($this->accessor)),
                     [
                         new Arg($input),
                     ]

src/Extractor/WriteMutator.php

@@ -32,8 +32,8 @@ final class WriteMutator
 
     public function __construct(
         public readonly int $type,
-        private readonly string $property,
-        private readonly bool $private = false,
+        public readonly string $property,
+        public readonly bool $private = false,
         public readonly ?\ReflectionParameter $parameter = null,
         private readonly ?string $removeMethodName = null,
     ) {

src/GeneratedMapper.php

@@ -36,6 +36,11 @@ public function registerMappers(AutoMapperRegistryInterface $registry): void
     {
     }
 
+    public function areIdentifiersEquals(mixed $source, mixed $target): bool
+    {
+        return false;
+    }
+
     /** @var array<string, MapperInterface<object, object>|MapperInterface<object, array<mixed>>|MapperInterface<array<mixed>, object>> */
     protected array $mappers = [];
 
@@ -51,6 +56,15 @@ public function registerMappers(AutoMapperRegistryInterface $registry): void
     /** @var array<string, callable(): bool>) */
     protected array $extractIsUndefinedCallbacks = [];
 
+    /** @var array<string, callable(): mixed> */
+    protected array $extractTargetCallbacks = [];
+
+    /** @var array<string, callable(): bool>) */
+    protected array $extractTargetIsNullCallbacks = [];
+
+    /** @var array<string, callable(): bool>) */
+    protected array $extractTargetIsUndefinedCallbacks = [];
+
     /** @var Target|\ReflectionClass<object> */
     protected mixed $cachedTarget;
 }

src/Generator/IdentifierEqualGenerator.php

@@ -0,0 +1,83 @@
+<?php
+
+declare(strict_types=1);
+
+namespace AutoMapper\Generator;
+
+use AutoMapper\Metadata\GeneratorMetadata;
+use PhpParser\Node\Expr;
+use PhpParser\Node\Name;
+use PhpParser\Node\Stmt;
+
+final readonly class IdentifierEqualGenerator
+{
+    /**
+     * @return list<Stmt>
+     */
+    public function getStatements(GeneratorMetadata $metadata): array
+    {
+        $identifiers = [];
+
+        foreach ($metadata->propertiesMetadata as $propertyMetadata) {
+            if (!$propertyMetadata->identifier) {
+                continue;
+            }
+
+            if (null === $propertyMetadata->target->readAccessor) {
+                continue;
+            }
+
+            if (null === $propertyMetadata->source->accessor) {
+                continue;
+            }
+
+            $identifiers[] = $propertyMetadata;
+        }
+
+        if (empty($identifiers)) {
+            return [];
+        }
+
+        $statements = [];
+
+        $sourceVariable = new Expr\Variable('source');
+        $targetVariable = new Expr\Variable('target');
+
+        // foreach property we check
+        foreach ($identifiers as $property) {
+            // check if the source is defined
+            if ($property->source->checkExists) {
+                $statements[] = new Stmt\If_($property->source->accessor->getIsUndefinedExpression($sourceVariable), [
+                    'stmts' => [
+                        new Stmt\Return_(new Expr\ConstFetch(new Name('false'))),
+                    ],
+                ]);
+            }
+
+            // check if the target is defined
+            $statements[] = new Stmt\If_($property->target->readAccessor->getIsUndefinedExpression($targetVariable, true), [
+                'stmts' => [
+                    new Stmt\Return_(new Expr\ConstFetch(new Name('false'))),
+                ],
+            ]);
+
+            // add the identifier check
+            $statements[] = new Stmt\If_(
+                new Expr\BinaryOp\NotIdentical(
+                    $property->source->accessor->getExpression($sourceVariable),
+                    $property->target->readAccessor->getExpression($targetVariable, true)
+                ),
+                [
+                    'stmts' => [
+                        new Stmt\Return_(new Expr\ConstFetch(new Name('false'))),
+                    ],
+                ]
+            );
+        }
+
+        // return true as everything is ok
+        $statements[] = new Stmt\Return_(new Expr\ConstFetch(new Name('true')));
+
+        return $statements;
+    }
+}