symfony · daniser · Sep 11, 2024 · Sep 11, 2024 · Sep 11, 2024 · Sep 13, 2024
@@ -14,7 +14,7 @@
 class_exists(\Symfony\Component\Serializer\Attribute\SerializedName::class);
 
 if (false) {
-    #[\Attribute(\Attribute::TARGET_METHOD | \Attribute::TARGET_PROPERTY)]
+    #[\Attribute(\Attribute::TARGET_METHOD | \Attribute::TARGET_PROPERTY | \Attribute::IS_REPEATABLE)]
     class SerializedName extends \Symfony\Component\Serializer\Attribute\SerializedName
     {
     }

@@ -14,7 +14,7 @@
 class_exists(\Symfony\Component\Serializer\Attribute\SerializedPath::class);
 
 if (false) {
-    #[\Attribute(\Attribute::TARGET_METHOD | \Attribute::TARGET_PROPERTY)]
+    #[\Attribute(\Attribute::TARGET_METHOD | \Attribute::TARGET_PROPERTY | \Attribute::IS_REPEATABLE)]
     class SerializedPath extends \Symfony\Component\Serializer\Attribute\SerializedPath
     {
     }

@@ -16,23 +16,41 @@
 /**
  * @author Fabien Bourigault <bourigaultfabien@gmail.com>
  */
-#[\Attribute(\Attribute::TARGET_METHOD | \Attribute::TARGET_PROPERTY)]
+#[\Attribute(\Attribute::TARGET_METHOD | \Attribute::TARGET_PROPERTY | \Attribute::IS_REPEATABLE)]
 class SerializedName
 {
+    private array $groups;
+
     /**
-     * @param string $serializedName The name of the property as it will be serialized
+     * @param string          $serializedName The name of the property as it will be serialized
+     * @param string|string[] $groups         The groups to use when serializing or deserializing
      */
-    public function __construct(private readonly string $serializedName)
-    {
+    public function __construct(
+        private readonly string $serializedName,
+        string|array $groups = ['*'],
+    ) {
         if ('' === $serializedName) {
             throw new InvalidArgumentException(\sprintf('Parameter given to "%s" must be a non-empty string.', self::class));
         }
+
+        $this->groups = ((array) $groups) ?: ['*'];
+
+        foreach ($this->groups as $group) {
+            if (!\is_string($group)) {
+                throw new InvalidArgumentException(\sprintf('Parameter "groups" given to "%s" must be a string or an array of strings, "%s" given.', static::class, get_debug_type($group)));
+            }
+        }
     }
 
     public function getSerializedName(): string
     {
         return $this->serializedName;
     }
+
+    public function getGroups(): array
+    {
+        return $this->groups;
+    }
 }
 
 if (!class_exists(\Symfony\Component\Serializer\Annotation\SerializedName::class, false)) {

@@ -18,27 +18,43 @@
 /**
  * @author Tobias Bönner <tobi@boenner.family>
  */
-#[\Attribute(\Attribute::TARGET_METHOD | \Attribute::TARGET_PROPERTY)]
+#[\Attribute(\Attribute::TARGET_METHOD | \Attribute::TARGET_PROPERTY | \Attribute::IS_REPEATABLE)]
 class SerializedPath
 {
     private PropertyPath $serializedPath;
 
+    private array $groups;
+
     /**
-     * @param string $serializedPath A path using a valid PropertyAccess syntax where the value is stored in a normalized representation
+     * @param string          $serializedPath A path using a valid PropertyAccess syntax where the value is stored in a normalized representation
+     * @param string|string[] $groups         The groups to use when serializing or deserializing
      */
-    public function __construct(string $serializedPath)
+    public function __construct(string $serializedPath, string|array $groups = ['*'])
     {
         try {
             $this->serializedPath = new PropertyPath($serializedPath);
         } catch (InvalidPropertyPathException $pathException) {
             throw new InvalidArgumentException(\sprintf('Parameter given to "%s" must be a valid property path.', self::class));
         }
+
+        $this->groups = ((array) $groups) ?: ['*'];
+
+        foreach ($this->groups as $group) {
+            if (!\is_string($group)) {
+                throw new InvalidArgumentException(\sprintf('Parameter "groups" given to "%s" must be a string or an array of strings, "%s" given.', static::class, get_debug_type($group)));
+            }
+        }
     }
 
     public function getSerializedPath(): PropertyPath
     {
         return $this->serializedPath;
     }
+
+    public function getGroups(): array
+    {
+        return $this->groups;
+    }
 }
 
 if (!class_exists(\Symfony\Component\Serializer\Annotation\SerializedPath::class, false)) {

@@ -13,6 +13,7 @@ CHANGELOG
    default contexts, name converters, sets of normalizers and encoders
  * Add support for collection profiles of multiple serializer instances
  * Deprecate `AdvancedNameConverterInterface`, use `NameConverterInterface` instead
+ * Add support for serialized names and paths configuration per group
 
 7.1
 ---

@@ -19,6 +19,7 @@
 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Output\OutputInterface;
 use Symfony\Component\Console\Style\SymfonyStyle;
+use Symfony\Component\Serializer\Mapping\AttributeMetadata;
 use Symfony\Component\Serializer\Mapping\ClassMetadataInterface;
 use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactoryInterface;
 
@@ -100,8 +101,8 @@ private function getAttributesData(ClassMetadataInterface $classMetadata): array
             $data[$attributeMetadata->getName()] = [
                 'groups' => $attributeMetadata->getGroups(),
                 'maxDepth' => $attributeMetadata->getMaxDepth(),
-                'serializedName' => $attributeMetadata->getSerializedName(),
-                'serializedPath' => $attributeMetadata->getSerializedPath() ? (string) $attributeMetadata->getSerializedPath() : null,
+                'serializedNames' => AttributeMetadata::getSerializedNamesFromAttributeMetadata($attributeMetadata),
+                'serializedPaths' => array_map('strval', AttributeMetadata::getSerializedPathsFromAttributeMetadata($attributeMetadata)),
                 'ignore' => $attributeMetadata->isIgnored(),
                 'normalizationContexts' => $attributeMetadata->getNormalizationContexts(),
                 'denormalizationContexts' => $attributeMetadata->getDenormalizationContexts(),

@@ -40,18 +40,22 @@ class AttributeMetadata implements AttributeMetadataInterface
     public ?int $maxDepth = null;
 
     /**
+     * @var array<string, string> Serialized names per group name ("*" applies to all groups)
+     *
      * @internal This property is public in order to reduce the size of the
      *           class' serialized representation. Do not access it. Use
-     *           {@link getSerializedName()} instead.
+     *           {@link getSerializedNames()} instead.
      */
-    public ?string $serializedName = null;
+    public array $serializedNames = [];
 
     /**
+     * @var array<string, PropertyPath> Serialized paths per group name ("*" applies to all groups)
+     *
      * @internal This property is public in order to reduce the size of the
      *           class' serialized representation. Do not access it. Use
-     *           {@link getSerializedPath()} instead.
+     *           {@link getSerializedPaths()} instead.
      */
-    public ?PropertyPath $serializedPath = null;
+    public array $serializedPaths = [];
 
     /**
      * @internal This property is public in order to reduce the size of the
@@ -110,24 +114,70 @@ public function getMaxDepth(): ?int
         return $this->maxDepth;
     }
 
-    public function setSerializedName(?string $serializedName): void
+    public function setSerializedName(?string $serializedName /* , array $groups = ['*'] */): void
+    {
+        $groups = 2 <= \func_num_args() ? (func_get_arg(1) ?: ['*']) : ['*'];
+
+        if (isset($serializedName)) {
+            foreach ($groups as $group) {
+                $this->serializedNames[$group] = $serializedName;
+            }
+        } else {
+            foreach ($groups as $group) {
+                unset($this->serializedNames[$group]);
+            }
+        }
+    }
+
+    public function getSerializedName(/* array $groups = ['*'] */): ?string
+    {
+        $groups = 1 <= \func_num_args() ? func_get_arg(0) : ['*'];
+
+        foreach ($groups as $group) {
+            if (isset($this->serializedNames[$group])) {
+                return $this->serializedNames[$group];
+            }
+        }
+
+        return $this->serializedNames['*'] ?? null;
+    }
+
+    public function getSerializedNames(): array
     {
-        $this->serializedName = $serializedName;
+        return $this->serializedNames;
     }
 
-    public function getSerializedName(): ?string
+    public function setSerializedPath(?PropertyPath $serializedPath = null /* , array $groups = ['*'] */): void
     {
-        return $this->serializedName;
+        $groups = 2 <= \func_num_args() ? (func_get_arg(1) ?: ['*']) : ['*'];
+
+        if (isset($serializedPath)) {
+            foreach ($groups as $group) {
+                $this->serializedPaths[$group] = $serializedPath;
+            }
+        } else {
+            foreach ($groups as $group) {
+                unset($this->serializedPaths[$group]);
+            }
+        }
     }
 
-    public function setSerializedPath(?PropertyPath $serializedPath = null): void
+    public function getSerializedPath(/* array $groups = ['*'] */): ?PropertyPath
     {
-        $this->serializedPath = $serializedPath;
+        $groups = 1 <= \func_num_args() ? func_get_arg(0) : ['*'];
+
+        foreach ($groups as $group) {
+            if (isset($this->serializedPaths[$group])) {
+                return $this->serializedPaths[$group];
+            }
+        }
+
+        return $this->serializedPaths['*'] ?? null;
     }
 
-    public function getSerializedPath(): ?PropertyPath
+    public function getSerializedPaths(): array
     {
-        return $this->serializedPath;
+        return $this->serializedPaths;
     }
 
     public function setIgnore(bool $ignore): void
@@ -200,8 +250,16 @@ public function merge(AttributeMetadataInterface $attributeMetadata): void
 
         // Overwrite only if not defined
         $this->maxDepth ??= $attributeMetadata->getMaxDepth();
-        $this->serializedName ??= $attributeMetadata->getSerializedName();
-        $this->serializedPath ??= $attributeMetadata->getSerializedPath();
+
+        // Overwrite only if serialized names are empty
+        if (!$this->serializedNames) {
+            $this->serializedNames = self::getSerializedNamesFromAttributeMetadata($attributeMetadata);
+        }
+
+        // Overwrite only if serialized paths are empty
+        if (!$this->serializedPaths) {
+            $this->serializedPaths = self::getSerializedPathsFromAttributeMetadata($attributeMetadata);
+        }
 
         // Overwrite only if both contexts are empty
         if (!$this->normalizationContexts && !$this->denormalizationContexts) {
@@ -214,13 +272,55 @@ public function merge(AttributeMetadataInterface $attributeMetadata): void
         }
     }
 
+    /**
+     * BC layer for extraction of serialized names from attribute metadata.
+     * Can be removed as soon as AttributeMetadataInterface::getSerializedNames() become part of the interface.
+     *
+     * @internal
+     *
+     * @return array<string, string>
+     */
+    public static function getSerializedNamesFromAttributeMetadata(AttributeMetadataInterface $attributeMetadata): array
+    {
+        if (method_exists($attributeMetadata, 'getSerializedNames')) {
+            return $attributeMetadata->getSerializedNames();
+        }
+
+        if (null !== $serializedName = $attributeMetadata->getSerializedName()) {
+            return ['*' => $serializedName];
+        }
+
+        return [];
+    }
+
+    /**
+     * BC layer for extraction of serialized paths from attribute metadata.
+     * Can be removed as soon as AttributeMetadataInterface::getSerializedPaths() become part of the interface.
+     *
+     * @internal
+     *
+     * @return array<string, PropertyPath>
+     */
+    public static function getSerializedPathsFromAttributeMetadata(AttributeMetadataInterface $attributeMetadata): array
+    {
+        if (method_exists($attributeMetadata, 'getSerializedPaths')) {
+            return $attributeMetadata->getSerializedPaths();
+        }
+
+        if (null !== $serializedPath = $attributeMetadata->getSerializedPath()) {
+            return ['*' => $serializedPath];
+        }
+
+        return [];
+    }
+
     /**
      * Returns the names of the properties that should be serialized.
      *
      * @return string[]
      */
     public function __sleep(): array
     {
-        return ['name', 'groups', 'maxDepth', 'serializedName', 'serializedPath', 'ignore', 'normalizationContexts', 'denormalizationContexts'];
+        return ['name', 'groups', 'maxDepth', 'serializedNames', 'serializedPaths', 'ignore', 'normalizationContexts', 'denormalizationContexts'];
     }
 }
@@ -21,6 +21,9 @@
  * @internal
  *
  * @author Kévin Dunglas <dunglas@gmail.com>
+ *
+ * @method string[]       getSerializedNames() Gets all the serialized names per group.
+ * @method PropertyPath[] getSerializedPaths() Gets all the serialized paths per group.
  */
 interface AttributeMetadataInterface
 {
@@ -53,17 +56,31 @@ public function getMaxDepth(): ?int;
 
     /**
      * Sets the serialization name for this attribute.
+     *
+     * @param string[] $groups
      */
-    public function setSerializedName(?string $serializedName): void;
+    public function setSerializedName(?string $serializedName /* , array $groups = ['*'] */): void;
 
     /**
      * Gets the serialization name for this attribute.
+     *
+     * @param string[] $groups
      */
-    public function getSerializedName(): ?string;
+    public function getSerializedName(/* array $groups = ['*'] */): ?string;
 
-    public function setSerializedPath(?PropertyPath $serializedPath): void;
+    /**
+     * Sets the serialization path for this attribute.
+     *
+     * @param string[] $groups
+     */
+    public function setSerializedPath(?PropertyPath $serializedPath /* , array $groups = ['*'] */): void;
 
-    public function getSerializedPath(): ?PropertyPath;
+    /**
+     * Gets the serialization path for this attribute.
+     *
+     * @param string[] $groups
+     */
+    public function getSerializedPath(/* array $groups = ['*'] */): ?PropertyPath;
 
     /**
      * Sets if this attribute must be ignored or not.

@@ -47,8 +47,10 @@ private function generateDeclaredClassMetadata(array $classMetadatas): string
                 $attributesMetadata[$attributeMetadata->getName()] = [
                     $attributeMetadata->getGroups(),
                     $attributeMetadata->getMaxDepth(),
-                    $attributeMetadata->getSerializedName(),
-                    $attributeMetadata->getSerializedPath(),
+                    method_exists($attributeMetadata, 'getSerializedNames')
+                        ? $attributeMetadata->getSerializedNames() : $attributeMetadata->getSerializedName(),
+                    method_exists($attributeMetadata, 'getSerializedPaths')
+                        ? $attributeMetadata->getSerializedPaths() : $attributeMetadata->getSerializedPath(),
                 ];
             }
 

@@ -53,7 +53,12 @@ public function getMetadataFor(string|object $value): ClassMetadataInterface
             $classMetadata = new ClassMetadata($className);
             foreach ($this->compiledClassMetadata[$className][0] as $name => $compiledAttributesMetadata) {
                 $classMetadata->attributesMetadata[$name] = $attributeMetadata = new AttributeMetadata($name);
-                [$attributeMetadata->groups, $attributeMetadata->maxDepth, $attributeMetadata->serializedName] = $compiledAttributesMetadata;
+                [$attributeMetadata->groups, $attributeMetadata->maxDepth, $serializedNames] = $compiledAttributesMetadata;
+                $attributeMetadata->serializedNames = match (true) {
+                    \is_array($serializedNames) => $serializedNames,
+                    null === $serializedNames => [],
+                    default => ['*' => $serializedNames],
+                };
             }
             $classMetadata->classDiscriminatorMapping = $this->compiledClassMetadata[$className][1]
                 ? new ClassDiscriminatorMapping(...$this->compiledClassMetadata[$className][1])