Merge pull request #319 from jolicode/feat/discriminator

feat(discriminator): add discriminator def, support class to class discriminator

Author: joelwurtz

src/Attribute/Mapper.php

@@ -5,6 +5,7 @@
 namespace AutoMapper\Attribute;
 
 use AutoMapper\ConstructorStrategy;
+use AutoMapper\Metadata\Discriminator;
 
 /**
  * Configures a mapper.
@@ -27,6 +28,7 @@ public function __construct(
         public int $priority = 0,
         public ?string $dateTimeFormat = null,
         public ?bool $allowExtraProperties = null,
+        public ?Discriminator $discriminator = null,
     ) {
     }
 }

src/AutoMapper.php

@@ -25,7 +25,6 @@
 use Symfony\Component\ExpressionLanguage\ExpressionLanguage;
 use Symfony\Component\Lock\LockFactory;
 use Symfony\Component\Lock\Store\FlockStore;
-use Symfony\Component\Serializer\Mapping\ClassDiscriminatorFromClassMetadata;
 use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactory;
 use Symfony\Component\Serializer\Mapping\Loader\AttributeLoader;
 use Symfony\Component\Serializer\NameConverter\NameConverterInterface;
@@ -157,11 +156,9 @@ public static function create(
         }
 
         $classMetadataFactory = null;
-        $classDiscriminatorFromClassMetadata = null;
 
         if (class_exists(ClassMetadataFactory::class) && $loaderClass !== null) {
             $classMetadataFactory = new ClassMetadataFactory($loaderClass);
-            $classDiscriminatorFromClassMetadata = new ClassDiscriminatorFromClassMetadata($classMetadataFactory);
         }
 
         $providers = iterator_to_array($providers);
@@ -194,7 +191,7 @@ public static function create(
         }
 
         $metadataRegistry = new MetadataRegistry($configuration);
-        $classDiscriminatorResolver = new ClassDiscriminatorResolver($classDiscriminatorFromClassMetadata);
+        $classDiscriminatorResolver = new ClassDiscriminatorResolver();
 
         $metadataFactory = MetadataFactory::create(
             $configuration,

src/Event/GenerateMapperEvent.php

@@ -5,6 +5,7 @@
 namespace AutoMapper\Event;
 
 use AutoMapper\ConstructorStrategy;
+use AutoMapper\Metadata\Discriminator;
 use AutoMapper\Metadata\MapperMetadata;
 
 /**
@@ -24,6 +25,8 @@ public function __construct(
         public ?bool $allowReadOnlyTargetToPopulate = null,
         public ?bool $strictTypes = null,
         public ?bool $allowExtraProperties = null,
+        public ?Discriminator $sourceDiscriminator = null,
+        public ?Discriminator $targetDiscriminator = null,
     ) {
     }
 }

src/EventListener/MapperListener.php

@@ -18,7 +18,7 @@ public function __construct()
 
     public function __invoke(GenerateMapperEvent $event): void
     {
-        /** @var Mapper[] $mappers */
+        /** @var array{0: Mapper, 1: bool}[] $mappers */
         $mappers = [];
 
         if ($event->mapperMetadata->sourceReflectionClass) {
@@ -27,15 +27,15 @@ public function __invoke(GenerateMapperEvent $event): void
                 $mapper = $attribute->newInstance();
 
                 if ($mapper->target === null) {
-                    $mappers[] = $mapper;
+                    $mappers[] = [$mapper, true];
                 }
 
                 if (\is_string($mapper->target) && $mapper->target === $event->mapperMetadata->target) {
-                    $mappers[] = $mapper;
+                    $mappers[] = [$mapper, true];
                 }
 
                 if (\is_array($mapper->target) && \in_array($event->mapperMetadata->target, $mapper->target, true)) {
-                    $mappers[] = $mapper;
+                    $mappers[] = [$mapper, true];
                 }
             }
         }
