use class normalizer

Author: DavidBadura

src/Hydrator.php

@@ -8,7 +8,6 @@ interface Hydrator
 {
     /**
      * @param class-string<T>      $class
-     * @param array<string, mixed> $data
      * @param array<string, mixed> $context
      *
      * @return T
@@ -17,12 +16,8 @@ interface Hydrator
      *
      * @template T of object
      */
-    public function hydrate(string $class, array $data, array $context = []): object;
+    public function hydrate(string $class, mixed $data, array $context = []): object;
 
-    /**
-     * @param array<string, mixed> $context
-     *
-     * @return array<string, mixed>
-     */
-    public function extract(object $object, array $context = []): array;
+    /** @param array<string, mixed> $context */
+    public function extract(object $object, array $context = []): mixed;
 }

src/Metadata/AttributeMetadataFactory.php

@@ -12,6 +12,7 @@
 use Patchlevel\Hydrator\Normalizer\ArrayNormalizer;
 use Patchlevel\Hydrator\Normalizer\ArrayShapeNormalizer;
 use Patchlevel\Hydrator\Normalizer\Normalizer;
+use Patchlevel\Hydrator\Normalizer\ObjectNormalizer;
 use Patchlevel\Hydrator\Normalizer\TypeAwareNormalizer;
 use ReflectionAttribute;
 use ReflectionClass;
