POC: nested subject id

src/Cryptography/CryptographySubscriber.php

@@ -5,8 +5,13 @@
 namespace Patchlevel\Hydrator\Cryptography;
 
 use Patchlevel\Hydrator\Event\PostExtract;
+use Patchlevel\Hydrator\Event\PreExtract;
 use Patchlevel\Hydrator\Event\PreHydrate;
+use Patchlevel\Hydrator\Metadata\ClassMetadata;
+use Stringable;
 use Symfony\Component\EventDispatcher\EventSubscriberInterface;
+use function is_int;
+use function is_string;
 
 final class CryptographySubscriber implements EventSubscriberInterface
 {
@@ -17,20 +22,106 @@
 
     public function preHydrate(PreHydrate $event): void
     {
-        $event->data = $this->cryptography->decrypt($event->metadata, $event->data);
+        $parentSubjectId = $event->context['subjectId'] ?? null;
+
+        $currentSubjectId = $this->subjectIdFromData($event->data, $event->metadata) ?: $parentSubjectId;
+        $event->data = $this->cryptography->decrypt($event->metadata, $event->data, $currentSubjectId);
+
+        $event->context['subjectId'] = $currentSubjectId;
+    }
+
+    public function preExtract(PreExtract $event): void
+    {
+        $parentSubjectId = $event->context['subjectId'] ?? null;
+
+        $currentSubjectId = $this->subjectIdFromObject($event->object, $event->metadata) ?: $parentSubjectId;
+
+        $event->context['subjectId'] = $currentSubjectId;
     }
 
     public function postExtract(PostExtract $event): void
     {
-        $event->data = $this->cryptography->encrypt($event->metadata, $event->data);
+        $event->data = $this->cryptography->encrypt(
+            $event->metadata,
+            $event->data,
+            $event->context['subjectId'] ?? null
+        );
     }
 
     /** @return array<string, string|array{0: string, 1: int}|list<array{0: string, 1?: int}>> */
     public static function getSubscribedEvents(): array
     {
         return [
             PreHydrate::class => 'preHydrate',
+            PreExtract::class => 'preExtract',
             PostExtract::class => 'postExtract',
         ];
     }
+
+    private function subjectIdFromObject(object $object, ClassMetadata $metadata): string|null
+    {
+        $subjectIdField = $metadata->dataSubjectIdField();
+
+        if ($subjectIdField === null) {
+            return null;
+        }
+
+        $property = $metadata->propertyForField($subjectIdField);
+
+        $value = $property->getValue($object);
+
+        if ($value === null) {
+            return null;
+        }
+
+        $normalizer = $property->normalizer();
+
+        if ($normalizer !== null) {
+            $value = $normalizer->normalize($value);
+        }
+
+        if ($value instanceof Stringable) {
+            $value = (string)$value;
+        }
+
+        if (is_int($value)) {
+            $value = (string)$value;
+        }
+
+        if (!is_string($value)) {
+            throw new UnsupportedSubjectId($metadata->className(), $subjectIdField, $value);
+        }
+
+        return $value;
+    }
+
+    /** @param array<string, mixed> $data */
+    private function subjectIdFromData(array $data, ClassMetadata $metadata): string|null
+    {
+        $subjectIdField = $metadata->dataSubjectIdField();
+
+        if ($subjectIdField === null) {
+            return null;
+        }
+
+        $value = $data[$subjectIdField] ?? null;
+
+        if ($value === null) {
+            return null;
+        }
+
+        if ($value instanceof Stringable) {
+            $value = (string)$value;
+        }
+
+        if (is_int($value)) {
+            $value = (string)$value;
+        }
+
+        if (!is_string($value)) {
+            throw new UnsupportedSubjectId($metadata->className(), $subjectIdField, $value);
+        }
+
+        return $value;
+    }
 }

src/Cryptography/PersonalDataPayloadCryptographer.php

@@ -34,9 +34,9 @@
      *
      * @return array<string, mixed>
      */
