use class normalizer

phpstan-baseline.neon

@@ -73,22 +73,16 @@ parameters:
 			path: src/Metadata/ClassMetadata.php
 
 		-
-			message: '#^Property Patchlevel\\Hydrator\\Normalizer\\EnumNormalizer\:\:\$enum \(class\-string\<BackedEnum\>\|null\) does not accept string\.$#'
-			identifier: assign.propertyType
-			count: 1
-			path: src/Normalizer/EnumNormalizer.php
-
-		-
-			message: '#^Parameter \#2 \$data of method Patchlevel\\Hydrator\\Hydrator\:\:hydrate\(\) expects array\<string, mixed\>, array given\.$#'
+			message: '#^Parameter \#2 \$data of method Patchlevel\\Hydrator\\Middleware\\Middleware\:\:hydrate\(\) expects array\<string, mixed\>, array\<mixed, mixed\> given\.$#'
 			identifier: argument.type
-			count: 1
-			path: src/Normalizer/ObjectMapNormalizer.php
+			count: 3
+			path: src/MetadataHydrator.php
 
 		-
-			message: '#^Parameter \#2 \$data of method Patchlevel\\Hydrator\\Hydrator\:\:hydrate\(\) expects array\<string, mixed\>, array\<mixed, mixed\> given\.$#'
-			identifier: argument.type
+			message: '#^Property Patchlevel\\Hydrator\\Normalizer\\EnumNormalizer\:\:\$enum \(class\-string\<BackedEnum\>\|null\) does not accept string\.$#'
+			identifier: assign.propertyType
 			count: 1
-			path: src/Normalizer/ObjectNormalizer.php
+			path: src/Normalizer/EnumNormalizer.php
 
 		-
 			message: '#^Property Patchlevel\\Hydrator\\Normalizer\\ObjectNormalizer\:\:\$className \(class\-string\|null\) does not accept string\.$#'

src/ArrayDataRequired.php

@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Patchlevel\Hydrator;
+
+use RuntimeException;
+
+use function sprintf;
+
+final class ArrayDataRequired extends RuntimeException implements HydratorException
+{
+    /** @param class-string $class */
+    public function __construct(string $class)
+    {
+        parent::__construct(sprintf(
+            'The data for the class "%s" must be an array. If you want to use another data type, you need to add a normalizer to the class.',
+            $class,
+        ));
+    }
+}

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 @@
     {
         $metadata = new ClassMetadata(
             $reflectionClass,
+            $this->getNormalizerOnClass($reflectionClass),
             $this->getPropertyMetadataList($reflectionClass),
             $this->getLazy($reflectionClass),
         );
@@ -189,6 +191,7 @@
 
         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,23 @@
         return $normalizer;
     }
 
+    /** @param ReflectionClass<object> $reflectionClass */
+    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

@@ -15,6 +15,7 @@
 use ReflectionClass;
 
 use function array_key_exists;
+use function is_array;
 
 use const PHP_VERSION_ID;
 
@@ -33,21 +34,34 @@ 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 (!$return instanceof $class) {
+                throw new ObjectRequired($class, $metadata->normalizer::class);
+            }
+
+            return $return;
+        }
+
+        if (!is_array($data)) {
+            throw new ArrayDataRequired($class);
+        }
+
         if (PHP_VERSION_ID < 80400) {
             $stack = new Stack($this->middlewares);
 
@@ -71,14 +85,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);

src/Normalizer/ObjectMapNormalizer.php

@@ -67,6 +67,11 @@ public function normalize(mixed $value, array $context): mixed
         }
 
         $data = $this->hydrator->extract($value);
+
+        if (!is_array($data)) {
+            throw InvalidArgument::withWrongType('array<string, mixed>', $data);
+        }
+
         $data[$this->typeFieldName] = $this->classToTypeMap[$value::class];
 
         return $data;

src/Normalizer/ObjectNormalizer.php

@@ -12,8 +12,6 @@
 use Symfony\Component\TypeInfo\Type\ObjectType;
 use Symfony\Component\TypeInfo\Type\TemplateType;
 
-use function is_array;
-
 #[Attribute(Attribute::TARGET_PROPERTY | Attribute::TARGET_CLASS)]
 final class ObjectNormalizer implements Normalizer, TypeAwareNormalizer, HydratorAwareNormalizer
 {
@@ -25,12 +23,8 @@ public function __construct(
     ) {
     }
 
-    /**
-     * @param array<string, mixed> $context
-     *
-     * @return array<string, mixed>|null
-     */
-    public function normalize(mixed $value, array $context): array|null
+    /** @param array<string, mixed> $context */
+    public function normalize(mixed $value, array $context): mixed
     {
         if (!$this->hydrator) {
             throw new MissingHydrator();
@@ -60,10 +54,6 @@ public function denormalize(mixed $value, array $context): object|null
             return null;
         }
 
-        if (!is_array($value)) {
-            throw InvalidArgument::withWrongType('array<string, mixed>|null', $value);
-        }
-
         $className = $this->getClassName();
 
         return $this->hydrator->hydrate($className, $value, $context);

src/ObjectRequired.php

@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Patchlevel\Hydrator;
+
+use Patchlevel\Hydrator\Normalizer\Normalizer;
+use RuntimeException;
+
+use function sprintf;
+
+final class ObjectRequired extends RuntimeException implements HydratorException
+{
+    /**
+     * @param class-string             $class
+     * @param class-string<Normalizer> $normalizerClass
+     */
+    public function __construct(
+        string $class,
+        string $normalizerClass,
+    ) {
+        parent::__construct(
+            sprintf(
+                'The result of the normalizer "%s" for the class "%s" must be an instance of "%s".',
+                $normalizerClass,
+                $class,
+                $class,
+            ),
+        );
+    }
+}

tests/Unit/Extension/Lifecycle/LifecycleExtensionTest.php

@@ -28,6 +28,7 @@ public function testIntegration(): void
 
         $extractedData = $hydrator->extract($object);
 
+        self::assertIsArray($extractedData);
         self::assertSame('foo [preHydrate] [postHydrate] [preExtract] [postExtract]', $extractedData['name']);
     }
 }

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

@@ -7,6 +7,7 @@
 use DateTime;
 use DateTimeImmutable;
 use DateTimeZone;
+use Patchlevel\Hydrator\ArrayDataRequired;
 use Patchlevel\Hydrator\CircularReference;
 use Patchlevel\Hydrator\ClassNotSupported;
 use Patchlevel\Hydrator\CoreExtension;
@@ -190,6 +191,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(
@@ -216,6 +226,17 @@ public function testHydrateUnknownClass(): void
         );
     }
 
+    public function testHydrateWithArrayDataRequired(): void
+    {
+        $this->expectException(ArrayDataRequired::class);
+        $this->expectExceptionMessage('The data for the class "Patchlevel\Hydrator\Tests\Unit\Fixture\ProfileCreated" must be an array. If you want to use another data type, you need to add a normalizer to the class.');
+
+        $this->hydrator->hydrate(
+            ProfileCreated::class,
+            'foo',
+        );
+    }
+
     public function testHydrateWithDefaults(): void
     {
         $object = $this->hydrator->hydrate(
@@ -471,6 +492,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
     {