@@ -46,34 +46,41 @@ public function __invoke(GenerateMapperEvent $event): void
                 $mapper = $attribute->newInstance();
 
                 if ($mapper->source === null) {
-                    $mappers[] = $mapper;
+                    $mappers[] = [$mapper, false];
                 }
 
                 if (\is_string($mapper->source) && $mapper->source === $event->mapperMetadata->source) {
-                    $mappers[] = $mapper;
+                    $mappers[] = [$mapper, false];
                 }
 
                 if (\is_array($mapper->source) && \in_array($event->mapperMetadata->source, $mapper->source, true)) {
-                    $mappers[] = $mapper;
+                    $mappers[] = [$mapper, false];
                 }
             }
         }
-
         if (0 === \count($mappers)) {
             return;
         }
 
         // sort by priority
-        usort($mappers, fn (Mapper $a, Mapper $b) => $a->priority <=> $b->priority);
+        usort($mappers, fn (array $a, array $b) => $a[0]->priority <=> $b[0]->priority);
 
         // get mapper with highest priority
-        $mapper = $mappers[0];
+        [$mapper, $fromSource] = $mappers[0];
 
         $event->checkAttributes ??= $mapper->checkAttributes;
         $event->constructorStrategy ??= $mapper->constructorStrategy;
         $event->allowReadOnlyTargetToPopulate ??= $mapper->allowReadOnlyTargetToPopulate;
         $event->strictTypes ??= $mapper->strictTypes;
         $event->allowExtraProperties ??= $mapper->allowExtraProperties;
         $event->mapperMetadata->dateTimeFormat = $mapper->dateTimeFormat;
+
+        if ($mapper->discriminator) {
+            if ($fromSource) {
+                $event->sourceDiscriminator = $mapper->discriminator;
+            } else {
+                $event->targetDiscriminator = $mapper->discriminator;
+            }
+        }
     }
 }

src/EventListener/Symfony/ClassDiscriminatorListener.php

@@ -8,6 +8,7 @@
 use AutoMapper\Event\PropertyMetadataEvent;
 use AutoMapper\Event\SourcePropertyMetadata;
 use AutoMapper\Event\TargetPropertyMetadata;
+use AutoMapper\Metadata\Discriminator;
 use AutoMapper\Transformer\FixedValueTransformer;
 use Symfony\Component\Serializer\Mapping\ClassDiscriminatorMapping;
 use Symfony\Component\Serializer\Mapping\ClassDiscriminatorResolverInterface;
@@ -37,6 +38,14 @@ public function __invoke(GenerateMapperEvent $event): void
                 }
             }
 
+            if (null === $sourceType) {
+                // It means the source is a parent class or interface of the mapped types
+                $event->sourceDiscriminator = new Discriminator(
+                    mapping: $classDiscriminatorMappingSource->getTypesMapping(),
+                    propertyName: $classDiscriminatorMappingSource->getTypeProperty(),
+                );
+            }
+
             $property = $classDiscriminatorMappingSource->getTypeProperty();
             $sourceProperty = new SourcePropertyMetadata($property);
             $targetProperty = new TargetPropertyMetadata($property);
