add extension api

src/CoreExtension.php

@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Patchlevel\Hydrator;
+
+use Patchlevel\Hydrator\Guesser\BuiltInGuesser;
+use Patchlevel\Hydrator\Guesser\Guesser;
+use Patchlevel\Hydrator\Middleware\Middleware;
+use Patchlevel\Hydrator\Middleware\TransformMiddleware;
+
+final class CoreExtension implements MiddlewareProvider, GuesserProvider
+{
+    /** @return iterable<Middleware|array{0: Middleware, 1?: int}> */
+    public function middlewares(): iterable
+    {
+        yield new TransformMiddleware();
+    }
+
+    /** @return iterable<Guesser|array{0: Guesser, 1?: int}> */
+    public function guesser(): iterable
+    {
+        yield new BuiltInGuesser();
+    }
+}

src/Cryptography/CryptographyExtension.php

@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Patchlevel\Hydrator\Cryptography;
+
+use Patchlevel\Hydrator\Metadata\MetadataEnricher;
+use Patchlevel\Hydrator\MetadataEnricherProvider;
+use Patchlevel\Hydrator\Middleware\Middleware;
+use Patchlevel\Hydrator\MiddlewareProvider;
+
+final class CryptographyExtension implements MiddlewareProvider, MetadataEnricherProvider
+{
+    public function __construct(
+        private readonly PayloadCryptographer $cryptography,
+    ) {
+    }
+
+    /** @return iterable<Middleware|array{0: Middleware, 1?: int}> */
+    public function middlewares(): iterable
+    {
+        yield [new CryptographyMiddleware($this->cryptography), 64];
+    }
+
+    /** @return iterable<MetadataEnricher|array{0: MetadataEnricher, 1?: int}> */
+    public function metadataEnrichers(): iterable
+    {
+        yield [new CryptographyMetadataEnricher(), 64];
+    }
+}

src/Cryptography/CryptographyMetadataFactory.php → src/Cryptography/CryptographyMetadataEnricher.php

@@ -7,25 +7,18 @@
 use Patchlevel\Hydrator\Attribute\DataSubjectId;
 use Patchlevel\Hydrator\Attribute\SensitiveData;
 use Patchlevel\Hydrator\Metadata\ClassMetadata;
-use Patchlevel\Hydrator\Metadata\MetadataFactory;
+use Patchlevel\Hydrator\Metadata\MetadataEnricher;
 use ReflectionProperty;
 
 use function array_key_exists;
 
