CQRSApiNormalizer has now the responsibility to handle setters with multiple arguments, DomainSerializer is now much cleaner and is a Serializer itself

Author: jolelievre

phpstan-baseline.neon

@@ -970,6 +970,11 @@ parameters:
 			count: 1
 			path: src/PrestaShopBundle/ApiPlatform/Normalizer/CQRSApiNormalizer.php
 
+		-
+			message: "#^Method Symfony\\\\Component\\\\Serializer\\\\Normalizer\\\\DenormalizerInterface\\:\\:supportsDenormalization\\(\\) invoked with 4 parameters, 2\\-3 required\\.$#"
+			count: 1
+			path: src/PrestaShopBundle/ApiPlatform/Normalizer/CQRSApiNormalizer.php
+
 		-
 			message: "#^Class Employee is forbidden, No legacy calls inside the prestashop bundle\\. Please create an interface and an adapter if you need to\\.$#"
 			count: 1

src/PrestaShopBundle/ApiPlatform/Normalizer/CQRSApiNormalizer.php

@@ -33,30 +33,29 @@
 use PrestaShopBundle\Entity\Repository\LangRepository;
 use ReflectionClass;
 use ReflectionMethod;
+use ReflectionNamedType;
 use ReflectionParameter;
 use Symfony\Component\DependencyInjection\Attribute\AutoconfigureTag;
 use Symfony\Component\PropertyAccess\PropertyAccessorInterface;
 use Symfony\Component\PropertyInfo\PropertyTypeExtractorInterface;
+use Symfony\Component\Serializer\Exception\InvalidArgumentException;
+use Symfony\Component\Serializer\Exception\LogicException;
 use Symfony\Component\Serializer\Mapping\ClassDiscriminatorResolverInterface;
 use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactoryInterface;
 use Symfony\Component\Serializer\NameConverter\NameConverterInterface;
+use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
 use Symfony\Component\Serializer\Normalizer\ObjectNormalizer;
 
 /**
- * This normalizer is based on the Symfony ObjectNormalizer but it handles some specific normalization for
+ * This normalizer is based on the Symfony ObjectNormalizer, but it handles some specific normalization for
  * our CQRS <-> ApiPlatform conversion:
  *  - handle getters that match the property without starting by get, has, is
- *  - normalize ValueObject (when it is the root object), it renames the [value] key based on the ValueObject class name
- *      ex: new ProductId(42); is not normalized as ['value' => 42] but as ['productId' => 42] which most of the time matches
- *          the following DTO object to denormalize and saves adding some extra mapping
- *  - normalize attributes that are ValueObject (so not on the root level) to remove the extra value layer
- *     ex: new CreatedApiAccess(42, 'my_secret') is not normalized as ['apiAccessId' => ['value' => 42], 'secret' => 'my_secret']
- *         but as ['apiAccessId' => 42, 'secret' => 'my_secret']
- *         Again this is useful to help the automatic mapping when denormalizing the following DTO in our workflow
+ *  - set appropriate context for the ValueObjectNormalizer for when we don't want a ValueObject but the scalar value to be used
  *  - converts localized values keys in the arrays:
  *    - the input is indexed by locale ['fr-FR' => 'Nom de la valeur', 'en-US' => 'Value name']
  *    - the data is normalized and indexed by locale ID [1 => 'Nom de la valeur', 2 => 'Value name']
  *    - reversely localized data indexed by IDs are converted into an array localized by locale
+ *  - handle setter methods that use multiple parameters
  */
 #[AutoconfigureTag('prestashop.api.normalizers')]
 class CQRSApiNormalizer extends ObjectNormalizer
@@ -78,6 +77,20 @@ public function __construct(
         parent::__construct($classMetadataFactory, $nameConverter, $propertyAccessor, $propertyTypeExtractor, $classDiscriminatorResolver, $objectClassResolver, $defaultContext);
     }
 
