Ai performance

src/Extension/Cryptography/CryptographyMetadataEnricher.php

@@ -17,12 +17,14 @@ final class CryptographyMetadataEnricher implements MetadataEnricher
     public function enrich(ClassMetadata $classMetadata): void
     {
         $subjectIdMapping = [];
+        $subjectIdProperties = [];
+        $sensitiveProperties = [];
 
         foreach ($classMetadata->properties as $property) {
             $isSubjectId = false;
             $attributeReflectionList = $property->reflection->getAttributes(DataSubjectId::class);
 
-            if ($attributeReflectionList) {
+            if ($attributeReflectionList !== []) {
                 $subjectIdIdentifier = $attributeReflectionList[0]->newInstance()->name;
 
                 if (array_key_exists($subjectIdIdentifier, $subjectIdMapping)) {
@@ -35,6 +37,7 @@ public function enrich(ClassMetadata $classMetadata): void
                 }
 
                 $subjectIdMapping[$subjectIdIdentifier] = $property->fieldName;
+                $subjectIdProperties[$subjectIdIdentifier] = $property;
 
                 $isSubjectId = true;
             }
@@ -50,13 +53,17 @@ public function enrich(ClassMetadata $classMetadata): void
             }
 
             $property->extras[SensitiveDataInfo::class] = $sensitiveDataInfo;
+            $sensitiveProperties[] = $property;
         }
 
-        if ($subjectIdMapping === []) {
-            return;
+        if ($sensitiveProperties !== []) {
+            $classMetadata->extras[SensitiveDataInfo::class . '::properties'] = $sensitiveProperties;
         }
 
-        $classMetadata->extras[SubjectIdFieldMapping::class] = new SubjectIdFieldMapping($subjectIdMapping);
+        if ($subjectIdMapping !== []) {
+            $classMetadata->extras[SubjectIdFieldMapping::class] = new SubjectIdFieldMapping($subjectIdMapping);
+            $classMetadata->extras[SubjectIdFieldMapping::class . '::properties'] = $subjectIdProperties;
+        }
     }
 
     private function sensitiveDataInfo(ReflectionProperty $reflectionProperty): SensitiveDataInfo|null

src/Extension/Cryptography/CryptographyMiddleware.php

@@ -36,39 +36,48 @@
      */
     public function hydrate(ClassMetadata $metadata, array $data, array $context, Stack $stack): object
     {
+        /** @var list<PropertyMetadata>|null $properties */
+        $properties = $metadata->extras[SensitiveDataInfo::class . '::properties'] ?? null;
+
+        if ($properties === null) {
+            return $stack->next()->hydrate($metadata, $data, $context, $stack);
+        }
+
         $context[SubjectIds::class] = $subjectIds = $this->resolveSubjectIds($metadata, $data, $context);
+        $cryptographer = $this->cryptographer;
 
-        foreach ($metadata->properties as $propertyMetadata) {
-            $info = $propertyMetadata->extras[SensitiveDataInfo::class] ?? null;
+        foreach ($properties as $propertyMetadata) {
+            $fieldName = $propertyMetadata->fieldName;
 
-            if (!$info instanceof SensitiveDataInfo) {
+            if (!isset($data[$fieldName])) {
                 continue;
             }
 
-            $value = $data[$propertyMetadata->fieldName] ?? null;
+            $value = $data[$fieldName];
 
-            if ($value === null) {
+            if (!$cryptographer->supports($value)) {
                 continue;
             }
 
-            if (!$this->cryptographer->supports($value)) {
-                continue;
-            }
+            $info = $propertyMetadata->extras[SensitiveDataInfo::class];
+            assert($info instanceof SensitiveDataInfo);
 
             $subjectId = $subjectIds->get($info->subjectIdName);
 
             try {
-                $data[$propertyMetadata->fieldName] = $this->cryptographer->decrypt($subjectId, $value);
+                $data[$fieldName] = $cryptographer->decrypt($subjectId, $value);
             } catch (DecryptionFailed | CipherKeyNotExists) {
                 $fallback = $info->fallback instanceof Closure
                     ? ($info->fallback)($subjectId)
                     : $info->fallback;
 
-                if ($propertyMetadata->normalizer) {
-                    $fallback = $propertyMetadata->normalizer->normalize($fallback, $context);
+                $normalizer = $propertyMetadata->normalizer;
+
+                if ($normalizer !== null) {
+                    $fallback = $normalizer->normalize($fallback, $context);
                 }
 
-                $data[$propertyMetadata->fieldName] = $fallback;
+                $data[$fieldName] = $fallback;
             }
         }
 

src/Metadata/ClassMetadata.php

@@ -5,6 +5,7 @@
 namespace Patchlevel\Hydrator\Metadata;
 
 use ReflectionClass;
+use ReflectionParameter;
 
 /**
  * @phpstan-type serialized array{
@@ -21,7 +22,16 @@ final class ClassMetadata
     public readonly string $className;
 
     /** @var array<string, PropertyMetadata> */
-    public readonly array $properties;
+    public array $properties;
+
+    /** @var list<PropertyMetadata> */
+    public array $propertiesWithNormalizer;
+
+    /** @var list<PropertyMetadata> */
+    public array $propertiesWithoutNormalizer;
+
+    /** @var array<string, ReflectionParameter>|null */
+    private array|null $promotedConstructorDefaults = null;
 
     /**
      * @param ReflectionClass<T>     $reflection
@@ -36,13 +46,29 @@ public function __construct(
     ) {
         $this->className = $reflection->getName();
 
+        $this->updateProperties($properties);
+    }
+
+    /** @param list<PropertyMetadata> $properties */
+    public function updateProperties(array $properties): void
+    {
         $map = [];
+        $withNormalizer = [];
+        $withoutNormalizer = [];
 
         foreach ($properties as $property) {
             $map[$property->propertyName] = $property;
+
+            if ($property->normalizer !== null) {
+                $withNormalizer[] = $property;
+            } else {
+                $withoutNormalizer[] = $property;
+            }
         }
 
         $this->properties = $map;
+        $this->propertiesWithNormalizer = $withNormalizer;
+        $this->propertiesWithoutNormalizer = $withoutNormalizer;
     }
 
     public function propertyForField(string $name): PropertyMetadata
@@ -62,12 +88,38 @@ public function newInstance(): object
         return $this->reflection->newInstanceWithoutConstructor();
     }
 
+    /** @return array<string, ReflectionParameter> */
+    public function promotedConstructorDefaults(): array
+    {
+        if ($this->promotedConstructorDefaults !== null) {
+            return $this->promotedConstructorDefaults;
+        }
+
+        $constructor = $this->reflection->getConstructor();
+
+        if (!$constructor) {
+            return $this->promotedConstructorDefaults = [];
+        }
+
+        $result = [];
+
+        foreach ($constructor->getParameters() as $parameter) {
+            if (!$parameter->isPromoted() || !$parameter->isDefaultValueAvailable()) {
+                continue;
+            }
+
+            $result[$parameter->getName()] = $parameter;
+        }
+
+        return $this->promotedConstructorDefaults = $result;
+    }
+
     /** @return serialized */
     public function __serialize(): array
     {
         return [
             'className' => $this->className,
-            'properties' => $this->properties,
+            'properties' => array_values($this->properties),
             'lazy' => $this->lazy,
             'extras' => $this->extras,
         ];
@@ -77,7 +129,25 @@ public function __serialize(): array
     public function __unserialize(array $data): void
     {
         $this->reflection = new ReflectionClass($data['className']);
-        $this->properties = $data['properties'];
+
+        $map = [];
+        $withNormalizer = [];
+        $withoutNormalizer = [];
+
+        foreach ($data['properties'] as $property) {
+            $map[$property->propertyName] = $property;
+
+            if ($property->normalizer !== null) {
+                $withNormalizer[] = $property;
+            } else {
+                $withoutNormalizer[] = $property;
+            }
+        }
+
+        $this->className = $data['className'];
+        $this->properties = $map;
+        $this->propertiesWithNormalizer = $withNormalizer;
+        $this->propertiesWithoutNormalizer = $withoutNormalizer;
         $this->lazy = $data['lazy'];
         $this->extras = $data['extras'];
     }

src/Metadata/EnrichingMetadataFactory.php

@@ -17,8 +17,14 @@ public function metadata(string $class): ClassMetadata
     {
         $metadata = $this->factory->metadata($class);
 
+        $enriched = false;
         foreach ($this->enrichers as $enricher) {
             $enricher->enrich($metadata);
+            $enriched = true;
+        }
+
+        if ($enriched) {
+            $metadata->updateProperties(array_values($metadata->properties));
         }
 
         return $metadata;

src/MetadataHydrator.php

@@ -23,12 +23,15 @@ final class MetadataHydrator implements Hydrator
     /** @var array<class-string, ClassMetadata> */
     private array $classMetadata = [];
 
+    private readonly Stack $stack;
+
     /** @param list<Middleware> $middlewares */
     public function __construct(
         private readonly MetadataFactory $metadataFactory = new AttributeMetadataFactory(),
         private readonly array $middlewares = [new TransformMiddleware()],
         private readonly bool $defaultLazy = false,
     ) {
+        $this->stack = new Stack($this->middlewares);
     }
 
     /**
@@ -48,23 +51,21 @@ public function hydrate(string $class, array $data, array $context = []): object
             throw new ClassNotSupported($class, $e);
         }
 
-        if (PHP_VERSION_ID < 80400) {
-            $stack = new Stack($this->middlewares);
+        $stack = clone $this->stack;
 
+        if (PHP_VERSION_ID < 80400) {
             return $stack->next()->hydrate($metadata, $data, $context, $stack);
         }
 
         $lazy = $metadata->lazy ?? $this->defaultLazy;
 
         if (!$lazy) {
-            $stack = new Stack($this->middlewares);
-
             return $stack->next()->hydrate($metadata, $data, $context, $stack);
         }
 
         return (new ReflectionClass($class))->newLazyProxy(
             function () use ($metadata, $data, $context): object {
-                $stack = new Stack($this->middlewares);
+                $stack = clone $this->stack;
 
                 return $stack->next()->hydrate($metadata, $data, $context, $stack);
             },
@@ -79,7 +80,7 @@ function () use ($metadata, $data, $context): object {
     public function extract(object $object, array $context = []): array
     {
         $metadata = $this->metadata($object::class);
-        $stack = new Stack($this->middlewares);
+        $stack = clone $this->stack;
 
         return $stack->next()->extract($metadata, $object, $context, $stack);
     }
@@ -93,18 +94,18 @@ public function extract(object $object, array $context = []): array
      */
     public function metadata(string $class): ClassMetadata
     {
-        if (array_key_exists($class, $this->classMetadata)) {
+        if (isset($this->classMetadata[$class])) {
             return $this->classMetadata[$class];
         }
 
         $this->classMetadata[$class] = $metadata = $this->metadataFactory->metadata($class);
 
         foreach ($metadata->properties as $property) {
-            if (!($property->normalizer instanceof HydratorAwareNormalizer)) {
-                continue;
-            }
+            $normalizer = $property->normalizer;
 
-            $property->normalizer->setHydrator($this);
+            if ($normalizer instanceof HydratorAwareNormalizer) {
+                $normalizer->setHydrator($this);
+            }
         }
 
         return $metadata;

src/Middleware/Stack.php

@@ -16,14 +16,6 @@ public function __construct(
 
     public function next(): Middleware
     {
-        $next = $this->middlewares[$this->index] ?? null;
-
-        if ($next === null) {
-            throw new NoMoreMiddleware();
-        }
-
-        $this->index++;
-
-        return $next;
+        return $this->middlewares[$this->index++] ?? throw new NoMoreMiddleware();
     }
 }