-    public function encrypt(ClassMetadata $metadata, array $data): array
+    public function encrypt(ClassMetadata $metadata, array $data, string|null $overrideSubjectId = null): array
     {
-        $subjectId = $this->subjectId($metadata, $data);
+        $subjectId = $overrideSubjectId ?: $this->subjectId($metadata, $data);
 
         if ($subjectId === null) {
             return $data;
@@ -78,9 +78,9 @@
      *
      * @return array<string, mixed>
      */
-    public function decrypt(ClassMetadata $metadata, array $data): array
+    public function decrypt(ClassMetadata $metadata, array $data, string|null $overrideSubjectId = null): array
     {
-        $subjectId = $this->subjectId($metadata, $data);
+        $subjectId = $overrideSubjectId ?: $this->subjectId($metadata, $data);
 
         if ($subjectId === null) {
             return $data;

src/Event/PostExtract.php

@@ -8,10 +8,14 @@
 
 final class PostExtract
 {
-    /** @param array<string, mixed> $data */
+    /**
+     * @param array<string, mixed> $data
+     * @param array<string, mixed> $context
+     */
     public function __construct(
         public array $data,
         public readonly ClassMetadata $metadata,
+        public array $context = [],
     ) {
     }
 }

src/Event/PreExtract.php

@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Patchlevel\Hydrator\Event;
+
+use Patchlevel\Hydrator\Metadata\ClassMetadata;
+
+final class PreExtract
+{
+    /**
+     * @param array<string, mixed> $context
+     */
+    public function __construct(
+        public object $object,
+        public readonly ClassMetadata $metadata,
+        public array $context = [],
+    ) {
+    }
+}

src/Event/PreHydrate.php

@@ -8,10 +8,14 @@
 
 final class PreHydrate
 {
-    /** @param array<string, mixed> $data */
+    /**
+     * @param array<string, mixed> $data
+     * @param array<string, mixed> $context
+     */
     public function __construct(
         public array $data,
         public readonly ClassMetadata $metadata,
+        public array $context = [],
     ) {
     }
 }

src/HydratorWithContext.php

@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Patchlevel\Hydrator;
+
+interface HydratorWithContext extends Hydrator
+{
+    /**
+     * @param class-string<T>      $class
+     * @param array<string, mixed> $data
+     * @param array<string, mixed> $context
+     *
+     * @return T
+     *
+     * @throws ClassNotSupported if the class is not supported or not found.
+     *
+     * @template T of object
+     */
+    public function hydrate(string $class, array $data, array $context = []): object;
+
+    /**
+     * @param array<string, mixed> $context
+     *
+     * @return array<string, mixed>
+     */
+    public function extract(object $object, array $context = []): array;
+}

src/MetadataHydrator.php

@@ -7,6 +7,7 @@
 use Patchlevel\Hydrator\Cryptography\CryptographySubscriber;
 use Patchlevel\Hydrator\Cryptography\PayloadCryptographer;
 use Patchlevel\Hydrator\Event\PostExtract;
+use Patchlevel\Hydrator\Event\PreExtract;
 use Patchlevel\Hydrator\Event\PreHydrate;
 use Patchlevel\Hydrator\Guesser\BuiltInGuesser;
 use Patchlevel\Hydrator\Guesser\ChainGuesser;
@@ -16,21 +17,20 @@
 use Patchlevel\Hydrator\Metadata\ClassNotFound;
 use Patchlevel\Hydrator\Metadata\MetadataFactory;
 use Patchlevel\Hydrator\Normalizer\HydratorAwareNormalizer;
+use Patchlevel\Hydrator\Normalizer\NormalizerWithContext;
 use ReflectionClass;
 use ReflectionParameter;
 use Symfony\Component\EventDispatcher\EventDispatcher;
 use Symfony\Component\EventDispatcher\EventDispatcherInterface;
 use Throwable;
 use TypeError;
-
 use function array_key_exists;
 use function array_values;
 use function is_object;
 use function spl_object_id;
-
 use const PHP_VERSION_ID;
 
-final class MetadataHydrator implements Hydrator
+final class MetadataHydrator implements HydratorWithContext
 {
     /** @var array<int, class-string> */
     private array $stack = [];
@@ -55,14 +55,15 @@ public function __construct(
     }
 
     /**
-     * @param class-string<T>      $class
+     * @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): object
+    public function hydrate(string $class, array $data, array $context = []): object
     {
         try {
             $metadata = $this->metadataFactory->metadata($class);
@@ -71,34 +72,38 @@ public function hydrate(string $class, array $data): object
         }
 
         if (PHP_VERSION_ID < 80400) {
-            return $this->doHydrate($metadata, $data);
+            return $this->doHydrate($metadata, $data, $context);
         }
 
         $lazy = $metadata->lazy() ?? $this->defaultLazy;
 
         if (!$lazy) {
-            return $this->doHydrate($metadata, $data);
+            return $this->doHydrate($metadata, $data, $context);
         }
 
         return (new ReflectionClass($class))->newLazyProxy(
-            function () use ($metadata, $data): object {
-                return $this->doHydrate($metadata, $data);
+            function () use ($metadata, $data, $context): object {
+                return $this->doHydrate($metadata, $data, $context);
             },
         );
     }
 
     /**
-     * @param ClassMetadata<T>     $metadata
+     * @param ClassMetadata<T> $metadata
      * @param array<string, mixed> $data
+     * @param array<string, mixed> $context
      *
      * @return T
      *
      * @template T of object
      */
-    private function doHydrate(ClassMetadata $metadata, array $data): object
+    private function doHydrate(ClassMetadata $metadata, array $data, array $context = []): object
     {
         if ($this->eventDispatcher) {
-            $data = $this->eventDispatcher->dispatch(new PreHydrate($data, $metadata))->data;
+            $event = $this->eventDispatcher->dispatch(new PreHydrate($data, $metadata, $context));
+
+            $data = $event->data;
+            $context = $event->context;
         }
 
         $object = $metadata->newInstance();
@@ -137,8 +142,13 @@ private function doHydrate(ClassMetadata $metadata, array $data): object
                 }
 
                 try {
-                    /** @psalm-suppress MixedAssignment */
-                    $value = $normalizer->denormalize($value);
+                    if ($normalizer instanceof NormalizerWithContext) {
+                        /** @psalm-suppress MixedAssignment */
+                        $value = $normalizer->denormalize($value, $context);
+                    } else {
+                        /** @psalm-suppress MixedAssignment */
+                        $value = $normalizer->denormalize($value);
+                    }
                 } catch (Throwable $e) {
                     throw new DenormalizationFailure(
                         $metadata->className(),
@@ -167,8 +177,12 @@ private function doHydrate(ClassMetadata $metadata, array $data): object
         return $object;
     }
 
-    /** @return array<string, mixed> */
-    public function extract(object $object): array
+    /**
+     * @param array<string, mixed> $context
+     *
+     * @return array<string, mixed>
+     */
+    public function extract(object $object, array $context = []): array
     {
         $objectId = spl_object_id($object);
 
@@ -188,6 +202,13 @@ public function extract(object $object): array
                 $callback->invoke($object);
             }
 
+            if ($this->eventDispatcher) {
+                $event = $this->eventDispatcher->dispatch(new PreExtract($object, $metadata, $context));
+
+                $object = $event->object;
+                $context = $event->context;
+            }
+
             $data = [];
 
             foreach ($metadata->properties() as $propertyMetadata) {
@@ -202,8 +223,13 @@ public function extract(object $object): array
                     }
 
                     try {
-                        /** @psalm-suppress MixedAssignment */
-                        $value = $normalizer->normalize($value);
+                        if ($normalizer instanceof NormalizerWithContext) {
+                            /** @psalm-suppress MixedAssignment */
+                            $value = $normalizer->normalize($value, $context);
+                        } else {
+                            /** @psalm-suppress MixedAssignment */
+                            $value = $normalizer->normalize($value);
+                        }
                     } catch (CircularReference $e) {
                         throw $e;
                     } catch (Throwable $e) {
@@ -225,7 +251,9 @@ public function extract(object $object): array
             }
 
             if ($this->eventDispatcher) {
-                return $this->eventDispatcher->dispatch(new PostExtract($data, $metadata))->data;
+                $event = $this->eventDispatcher->dispatch(new PostExtract($data, $metadata, $context));
+
+                $data = $event->data;
             }
 
             return $data;