+    /**
+     * This method is overridden because our CQRS objects sometimes have setters with multiple arguments, these are usually used to force specifying arguments that must
+     * be defined all together, so they can be validated as a whole. The ObjectNormalizer only deserialize object properties one at a time, so we have to handle this special
+     * use case and the best moment to do so is right after the object is instantiated and right before the properties are deserialized.
+     */
+    protected function instantiateObject(array &$data, string $class, array &$context, ReflectionClass $reflectionClass, bool|array $allowedAttributes, ?string $format = null)
+    {
+        $object = parent::instantiateObject($data, $class, $context, $reflectionClass, $allowedAttributes, $format);
+        $methodsWithMultipleArguments = $this->findMethodsWithMultipleArguments($reflectionClass, $data);
+        $this->executeMethodsWithMultipleArguments($data, $object, $methodsWithMultipleArguments, $context, $format);
+
+        return $object;
+    }
+
     /**
      * This method is only used to denormalize the constructor parameters, the CQRS classes usually expect scalar input values that
      * are converted into ValueObject in the constructor, so only in this phase of the denormalization we disable the ValueObjectNormalizer
@@ -100,14 +113,19 @@ protected function createChildContext(array $parentContext, string $attribute, ?
         return $childContext + [ValueObjectNormalizer::VALUE_OBJECT_RETURNED_AS_SCALAR => true];
     }
 
+    /**
+     * This method is overridden in order to increase the getters used to fetch attributes, by default the ObjectNormalizer
+     * searches for getters start with get/is/has/can, but it ignores getters that matches the properties exactly.
+     */
     protected function extractAttributes(object $object, ?string $format = null, array $context = []): array
     {
         $attributes = parent::extractAttributes($object, $format, $context);
-
-        // Check methods that may have been ignored by the parent, the parent normalizer only checks getter if they start
-        // with "is" or "get" we increase this behaviour on other potential getters that don't match this convention
-        $metadata = $this->classMetadataFactory->getMetadataFor($object);
-        $reflClass = $metadata->getReflectionClass();
+        if ($this->classMetadataFactory) {
+            $metadata = $this->classMetadataFactory->getMetadataFor($object);
+            $reflClass = $metadata->getReflectionClass();
+        } else {
+            $reflClass = new ReflectionClass(\is_object($object) ? $object::class : $object);
+        }
 
         foreach ($reflClass->getMethods(ReflectionMethod::IS_PUBLIC) as $reflMethod) {
             if (
@@ -121,7 +139,7 @@ protected function extractAttributes(object $object, ?string $format = null, arr
 
             $methodName = $reflMethod->name;
             // These type of getters have already been handled by the parent
-            if (str_starts_with($methodName, 'get') || str_starts_with($methodName, 'has') || str_starts_with($methodName, 'is')) {
+            if (str_starts_with($methodName, 'get') || str_starts_with($methodName, 'has') || str_starts_with($methodName, 'is') || str_starts_with($methodName, 'can')) {
                 continue;
             }
 
@@ -134,17 +152,115 @@ protected function extractAttributes(object $object, ?string $format = null, arr
         return $attributes;
     }
 
+    /**
+     * This method is overridden, so we can dynamically change the localized properties identified by a context or the LocalizedValue
+     * helper attribute. The used key that are based on Language's locale are automatically converted to rely on Language's ID.
+     */
     protected function getAttributeValue(object $object, string $attribute, ?string $format = null, array $context = []): mixed
     {
         $attributeValue = parent::getAttributeValue($object, $attribute, $format, $context);
         if (($context[LocalizedValue::IS_LOCALIZED_VALUE] ?? false) && is_array($attributeValue)) {
-            $attributeValue = $this->indexByID($attributeValue);
+            $attributeValue = $this->updateLanguageIndexesWithIDs($attributeValue);
         }
 
         return $attributeValue;
     }
 
-    protected function indexByID(array $localizedValue): array
+    /**
+     * Call all the method with multiple arguments and remove the data from the normalized data since it has already been denormalized into
+     * the object.
+     *
+     * @param array $data
+     * @param object $object
+     * @param array<string, ReflectionMethod> $methodsWithMultipleArguments
+     *
+     * @return void
+     */
+    protected function executeMethodsWithMultipleArguments(array &$data, object $object, array $methodsWithMultipleArguments, array $context, ?string $format = null): void
+    {
+        foreach ($methodsWithMultipleArguments as $attributeName => $reflectionMethod) {
+            $methodParameters = $data[$attributeName];
+            // denormalize parameters
+            foreach ($reflectionMethod->getParameters() as $parameter) {
+                $parameterType = $parameter->getType();
+                if ($parameterType instanceof ReflectionNamedType && !$parameterType->isBuiltin()) {
+                    $childContext = $this->createChildContext($context, $parameter->getName(), $format);
+                    if (!$this->serializer instanceof DenormalizerInterface) {
+                        throw new LogicException(sprintf('Cannot denormalize parameter "%s" for method "%s" because injected serializer is not a denormalizer.', $parameter->getName(), $reflectionMethod->getName()));
+                    }
+
+                    if ($this->serializer->supportsDenormalization($methodParameters[$parameter->getName()], $parameterType->getName(), $format, $childContext)) {
+                        $methodParameters[$parameter->getName()] = $this->serializer->denormalize($methodParameters[$parameter->getName()], $parameterType->getName(), $format, $childContext);
+                    }
+                }
+            }
+
+            $reflectionMethod->invoke($object, ...$methodParameters);
+            unset($data[$attributeName]);
+        }
+    }
+
+    /**
+     * @param ReflectionClass $reflectionClass
+     * @param array $normalizedData
+     *
+     * @return array<string, ReflectionMethod>
+     */
+    protected function findMethodsWithMultipleArguments(ReflectionClass $reflectionClass, array $normalizedData): array
+    {
+        $methodsWithMultipleArguments = [];
+        foreach ($reflectionClass->getMethods(ReflectionMethod::IS_PUBLIC) as $reflectionMethod) {
+            // We only look into public method that can be setters with multiple parameters
+            if (
+                $reflectionMethod->getNumberOfRequiredParameters() <= 1
+                || $reflectionMethod->isStatic()
+                || $reflectionMethod->isConstructor()
+                || $reflectionMethod->isDestructor()
+            ) {
+                continue;
+            }
+
+            // Remove set/with to get the potential matching property in data (use full method name by default)
+            if (str_starts_with($reflectionMethod->getName(), 'set')) {
+                $methodPropertyName = lcfirst(substr($reflectionMethod->getName(), 3));
+            } elseif (str_starts_with($reflectionMethod->getName(), 'with')) {
+                $methodPropertyName = lcfirst(substr($reflectionMethod->getName(), 4));
+            } else {
+                $methodPropertyName = $reflectionMethod->getName();
+            }
+
+            // No data found matching the method so we skip it
+            if (empty($normalizedData[$methodPropertyName])) {
+                continue;
+            }
+
+            $methodParameters = $normalizedData[$methodPropertyName];
+            if (!is_array($methodParameters)) {
+                throw new InvalidArgumentException(sprintf('Value for method "%s" should be an array', $reflectionMethod->getName()));
+            }
+
+            // Now check that all required parameters are present
+            foreach ($reflectionMethod->getParameters() as $reflectionParameter) {
+                if (!$reflectionParameter->isOptional() && !isset($methodParameters[$reflectionParameter->getName()])) {
+                    throw new InvalidArgumentException(sprintf('Missing required parameter "%s" for method "%s"', $reflectionParameter->getName(), $reflectionMethod->getName()));
+                }
+            }
+            $methodsWithMultipleArguments[$methodPropertyName] = $reflectionMethod;
+        }
+
+        return $methodsWithMultipleArguments;
+    }
+
+    /**
+     * Return the localized array with keys based on local string value transformed into integer database IDs.
+     *
+     * @param array $localizedValue
+     *
+     * @return array
+     *
+     * @throws LocaleNotFoundException
+     */
+    protected function updateLanguageIndexesWithIDs(array $localizedValue): array
     {
         $indexLocalizedValue = [];
         $this->fetchLanguagesMapping();
@@ -161,6 +277,11 @@ protected function indexByID(array $localizedValue): array
         return $indexLocalizedValue;
     }
 
+    /**
+     * Fetches the language mapping once and save them in local property for better performance.
+     *
+     * @return void
+     */
     protected function fetchLanguagesMapping(): void
     {
         if (!isset($this->localesByID) || !isset($this->idsByLocale)) {
@@ -174,7 +295,7 @@ protected function fetchLanguagesMapping(): void
     }
 
     /**
-     * ObjectNormalizer must be the last normalizer as a fallback.
+     * CQRSApiNormalizer must be the last normalizer executed after all the special types normalizers already did their job.
      *
      * @return int
      */