@@ -73,6 +74,7 @@ private function getClassMetadata(ReflectionClass $reflectionClass): ClassMetada
     {
         $metadata = new ClassMetadata(
             $reflectionClass,
+            $this->getNormalizerOnClass($reflectionClass),
             $this->getPropertyMetadataList($reflectionClass),
             $this->getLazy($reflectionClass),
         );
@@ -189,6 +191,7 @@ private function mergeMetadata(ClassMetadata $parent, ClassMetadata $child): Cla
 
         return new ClassMetadata(
             $parent->reflection,
+            $child->normalizer ?? $parent->normalizer,
             array_values($properties),
             $child->lazy ?? $parent->lazy,
             array_merge($parent->extras, $child->extras),
@@ -212,6 +215,22 @@ private function getNormalizer(ReflectionProperty $reflectionProperty): Normaliz
         return $normalizer;
     }
 
+    private function getNormalizerOnClass(ReflectionClass $reflectionClass): Normalizer|null
+    {
+        $type = Type::object($reflectionClass->getName());
+        $normalizer = $this->inferNormalizerByType($type);
+
+        if ($normalizer instanceof ObjectNormalizer) {
+            return null;
+        }
+
+        if ($normalizer instanceof TypeAwareNormalizer) {
+            $normalizer->handleType($type);
+        }
+
+        return $normalizer;
+    }
+
     private function findNormalizerOnProperty(ReflectionProperty $reflectionProperty): Normalizer|null
     {
         /** @var list<ReflectionAttribute<Normalizer>> $attributeReflectionList */

src/Metadata/ClassMetadata.php

@@ -4,11 +4,13 @@
 
 namespace Patchlevel\Hydrator\Metadata;
 
+use Patchlevel\Hydrator\Normalizer\Normalizer;
 use ReflectionClass;
 
 /**
  * @phpstan-type serialized array{
  *     className: class-string,
+ *     normalizer: Normalizer|null,
  *     properties: array<string, PropertyMetadata>,
  *     lazy: bool|null,
  *     extras: array<string, mixed>,
@@ -30,6 +32,7 @@ final class ClassMetadata
      */
     public function __construct(
         public readonly ReflectionClass $reflection,
+        public Normalizer|null $normalizer = null,
         array $properties = [],
         public bool|null $lazy = null,
         public array $extras = [],
@@ -67,6 +70,7 @@ public function __serialize(): array
     {
         return [
             'className' => $this->className,
+            'normalizer' => $this->normalizer,
             'properties' => $this->properties,
             'lazy' => $this->lazy,
             'extras' => $this->extras,
@@ -77,6 +81,7 @@ public function __serialize(): array
     public function __unserialize(array $data): void
     {
         $this->reflection = new ReflectionClass($data['className']);
+        $this->normalizer = $data['normalizer'];
         $this->properties = $data['properties'];
         $this->lazy = $data['lazy'];
         $this->extras = $data['extras'];

src/MetadataHydrator.php

@@ -12,9 +12,11 @@
 use Patchlevel\Hydrator\Middleware\Stack;
 use Patchlevel\Hydrator\Middleware\TransformMiddleware;
 use Patchlevel\Hydrator\Normalizer\HydratorAwareNormalizer;
+use Patchlevel\Hydrator\Normalizer\InvalidType;
 use ReflectionClass;
 
 use function array_key_exists;
+use function is_array;
 
 use const PHP_VERSION_ID;
 
@@ -33,21 +35,28 @@ public function __construct(
 
     /**
      * @param class-string<T>      $class
-     * @param array<string, mixed> $data
      * @param array<string, mixed> $context
      *
      * @return T
      *
      * @template T of object
      */
-    public function hydrate(string $class, array $data, array $context = []): object
+    public function hydrate(string $class, mixed $data, array $context = []): object
     {
         try {
             $metadata = $this->metadata($class);
         } catch (ClassNotFound $e) {
             throw new ClassNotSupported($class, $e);
         }
 
+        if ($metadata->normalizer) {
+            return $metadata->normalizer->denormalize($data, $context);
+        }
+
+        if (!is_array($data)) {
+            throw new InvalidType();
+        }
+
         if (PHP_VERSION_ID < 80400) {
             $stack = new Stack($this->middlewares);
 
@@ -71,14 +80,15 @@ function () use ($metadata, $data, $context): object {
         );
     }
 
-    /**
-     * @param array<string, mixed> $context
-     *
-     * @return array<string, mixed>
-     */
-    public function extract(object $object, array $context = []): array
+    /** @param array<string, mixed> $context */
+    public function extract(object $object, array $context = []): mixed
     {
         $metadata = $this->metadata($object::class);
+
+        if ($metadata->normalizer) {
+            return $metadata->normalizer->normalize($object, $context);
+        }
+
         $stack = new Stack($this->middlewares);
 
         return $stack->next()->extract($metadata, $object, $context, $stack);

tests/Unit/Metadata/AttributeMetadataFactoryTest.php

@@ -359,4 +359,12 @@ class {
 
         self::assertTrue($metadata->lazy);
     }
+
+    public function testClassMetadataWithNormalizer(): void
+    {
+        $metadataFactory = new AttributeMetadataFactory();
+        $metadata = $metadataFactory->metadata(ProfileId::class);
+
+        self::assertInstanceOf(IdNormalizer::class, $metadata->normalizer);
+    }
 }

tests/Unit/Metadata/ClassMetadataTest.php

@@ -30,6 +30,7 @@ public function testPropertiesHashmap(): void
 
         $classMetadata = new ClassMetadata(
             $reflection,
+            null,
             [$fooMetadata, $barMetadata],
         );
 

tests/Unit/MetadataHydratorTest.php

@@ -190,6 +190,15 @@ public function testExtractWithInlineNormalizer(): void
         );
     }
 
+    public function testExtractWithClassNormalizer(): void
+    {
+        $data = $this->hydrator->extract(
+            ProfileId::fromString('id'),
+        );
+
+        self::assertEquals('id', $data);
+    }
+
     public function testHydrate(): void
     {
         $expected = new ProfileCreated(
@@ -471,6 +480,16 @@ public function testHydrateWithInferNormalizerWitIterables(): void
         self::assertEquals($expected, $event);
     }
 
+    public function testHydrateWithClassNormalizer(): void
+    {
+        $object = $this->hydrator->hydrate(
+            ProfileId::class,
+            'id',
+        );
+
+        self::assertEquals(ProfileId::fromString('id'), $object);
+    }
+
     #[RequiresPhp('>=8.4')]
     public function testLazyHydrate(): void
     {