Add AbstractObjectNormalizer::ENABLE_TYPE_CONVERSION for scalar type transformation

Jeroeny · Jeroeny · commit 4690cbfe9d72 · 2023-10-19T16:39:44.000+02:00
diff --git a/src/Symfony/Component/Serializer/CHANGELOG.md b/src/Symfony/Component/Serializer/CHANGELOG.md
@@ -11,6 +11,7 @@ CHANGELOG
  * Make `ProblemNormalizer` give details about Messenger's `ValidationFailedException`
  * Add `XmlEncoder::CDATA_WRAPPING` context option
  * Deprecate `AnnotationLoader`, use `AttributeLoader` instead
+ * Add `AbstractObjectNormalizer::ENABLE_TYPE_CONVERSION` for scalar type transformation
 
 6.3
 ---
diff --git a/src/Symfony/Component/Serializer/Normalizer/AbstractObjectNormalizer.php b/src/Symfony/Component/Serializer/Normalizer/AbstractObjectNormalizer.php
@@ -56,6 +56,13 @@ abstract class AbstractObjectNormalizer extends AbstractNormalizer
      */
     public const DISABLE_TYPE_ENFORCEMENT = 'disable_type_enforcement';
 
+    /**
+     * While denormalizing, convert scalar types to the expected type.
+     *
+     * Enabled by default for the XML and CSV format, because all basic datatypes are represented as strings.
+     */
+    public const ENABLE_TYPE_CONVERSION = 'enable_type_conversion';
+
     /**
      * Flag to control whether fields with the value `null` should be output
      * when normalizing or omitted.
@@ -290,8 +297,6 @@ abstract protected function extractAttributes(object $object, string $format = n
 
     /**
      * Gets the attribute value.
-     *
-     * @return mixed
      */
     abstract protected function getAttributeValue(object $object, string $attribute, string $format = null, array $context = []);
 
@@ -305,9 +310,6 @@ public function supportsDenormalization(mixed $data, string $type, string $forma
         return class_exists($type) || (interface_exists($type, false) && null !== $this->classDiscriminatorResolver?->getMappingForClass($type));
     }
 
-    /**
-     * @return mixed
-     */
     public function denormalize(mixed $data, string $type, string $format = null, array $context = [])
     {
         if (!isset($context['cache_key'])) {
@@ -320,6 +322,10 @@ public function denormalize(mixed $data, string $type, string $format = null, ar
             return null;
         }
 
+        if (!isset($context[self::ENABLE_TYPE_CONVERSION]) && (XmlEncoder::FORMAT === $format || CsvEncoder::FORMAT === $format)) {
+            $context[self::ENABLE_TYPE_CONVERSION] = true;
+        }
+
         $allowedAttributes = $this->getAllowedAttributes($type, $context, true);
         $normalizedData = $this->prepareForDenormalization($data);
         $extraAttributes = [];
@@ -434,11 +440,16 @@ private function validateAndDenormalize(array $types, string $currentClass, stri
         $isUnionType = \count($types) > 1;
         $extraAttributesException = null;
         $missingConstructorArgumentsException = null;
+        $hasNonObjectType = false;
+        $isUnionTypeOrNullable = $isUnionType;
+
         foreach ($types as $type) {
             if (null === $data && $type->isNullable()) {
                 return null;
             }
 
+            $isUnionTypeOrNullable = $isUnionTypeOrNullable ?: $type->isNullable();
+            $hasNonObjectType = $hasNonObjectType ?: Type::BUILTIN_TYPE_OBJECT !== $type->getBuiltinType();
             $collectionValueType = $type->isCollection() ? $type->getCollectionValueTypes()[0] ?? null : null;
 
             // Fix a collection that contains the only one element
@@ -456,7 +467,7 @@ private function validateAndDenormalize(array $types, string $currentClass, stri
                 // In XML and CSV all basic datatypes are represented as strings, it is e.g. not possible to determine,
                 // if a value is meant to be a string, float, int or a boolean value from the serialized representation.
                 // That's why we have to transform the values, if one of these non-string basic datatypes is expected.
-                if (\is_string($data) && (XmlEncoder::FORMAT === $format || CsvEncoder::FORMAT === $format)) {
+                if (\is_string($data) && ($context[self::ENABLE_TYPE_CONVERSION] ?? false)) {
                     if ('' === $data) {
                         if (Type::BUILTIN_TYPE_ARRAY === $builtinType = $type->getBuiltinType()) {
                             return [];
@@ -564,17 +575,17 @@ private function validateAndDenormalize(array $types, string $currentClass, stri
                     return $data;
                 }
             } catch (NotNormalizableValueException|InvalidArgumentException $e) {
-                if (!$isUnionType) {
+                if (!$isUnionTypeOrNullable) {
                     throw $e;
                 }
             } catch (ExtraAttributesException $e) {
-                if (!$isUnionType) {
+                if (!$isUnionTypeOrNullable) {
                     throw $e;
                 }
 
                 $extraAttributesException ??= $e;
             } catch (MissingConstructorArgumentsException $e) {
-                if (!$isUnionType) {
+                if (!$isUnionTypeOrNullable) {
                     throw $e;
                 }
 
@@ -590,6 +601,12 @@ private function validateAndDenormalize(array $types, string $currentClass, stri
             throw $missingConstructorArgumentsException;
         }
 
+        if ('' === $data && !$hasNonObjectType && ($context[self::ENABLE_TYPE_CONVERSION] ?? false)) {
+            return null;
+        } elseif (!$isUnionType && isset($e)) {
+            throw $e;
+        }
+
         if ($context[self::DISABLE_TYPE_ENFORCEMENT] ?? $this->defaultContext[self::DISABLE_TYPE_ENFORCEMENT] ?? false) {
             return $data;
         }
