feat(transformer): allow expression language for transformer, add provider for custom functions

src/AutoMapper.php

@@ -11,10 +11,12 @@
 use AutoMapper\Loader\EvalLoader;
 use AutoMapper\Loader\FileLoader;
 use AutoMapper\Metadata\MetadataRegistry;
+use AutoMapper\Symfony\ExpressionLanguageProvider;
 use AutoMapper\Transformer\PropertyTransformer\PropertyTransformerInterface;
 use AutoMapper\Transformer\PropertyTransformer\PropertyTransformerRegistry;
 use AutoMapper\Transformer\TransformerFactoryInterface;
 use Doctrine\Common\Annotations\AnnotationReader;
+use Symfony\Component\ExpressionLanguage\ExpressionLanguage;
 use Symfony\Component\Serializer\Mapping\ClassDiscriminatorFromClassMetadata;
 use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactory;
 use Symfony\Component\Serializer\Mapping\Loader\AnnotationLoader;
@@ -42,6 +44,7 @@ public function __construct(
         private readonly ClassLoaderInterface $classLoader,
         private readonly PropertyTransformerRegistry $propertyTransformerRegistry,
         private readonly MetadataRegistry $metadataRegistry,
+        private readonly ?ExpressionLanguageProvider $expressionLanguageProvider = null,
     ) {
     }
 
@@ -75,6 +78,10 @@ public function getMapper(string $source, string $target): MapperInterface
         $mapper->injectMappers($this);
         $mapper->setPropertyTransformers($this->propertyTransformerRegistry->getPropertyTransformers());
 
+        if (null !== $this->expressionLanguageProvider) {
+            $mapper->setExpressionLanguageProvider($this->expressionLanguageProvider);
+        }
+
         /** @var GeneratedMapper<Source, Target>|GeneratedMapper<array<mixed>, Target>|GeneratedMapper<Source, array<mixed>> */
         return $this->mapperRegistry[$className];
     }