@@ -50,6 +59,23 @@ public function __invoke(GenerateMapperEvent $event): void
         }
 
         if ($classDiscriminatorMappingTarget) {
+            $targetType = null;
+
+            foreach ($classDiscriminatorMappingTarget->getTypesMapping() as $type => $class) {
+                if ($class === $event->mapperMetadata->target) {
+                    $targetType = $type;
+                    break;
+                }
+            }
+
+            if (null === $targetType) {
+                // It means the target is a parent class or interface of the mapped types
+                $event->targetDiscriminator = new Discriminator(
+                    mapping: $classDiscriminatorMappingTarget->getTypesMapping(),
+                    propertyName: $classDiscriminatorMappingTarget->getTypeProperty(),
+                );
+            }
+
             $property = $classDiscriminatorMappingTarget->getTypeProperty();
             $sourceProperty = new SourcePropertyMetadata($property);
             $targetProperty = new TargetPropertyMetadata($property);

src/Generator/MapMethodStatementsGenerator.php

@@ -132,26 +132,32 @@ public function getStatements(GeneratorMetadata $metadata, array $duplicatedStat
              * }
              */
             $lastStatement = $statements[array_key_last($statements)];
-            \assert($lastStatement instanceof Stmt\If_);
-            $lastStatement->stmts = [
-                ...$lastStatement->stmts,
-                ...$addedDependenciesStatements,
-            ];
-            /*
-             * Generate else statements when the result is already an object, which means it has already been created,
-             * so we need to execute the statements that need to be executed before the constructor since the constructor has already been called
-             *
-             * ```php
-             * if (null !== $result) {
-             *     .. // create object statements
-             * } else {
-             *     // remap property from the constructor in case object already exists so we do not loose information
-             *     $source->propertyName = $this->extractCallbacks['propertyName']($source);
-             *     ...
-             * }
-             * ```
-             */
-            $statements[] = new Stmt\Else_(array_merge($addedDependenciesStatements, $duplicatedStatements));
+
+            if ($lastStatement instanceof Stmt\If_) {
+                $lastStatement->stmts = [
+                    ...$lastStatement->stmts,
+                    ...$addedDependenciesStatements,
+                ];
+
+                $statements[] = new Stmt\Else_(array_merge($addedDependenciesStatements, $duplicatedStatements));
+            } else {
+                $statements = [...$statements, ...$addedDependenciesStatements, ...$duplicatedStatements];
+            }
+
+        /*
+         * Generate else statements when the result is already an object, which means it has already been created,
+         * so we need to execute the statements that need to be executed before the constructor since the constructor has already been called
+         *
+         * ```php
+         * if (null !== $result) {
+         *     .. // create object statements
+         * } else {
+         *     // remap property from the constructor in case object already exists so we do not loose information
+         *     $source->propertyName = $this->extractCallbacks['propertyName']($source);
+         *     ...
+         * }
+         * ```
+         */
         } else {
             $statements = [...$statements, ...$addedDependenciesStatements];
         }

src/Generator/Shared/ClassDiscriminatorResolver.php

@@ -6,91 +6,70 @@
 
 use AutoMapper\Metadata\GeneratorMetadata;
 use AutoMapper\Metadata\PropertyMetadata;