-final class CryptographyMetadataFactory implements MetadataFactory
+final class CryptographyMetadataEnricher implements MetadataEnricher
 {
-    public function __construct(
-        private readonly MetadataFactory $metadataFactory,
-    ) {
-    }
-
-    public function metadata(string $class): ClassMetadata
+    public function enrich(ClassMetadata $classMetadata): void
     {
-        $metadata = $this->metadataFactory->metadata($class);
-
         $subjectIdMapping = [];
 
-        foreach ($metadata->properties as $property) {
+        foreach ($classMetadata->properties as $property) {
             $isSubjectId = false;
             $attributeReflectionList = $property->reflection->getAttributes(DataSubjectId::class);
 
@@ -34,8 +27,8 @@ public function metadata(string $class): ClassMetadata
 
                 if (array_key_exists($subjectIdIdentifier, $subjectIdMapping)) {
                     throw new DuplicateSubjectIdIdentifier(
-                        $metadata->className,
-                        $metadata->propertyForField($subjectIdMapping[$subjectIdIdentifier])->propertyName,
+                        $classMetadata->className,
+                        $classMetadata->propertyForField($subjectIdMapping[$subjectIdIdentifier])->propertyName,
                         $property->propertyName,
                         $subjectIdIdentifier,
                     );
@@ -53,17 +46,17 @@ public function metadata(string $class): ClassMetadata
             }
 
             if ($isSubjectId) {
-                throw new SubjectIdAndSensitiveDataConflict($metadata->className, $property->propertyName);
+                throw new SubjectIdAndSensitiveDataConflict($classMetadata->className, $property->propertyName);
             }
 
             $property->extras[SensitiveDataInfo::class] = $sensitiveDataInfo;
         }
 
-        if ($subjectIdMapping !== []) {
-            $metadata->extras[SubjectIdFieldMapping::class] = new SubjectIdFieldMapping($subjectIdMapping);
+        if ($subjectIdMapping === []) {
+            return;
         }
 
-        return $metadata;
+        $classMetadata->extras[SubjectIdFieldMapping::class] = new SubjectIdFieldMapping($subjectIdMapping);
     }
 
     private function sensitiveDataInfo(ReflectionProperty $reflectionProperty): SensitiveDataInfo|null

src/GuesserProvider.php

@@ -0,0 +1,13 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Patchlevel\Hydrator;
+
+use Patchlevel\Hydrator\Guesser\Guesser;
+
+interface GuesserProvider
+{
+    /** @return iterable<Guesser|array{0: Guesser, 1?: int}> */
+    public function guesser(): iterable;
+}

src/Metadata/AttributeMetadataFactory.php

@@ -41,7 +41,7 @@ public function __construct(
         Guesser|null $guesser = null,
     ) {
         $this->typeResolver = $typeResolver ?: TypeResolver::create();
-        $this->guesser = $guesser ?: new BuiltInGuesser(false);
+        $this->guesser = $guesser ?: new BuiltInGuesser();
     }
 
     /**

src/Metadata/MetadataEnricher.php

@@ -0,0 +1,10 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Patchlevel\Hydrator\Metadata;
+
+interface MetadataEnricher
+{
+    public function enrich(ClassMetadata $classMetadata): void;
+}

src/MetadataEnricherProvider.php

@@ -0,0 +1,13 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Patchlevel\Hydrator;
+
+use Patchlevel\Hydrator\Metadata\MetadataEnricher;
+
+interface MetadataEnricherProvider
+{
+    /** @return iterable<MetadataEnricher|array{0: MetadataEnricher, 1?: int}> */
+    public function metadataEnrichers(): iterable;
+}

src/MetadataHydrator.php

@@ -4,20 +4,21 @@
 
 namespace Patchlevel\Hydrator;
 
-use Patchlevel\Hydrator\Guesser\BuiltInGuesser;
 use Patchlevel\Hydrator\Guesser\ChainGuesser;
 use Patchlevel\Hydrator\Guesser\Guesser;
 use Patchlevel\Hydrator\Metadata\AttributeMetadataFactory;
 use Patchlevel\Hydrator\Metadata\ClassMetadata;
 use Patchlevel\Hydrator\Metadata\ClassNotFound;
+use Patchlevel\Hydrator\Metadata\MetadataEnricher;
 use Patchlevel\Hydrator\Metadata\MetadataFactory;
 use Patchlevel\Hydrator\Middleware\Middleware;
 use Patchlevel\Hydrator\Middleware\Stack;
-use Patchlevel\Hydrator\Middleware\TransformMiddleware;
 use Patchlevel\Hydrator\Normalizer\HydratorAwareNormalizer;
 use ReflectionClass;
 
 use function array_key_exists;
+use function array_merge;
+use function krsort;
 
 use const PHP_VERSION_ID;
 
@@ -26,10 +27,14 @@
     /** @var array<class-string, ClassMetadata> */
     private array $classMetadata = [];
 
-    /** @param list<Middleware> $middlewares */
+    /**
+     * @param list<Middleware>       $middlewares
+     * @param list<MetadataEnricher> $metadataEnrichers
+     */
     public function __construct(
         private readonly MetadataFactory $metadataFactory = new AttributeMetadataFactory(),
         private readonly array $middlewares = [],
+        private readonly array $metadataEnrichers = [],
         private readonly bool $defaultLazy = false,
     ) {
     }
@@ -110,32 +115,68 @@
             $property->normalizer->setHydrator($this);
         }
 
+        foreach ($this->metadataEnrichers as $enricher) {
+            $enricher->enrich($metadata);
+        }
+
         return $metadata;
     }
 