@@ -126,6 +133,7 @@ public static function create(
         AdvancedNameConverterInterface $nameConverter = null,
         array $transformerFactories = [],
         iterable $propertyTransformers = [],
+        ExpressionLanguageProvider $expressionLanguageProvider = null,
     ): self {
         if (class_exists(AttributeLoader::class)) {
             $loaderClass = new AttributeLoader();
@@ -135,6 +143,12 @@ public static function create(
             $loaderClass = null;
         }
 
+        $expressionLanguage = new ExpressionLanguage();
+
+        if (null !== $expressionLanguageProvider) {
+            $expressionLanguage->registerProvider($expressionLanguageProvider);
+        }
+
         $classMetadataFactory = null;
         $classDiscriminatorFromClassMetadata = null;
 
@@ -144,11 +158,12 @@ public static function create(
         }
 
         $customTransformerRegistry = new PropertyTransformerRegistry($propertyTransformers);
-        $metadataRegistry = MetadataRegistry::create($configuration, $customTransformerRegistry, $transformerFactories, $classMetadataFactory, $nameConverter);
+        $metadataRegistry = MetadataRegistry::create($configuration, $customTransformerRegistry, $transformerFactories, $classMetadataFactory, $nameConverter, $expressionLanguage);
 
         $mapperGenerator = new MapperGenerator(
             new ClassDiscriminatorResolver($classDiscriminatorFromClassMetadata),
             $configuration,
+            $expressionLanguage,
         );
 
         if (null === $cacheDirectory) {
@@ -157,6 +172,6 @@ public static function create(
             $loader = new FileLoader($mapperGenerator, $metadataRegistry, $cacheDirectory);
         }
 
-        return new self($loader, $customTransformerRegistry, $metadataRegistry);
+        return new self($loader, $customTransformerRegistry, $metadataRegistry, $expressionLanguageProvider);
     }
 }

src/EventListener/MapListener.php

@@ -8,10 +8,13 @@
 use AutoMapper\Attribute\MapTo;
 use AutoMapper\Exception\BadMapDefinitionException;
 use AutoMapper\Transformer\CallableTransformer;
+use AutoMapper\Transformer\ExpressionLanguageTransformer;
 use AutoMapper\Transformer\PropertyTransformer\PropertyTransformer;
 use AutoMapper\Transformer\PropertyTransformer\PropertyTransformerInterface;
 use AutoMapper\Transformer\PropertyTransformer\PropertyTransformerRegistry;
 use AutoMapper\Transformer\TransformerInterface;
+use Symfony\Component\ExpressionLanguage\ExpressionLanguage;
+use Symfony\Component\ExpressionLanguage\SyntaxError;
 use Symfony\Component\PropertyInfo\Extractor\ReflectionExtractor;
 use Symfony\Component\String\Inflector\EnglishInflector;
 use Symfony\Component\String\Inflector\InflectorInterface;
@@ -23,6 +26,7 @@
 {
     public function __construct(
         private PropertyTransformerRegistry $propertyTransformerRegistry,
+        private ExpressionLanguage $expressionLanguage,
         private InflectorInterface $inflector = new EnglishInflector(),
     ) {
     }
@@ -46,23 +50,22 @@ protected function getTransformerFromMapAttribute(string $class, MapTo|MapFrom $
                 $transformer = new PropertyTransformer($transformerCallable);
             } elseif (\is_callable($transformerCallable, false, $callableName)) {
                 $transformer = new CallableTransformer($callableName);
-            } elseif (\is_string($transformerCallable)) {
-                // Check the method exist on the class
-                if (!method_exists($class, $transformerCallable)) {
-                    if (class_exists($transformerCallable)) {
-                        throw new BadMapDefinitionException(sprintf('Transformer "%s" targeted by %s transformer does not exist on class "%s", did you register it ?.', $transformerCallable, $attribute::class, $class));
-                    }
-
-                    throw new BadMapDefinitionException(sprintf('Method "%s" targeted by %s transformer does not exist on class "%s".', $transformerCallable, $attribute::class, $class));
-                }
-
+            } elseif (\is_string($transformerCallable) && method_exists($class, $transformerCallable)) {
                 $reflMethod = new \ReflectionMethod($class, $transformerCallable);
 
                 if ($reflMethod->isStatic()) {
                     $transformer = new CallableTransformer($class . '::' . $transformerCallable);
                 } else {
                     $transformer = new CallableTransformer($transformerCallable, $fromSource, !$fromSource);
                 }
+            } elseif (\is_string($transformerCallable)) {
+                try {
+                    $expression = $this->expressionLanguage->compile($transformerCallable, ['value' => 'source', 'context']);
+                } catch (SyntaxError $e) {
+                    throw new BadMapDefinitionException(sprintf('Transformer "%s" targeted by %s transformer on class "%s" is not valid.', $transformerCallable, $attribute::class, $class), 0, $e);
+                }
+
+                $transformer = new ExpressionLanguageTransformer($expression);
             } else {
                 throw new BadMapDefinitionException(sprintf('Callable "%s" targeted by %s transformer on class "%s" is not valid.', json_encode($transformerCallable), $attribute::class, $class));
             }

src/EventListener/Symfony/AdvancedNameConverterListener.php

@@ -16,11 +16,11 @@ public function __construct(
 
     public function __invoke(PropertyMetadataEvent $event): void
     {
-        if ($event->mapperMetadata->source === 'array' || $event->mapperMetadata->source === \stdClass::class) {
+        if (($event->mapperMetadata->source === 'array' || $event->mapperMetadata->source === \stdClass::class) && $event->source->name === $event->target->name) {
             $event->source->name = $this->nameConverter->denormalize($event->target->name, $event->mapperMetadata->target);
         }
 
-        if ($event->mapperMetadata->target === 'array' || $event->mapperMetadata->target === \stdClass::class) {
+        if (($event->mapperMetadata->target === 'array' || $event->mapperMetadata->target === \stdClass::class) && $event->source->name === $event->target->name) {
             $event->target->name = $this->nameConverter->normalize($event->source->name, $event->mapperMetadata->source);
         }
     }

src/GeneratedMapper.php

@@ -4,6 +4,7 @@
 
 namespace AutoMapper;
 
+use AutoMapper\Symfony\ExpressionLanguageProvider;
 use AutoMapper\Transformer\PropertyTransformer\PropertyTransformerInterface;
 
 /**
@@ -38,6 +39,8 @@ abstract class GeneratedMapper implements MapperInterface
     /** @var array<string, PropertyTransformerInterface> */
     protected array $transformers = [];
 
+    protected ?ExpressionLanguageProvider $expressionLanguageProvider = null;
+
     /**
      * Inject sub mappers.
      */
@@ -62,4 +65,9 @@ public function setPropertyTransformers(array $transformers): void
     {
         $this->transformers = $transformers;
     }
+
+    public function setExpressionLanguageProvider(ExpressionLanguageProvider $expressionLanguageProvider): void
+    {
+        $this->expressionLanguageProvider = $expressionLanguageProvider;
+    }
 }

src/Generator/MapMethodStatementsGenerator.php

@@ -28,7 +28,7 @@
     public function __construct(
         DiscriminatorStatementsGenerator $discriminatorStatementsGenerator,
         CachedReflectionStatementsGenerator $cachedReflectionStatementsGenerator,
-        ExpressionLanguage $expressionLanguage = new ExpressionLanguage(),
+        ExpressionLanguage $expressionLanguage,
         private bool $allowReadOnlyTargetToPopulate = false,
     ) {
         $this->createObjectStatementsGenerator = new CreateTargetStatementsGenerator(

src/Generator/MapperGenerator.php

@@ -37,7 +37,7 @@
     public function __construct(
         ClassDiscriminatorResolver $classDiscriminatorResolver,
         Configuration $configuration,
-        ExpressionLanguage $expressionLanguage = new ExpressionLanguage()
+        ExpressionLanguage $expressionLanguage,
     ) {
         $this->mapperConstructorGenerator = new MapperConstructorGenerator(
             $cachedReflectionStatementsGenerator = new CachedReflectionStatementsGenerator()

src/Generator/PropertyConditionsGenerator.php

@@ -32,7 +32,7 @@ class_alias(Expr\ArrayItem::class, ArrayItem::class);
     private Parser $parser;
 
     public function __construct(
-        private ExpressionLanguage $expressionLanguage = new ExpressionLanguage(),
+        private ExpressionLanguage $expressionLanguage,
         Parser $parser = null,
     ) {
         $this->parser = $parser ?? (new ParserFactory())->createForHostVersion();
@@ -247,7 +247,9 @@ private function customCondition(GeneratorMetadata $metadata, PropertyMetadata $
                             new Arg(new Expr\Variable('value')),
                         ]
                     );
-                } elseif ($argumentsCount > 2) {
+                }
+
+                if ($argumentsCount > 2) {
                     throw new \LogicException('Callable condition must have 1 or 2 arguments required, but it has ' . $argumentsCount);
                 }
             }
@@ -259,7 +261,9 @@ private function customCondition(GeneratorMetadata $metadata, PropertyMetadata $
                     new Arg(new Expr\Variable('context')),
                 ]
             );
-        } elseif ($metadata->mapperMetadata->sourceReflectionClass !== null && $metadata->mapperMetadata->sourceReflectionClass->hasMethod($propertyMetadata->if)) {
+        }
+
+        if ($metadata->mapperMetadata->sourceReflectionClass !== null && $metadata->mapperMetadata->sourceReflectionClass->hasMethod($propertyMetadata->if)) {
             $reflectionMethod = $metadata->mapperMetadata->sourceReflectionClass->getMethod($propertyMetadata->if);
 
             if ($reflectionMethod->isStatic()) {

src/Generator/PropertyStatementsGenerator.php

@@ -22,7 +22,7 @@
     private PropertyConditionsGenerator $propertyConditionsGenerator;
 
     public function __construct(
-        ExpressionLanguage $expressionLanguage = new ExpressionLanguage()
+        ExpressionLanguage $expressionLanguage
     ) {
         $this->propertyConditionsGenerator = new PropertyConditionsGenerator($expressionLanguage);
     }

src/Metadata/MetadataRegistry.php

@@ -36,6 +36,7 @@
 use AutoMapper\Transformer\UniqueTypeTransformerFactory;
 use Symfony\Component\EventDispatcher\EventDispatcher;
 use Symfony\Component\EventDispatcher\EventDispatcherInterface;
+use Symfony\Component\ExpressionLanguage\ExpressionLanguage;
 use Symfony\Component\PropertyInfo\Extractor\PhpStanExtractor;
 use Symfony\Component\PropertyInfo\Extractor\ReflectionExtractor;
 use Symfony\Component\PropertyInfo\PropertyInfoExtractor;
@@ -232,6 +233,7 @@ public static function create(
         array $transformerFactories = [],
         ClassMetadataFactory $classMetadataFactory = null,
         AdvancedNameConverterInterface $nameConverter = null,
+        ExpressionLanguage $expressionLanguage = new ExpressionLanguage(),
     ): self {
         // Create property info extractors
         $flags = ReflectionExtractor::ALLOW_PUBLIC;
@@ -255,8 +257,8 @@ public static function create(
         }
 
         $eventDispatcher->addListener(PropertyMetadataEvent::class, new MapToContextListener($reflectionExtractor));
-        $eventDispatcher->addListener(GenerateMapperEvent::class, new MapToListener($customTransformerRegistry));
-        $eventDispatcher->addListener(GenerateMapperEvent::class, new MapFromListener($customTransformerRegistry));
+        $eventDispatcher->addListener(GenerateMapperEvent::class, new MapToListener($customTransformerRegistry, $expressionLanguage));
+        $eventDispatcher->addListener(GenerateMapperEvent::class, new MapFromListener($customTransformerRegistry, $expressionLanguage));
 
         $propertyInfoExtractor = new PropertyInfoExtractor(
             listExtractors: [$reflectionExtractor],

src/Symfony/Attribute/AsAutoMapperExpressionService.php

@@ -0,0 +1,48 @@
+<?php
+
+declare(strict_types=1);
+
+namespace AutoMapper\Symfony\Attribute;
+
+use Symfony\Component\DependencyInjection\Attribute\AutoconfigureTag;
+
+/**
+ * Service tag to autoconfigure auto mapper expression services.
+ *
+ * You can tag a service:
+ *
+ *     #[AsAutoMapperExpressionService('foo')]
+ *     class SomeFooService
+ *     {
+ *         public function bar(DummyObject $object): string
+ *         {
+ *             // ...
+ *         }
+ *
+ *         public function isOk(): bool
+ *         {
+ *             // ...
+ *         }
+ *
+ * Then you can use the tagged service in the transformer or check property of MapTo / MapFrom attribute
+ *
+ *     class DummyObject
+ *     {
+ *        #[MapTo('array', transformer: 'service("foo").bar(source)', if: 'service("foo").isOk()')]
+ *        public string $foo;
+ *     }
+ */
+#[\Attribute(\Attribute::TARGET_CLASS)]
+class AsAutoMapperExpressionService extends AutoconfigureTag
+{
+    /**
+     * @param string|null $alias    The alias of the service to use it in routing condition expressions
+     * @param int         $priority Defines a priority that allows the routing condition service to override a service with the same alias
+     */
+    public function __construct(
+        ?string $alias = null,
+        int $priority = 0,
+    ) {
+        parent::__construct('automapper.expression_service', ['alias' => $alias, 'priority' => $priority]);
+    }
+}

src/Symfony/Bundle/DependencyInjection/AutoMapperExtension.php

@@ -43,6 +43,7 @@ public function load(array $configs, ContainerBuilder $container): void
         $loader->load('automapper.php');
         $loader->load('custom_transformers.php');
         $loader->load('event.php');
+        $loader->load('expression_language.php');
         $loader->load('generator.php');
         $loader->load('metadata.php');
         $loader->load('symfony.php');

src/Symfony/Bundle/config/automapper.php

@@ -13,6 +13,7 @@
 use AutoMapper\Loader\EvalLoader;
 use AutoMapper\Loader\FileLoader;
 use AutoMapper\Metadata\MetadataRegistry;
+use AutoMapper\Symfony\ExpressionLanguageProvider;
 use AutoMapper\Transformer\PropertyTransformer\PropertyTransformerRegistry;
 
 return static function (ContainerConfigurator $container) {
@@ -22,6 +23,7 @@
                 service(ClassLoaderInterface::class),
                 service(PropertyTransformerRegistry::class),
                 service(MetadataRegistry::class),
+                service(ExpressionLanguageProvider::class),
             ])
             ->alias(AutoMapperInterface::class, AutoMapper::class)->public()
             ->alias(AutoMapperRegistryInterface::class, AutoMapper::class)->public()

src/Symfony/Bundle/config/event.php

@@ -19,10 +19,10 @@
             ->args([service('automapper.property_info.reflection_extractor')])
             ->tag('kernel.event_listener', ['event' => PropertyMetadataEvent::class, 'priority' => 64])
         ->set(MapToListener::class)
-            ->args([service(PropertyTransformerRegistry::class)])
+            ->args([service(PropertyTransformerRegistry::class), service('automapper.expression_language')])
             ->tag('kernel.event_listener', ['event' => GenerateMapperEvent::class, 'priority' => 64])
         ->set(MapFromListener::class)
-            ->args([service(PropertyTransformerRegistry::class)])
+            ->args([service(PropertyTransformerRegistry::class), service('automapper.expression_language')])
             ->tag('kernel.event_listener', ['event' => GenerateMapperEvent::class, 'priority' => 32])
 
         ->set(AdvancedNameConverterListener::class)

src/Symfony/Bundle/config/expression_language.php

@@ -0,0 +1,38 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Symfony\Component\DependencyInjection\Loader\Configurator;
+
+use AutoMapper\Symfony\ExpressionLanguageProvider;
+use Symfony\Component\DependencyInjection\ExpressionLanguage;
+
+return static function (ContainerConfigurator $container) {
+    $container->services()
+        ->set('automapper.expression_language', ExpressionLanguage::class)
+            ->call('registerProvider', [
+                service(ExpressionLanguageProvider::class),
+            ])
+
+        ->set(ExpressionLanguageProvider::class)
+            ->args([
+                tagged_locator('automapper.expression_language_function', 'function'),
+            ])
+            ->tag('automapper.expression_language_provider')
+
+        ->set('automapper.expression_language.env', \Closure::class)
+            ->factory([\Closure::class, 'fromCallable'])
+            ->args([
+                [service('service_container'), 'getEnv'],
+            ])
+            ->tag('automapper.expression_language_function', ['function' => 'env'])
+
+        ->set('automapper.expression_language.service', \Closure::class)
+            ->public()
+            ->factory([\Closure::class, 'fromCallable'])
+            ->args([
+                [tagged_locator('automapper.expression_service', 'alias'), 'get'],
+            ])
+            ->tag('automapper.expression_language_function', ['function' => 'service'])
+    ;
+};

src/Symfony/Bundle/config/generator.php

@@ -15,6 +15,7 @@
             ->args([
                 service(ClassDiscriminatorResolver::class),
                 service(Configuration::class),
+                service('automapper.expression_language'),
             ])
 
         ->set(ClassDiscriminatorResolver::class)