-use AutoMapper\Transformer\TransformerInterface;
-use Symfony\Component\Serializer\Mapping\ClassDiscriminatorMapping;
-use Symfony\Component\Serializer\Mapping\ClassDiscriminatorResolverInterface;
+use AutoMapper\Transformer\MapperDependency;
 
 /**
  * @internal
  */
 final readonly class ClassDiscriminatorResolver
 {
-    public function __construct(
-        private ?ClassDiscriminatorResolverInterface $classDiscriminator = null,
-    ) {
-    }
-
     public function hasClassDiscriminator(GeneratorMetadata $metadata, bool $fromSource): bool
     {
-        if (!($fromSource ? $metadata->isSourceUserDefined() : $metadata->isTargetUserDefined())
-            || !($propertyMetadata = $this->getDiscriminatorPropertyMetadata($metadata, $fromSource))
-            || !$propertyMetadata->transformer instanceof TransformerInterface
-        ) {
-            return false;
+        if ($fromSource) {
+            return $metadata->sourceDiscriminator !== null;
         }
 
-        return true;
+        return $metadata->targetDiscriminator !== null;
     }
 
     public function getDiscriminatorPropertyMetadata(GeneratorMetadata $metadata, bool $fromSource): ?PropertyMetadata
     {
-        $classDiscriminatorMapping = $this->classDiscriminator?->getMappingForClass($fromSource ? $metadata->mapperMetadata->source : $metadata->mapperMetadata->target);
+        $discriminator = $fromSource ? $metadata->sourceDiscriminator : $metadata->targetDiscriminator;
 
-        if (!$classDiscriminatorMapping) {
+        if (!$discriminator) {
             return null;
         }
 
-        foreach ($metadata->propertiesMetadata as $propertyMetadata) {
-            if (($fromSource ? $propertyMetadata->source->property : $propertyMetadata->target->property) === $classDiscriminatorMapping->getTypeProperty()) {
-                return $propertyMetadata;
-            }
-        }
-
-        return null;
-    }
-
-    /**
-     * @return array<class-string<object>, string>
-     */
-    public function discriminatorMapperNames(GeneratorMetadata $metadata, bool $fromSource): array
-    {
-        $classDiscriminatorMapping = $this->classDiscriminator?->getMappingForClass($fromSource ? $metadata->mapperMetadata->source : $metadata->mapperMetadata->target);
-
-        if (!$classDiscriminatorMapping) {
-            return [];
+        if ($discriminator->propertyName === null) {
+            return null;
         }
 
-        return array_combine(
-            array_values($classDiscriminatorMapping->getTypesMapping()),
-            $this->discriminatorNames($metadata, $classDiscriminatorMapping, $fromSource)
+        return array_find($metadata->propertiesMetadata,
+            fn ($propertyMetadata,
+            ) => ($fromSource ? $propertyMetadata->source->property : $propertyMetadata->target->property) === $discriminator->propertyName
         );
     }
 
     /**
-     * @return array<string, string>
+     * @return list<MapperDependency>
      */
-    public function discriminatorMapperNamesIndexedByTypeValue(GeneratorMetadata $metadata, bool $fromSource): array
+    public function getMappersList(GeneratorMetadata $metadata, bool $fromSource): array
     {
-        $classDiscriminatorMapping = $this->classDiscriminator?->getMappingForClass($fromSource ? $metadata->mapperMetadata->source : $metadata->mapperMetadata->target);
+        $discriminator = $fromSource ? $metadata->sourceDiscriminator : $metadata->targetDiscriminator;
 
-        if (!$classDiscriminatorMapping) {
+        if (!$discriminator) {
             return [];
         }
 
-        return array_combine(
-            array_keys($classDiscriminatorMapping->getTypesMapping()),
-            $this->discriminatorNames($metadata, $classDiscriminatorMapping, $fromSource)
-        );
-    }
+        $classList = array_values($discriminator->mapping);
+        $typeList = array_keys($discriminator->mapping);
+        $targetClassList = $discriminator->propertyName === null ? $typeList : array_fill(0, \count($classList), $fromSource ? $metadata->mapperMetadata->target : $metadata->mapperMetadata->source);
+        $mappers = [];
+
+        foreach ($classList as $index => $className) {
+            /** @var class-string $sourceClass */
+            $sourceClass = $fromSource ? $className : $targetClassList[$index];
+            /** @var class-string $targetClass */
+            $targetClass = $fromSource ? $targetClassList[$index] : $className;
+
+            $mappers[] = new MapperDependency(
+                name: "Discriminator_Mapper_{$sourceClass}_{$targetClass}",
+                source: $sourceClass,
+                target: $targetClass,
+                type: $typeList[$index],
+            );
+        }
 
-    /**
-     * @return list<string>
-     */
-    private function discriminatorNames(GeneratorMetadata $metadata, ClassDiscriminatorMapping $classDiscriminatorMapping, bool $fromSource): array
-    {
-        return array_map(
-            static fn (string $typeTarget) => $fromSource ? "Discriminator_Mapper_{$typeTarget}_{$metadata->mapperMetadata->target}" : "Discriminator_Mapper_{$metadata->mapperMetadata->source}_{$typeTarget}",
-            $classDiscriminatorMapping->getTypesMapping()
-        );
+        return $mappers;
     }
 }