-    /**
-     * @param list<Middleware>  $additionalMiddleware
-     * @param iterable<Guesser> $guessers
-     */
+    /** @param iterable<MiddlewareProvider|MetadataEnricherProvider|GuesserProvider> $extensions */
     public static function create(
-        array $additionalMiddleware = [],
-        iterable $guessers = [],
+        iterable $extensions = [],
         bool $defaultLazy = false,
     ): self {
-        $guesser = new BuiltInGuesser();
+        $extensions = [...$extensions, new CoreExtension()];
+
+        $middlewares = [];
+        $enrichers = [];
+        $guessers = [];
+
+        foreach ($extensions as $extension) {
+            if ($extension instanceof MiddlewareProvider) {
+                foreach ($extension->middlewares() as $entry) {
+                    if ($entry instanceof Middleware) {
+                        $middlewares[0][] = $entry;
+                    } else {
+                        $middlewares[$entry[1] ?? 0][] = $entry[0];
+                    }
+                }
+            }
 
-        if ($guessers !== []) {
-            $guesser = new ChainGuesser([
-                ...$guessers,
-                $guesser,
-            ]);
+            if ($extension instanceof MetadataEnricherProvider) {
+                foreach ($extension->metadataEnrichers() as $entry) {
+                    if ($entry instanceof MetadataEnricher) {
+                        $enrichers[0][] = $entry;
+                    } else {
+                        $enrichers[$entry[1] ?? 0][] = $entry[0];
+                    }
+                }
+            }
+
+            if (!($extension instanceof GuesserProvider)) {
+                continue;
+            }
+
+            foreach ($extension->guesser() as $entry) {
+                if ($entry instanceof Guesser) {
+                    $guessers[0][] = $entry;
+                } else {
+                    $guessers[$entry[1] ?? 0][] = $entry[0];
+                }
+            }
         }
 
+        krsort($middlewares);
+        krsort($enrichers);
+        krsort($guessers);
+
         return new self(
             new AttributeMetadataFactory(
-                guesser: $guesser,
+                guesser: new ChainGuesser([...array_merge(...$guessers)]),
             ),
-            [...$additionalMiddleware, new TransformMiddleware()],
+            [...array_merge(...$middlewares)],
+            [...array_merge(...$enrichers)],
             $defaultLazy,
         );
     }

src/MiddlewareProvider.php

@@ -0,0 +1,13 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Patchlevel\Hydrator;
+
+use Patchlevel\Hydrator\Middleware\Middleware;
+
+interface MiddlewareProvider
+{
+    /** @return iterable<Middleware|array{0: Middleware, 1?: int}> */
+    public function middlewares(): iterable;
+}

tests/Benchmark/HydratorWithCryptographyBench.php

@@ -4,14 +4,11 @@
 
 namespace Patchlevel\Hydrator\Tests\Benchmark;
 
-use Patchlevel\Hydrator\Cryptography\CryptographyMetadataFactory;
-use Patchlevel\Hydrator\Cryptography\CryptographyMiddleware;
+use Patchlevel\Hydrator\Cryptography\CryptographyExtension;
 use Patchlevel\Hydrator\Cryptography\SensitiveDataPayloadCryptographer;
 use Patchlevel\Hydrator\Cryptography\Store\InMemoryCipherKeyStore;
 use Patchlevel\Hydrator\Hydrator;
-use Patchlevel\Hydrator\Metadata\AttributeMetadataFactory;
 use Patchlevel\Hydrator\MetadataHydrator;
-use Patchlevel\Hydrator\Middleware\TransformMiddleware;
 use Patchlevel\Hydrator\Tests\Benchmark\Fixture\ProfileCreated;
 use Patchlevel\Hydrator\Tests\Benchmark\Fixture\ProfileId;
 use Patchlevel\Hydrator\Tests\Benchmark\Fixture\Skill;
@@ -28,13 +25,11 @@ public function __construct()
     {
         $this->store = new InMemoryCipherKeyStore();
 
-        $this->hydrator = new MetadataHydrator(
-            new CryptographyMetadataFactory(new AttributeMetadataFactory()),
-            [
-                new CryptographyMiddleware(SensitiveDataPayloadCryptographer::createWithDefaultSettings($this->store)),
-                new TransformMiddleware(),
-            ],
-        );
+        $this->hydrator = MetadataHydrator::create([
+            new CryptographyExtension(
+                SensitiveDataPayloadCryptographer::createWithDefaultSettings($this->store),
+            ),
+        ]);
     }
 
     public function setUp(): void