allow to switch to stack hydrator

Author: DavidBadura

composer.json

@@ -19,8 +19,8 @@
   ],
   "require": {
     "php": "~8.2.0 || ~8.3.0 || ~8.4.0 || ~8.5.0",
-    "patchlevel/event-sourcing": "^3.18.0",
-    "patchlevel/hydrator": "^1.18.0",
+    "patchlevel/event-sourcing": "^3.19.1",
+    "patchlevel/hydrator": "^1.21.2",
     "symfony/cache": "^6.4.0 || ^7.0.0 || ^8.0.0",
     "symfony/config": "^6.4.0 || ^7.0.0 || ^8.0.0",
     "symfony/console": "^6.4.1 || ^7.0.1 || ^8.0.0",

composer.lock

@@ -5,6 +5,7 @@
 namespace Patchlevel\EventSourcingBundle\DependencyInjection;
 
 use Patchlevel\EventSourcing\Repository\AggregateOutdated;
+use Patchlevel\Hydrator\Extension\Cryptography\Cipher\OpensslCipherKeyFactory;
 use Symfony\Component\Config\Definition\Builder\TreeBuilder;
 use Symfony\Component\Config\Definition\ConfigurationInterface;
 use Throwable;
@@ -87,6 +88,17 @@
  *      },
  *      clock: array{freeze: ?string, service: ?string},
  *      aggregate_handlers: array{enabled: bool, bus: string|null},
+ *      hydrator: array{
+ *          enabled: bool,
+ *          default_lazy: bool,
+ *          cryptography: array{
+ *              enabled: bool,
+ *              algorithm: string,
+ *          },
+ *          lifecycle: array{
+ *              enabled: bool,
+ *          },
+ *      },
  * }
  */
 final class Configuration implements ConfigurationInterface
@@ -361,6 +373,25 @@ public function getConfigTreeBuilder(): TreeBuilder
                 )
             ->end()
 
+            ->arrayNode('hydrator')
+                ->canBeEnabled()
+                ->addDefaultsIfNotSet()
+                ->children()
+                    ->booleanNode('default_lazy')->defaultFalse()->end()
+                    ->arrayNode('cryptography')
+                        ->canBeEnabled()
+                        ->addDefaultsIfNotSet()
+                        ->children()
+                            ->scalarNode('algorithm')->defaultValue(OpensslCipherKeyFactory::DEFAULT_METHOD)->end()
+                        ->end()
+                    ->end()
+                    ->arrayNode('lifecycle')
+                        ->canBeEnabled()
+                        ->addDefaultsIfNotSet()
+                    ->end()
+                ->end()
+            ->end()
+
         ->end();
         // @codingStandardsIgnoreEnd
 

src/DependencyInjection/Configuration.php

@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Patchlevel\EventSourcingBundle\DependencyInjection;
+
+use Patchlevel\Hydrator\StackHydratorBuilder;
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Reference;
+
+use function array_keys;
+
+/** @internal */
+final class HydratorCompilerPass implements CompilerPassInterface
+{
+    public function process(ContainerBuilder $container): void
+    {
+        if (!$container->has(StackHydratorBuilder::class)) {
+            return;
+        }
+
+        $builder = $container->getDefinition(StackHydratorBuilder::class);
+        $extensions = $container->findTaggedServiceIds('event_sourcing.hydrator.extension');
+
+        foreach (array_keys($extensions) as $subscriberServiceName) {
+            $builder->addMethodCall('useExtension', [new Reference($subscriberServiceName)]);
+        }
+    }
+}

src/DependencyInjection/HydratorCompilerPass.php

@@ -45,6 +45,7 @@
 use Patchlevel\EventSourcing\Console\Command\WatchCommand;
 use Patchlevel\EventSourcing\Console\DoctrineHelper;
 use Patchlevel\EventSourcing\Cryptography\DoctrineCipherKeyStore;
+use Patchlevel\EventSourcing\Cryptography\ExtensionDoctrineCipherKeyStore;
 use Patchlevel\EventSourcing\EventBus\AttributeListenerProvider;
 use Patchlevel\EventSourcing\EventBus\Consumer;
 use Patchlevel\EventSourcing\EventBus\DefaultConsumer;
@@ -126,6 +127,7 @@
 use Patchlevel\EventSourcingBundle\DataCollector\MessageCollectorEventBus;
 use Patchlevel\EventSourcingBundle\Doctrine\DbalConnectionFactory;
 use Patchlevel\EventSourcingBundle\EventBus\SymfonyEventBus;
+use Patchlevel\EventSourcingBundle\Normalizer\SymfonyExtension;
 use Patchlevel\EventSourcingBundle\Normalizer\SymfonyGuesser;
 use Patchlevel\EventSourcingBundle\QueryBus\SymfonyQueryBus;
 use Patchlevel\EventSourcingBundle\RequestListener\AutoSetupListener;
@@ -134,20 +136,28 @@
 use Patchlevel\EventSourcingBundle\Subscription\ResetServicesListener;
 use Patchlevel\EventSourcingBundle\Subscription\StaticInMemorySubscriptionStoreFactory;
 use Patchlevel\EventSourcingBundle\ValueResolver\AggregateRootIdValueResolver;
+use Patchlevel\Hydrator\CoreExtension;
 use Patchlevel\Hydrator\Cryptography\Cipher\Cipher;
 use Patchlevel\Hydrator\Cryptography\Cipher\CipherKeyFactory;
 use Patchlevel\Hydrator\Cryptography\Cipher\OpensslCipher;
 use Patchlevel\Hydrator\Cryptography\Cipher\OpensslCipherKeyFactory;
 use Patchlevel\Hydrator\Cryptography\PayloadCryptographer;
 use Patchlevel\Hydrator\Cryptography\PersonalDataPayloadCryptographer;
 use Patchlevel\Hydrator\Cryptography\Store\CipherKeyStore;
+use Patchlevel\Hydrator\Extension as HydratorExtension;
+use Patchlevel\Hydrator\Extension\Cryptography\BaseCryptographer;
+use Patchlevel\Hydrator\Extension\Cryptography\Cryptographer;
+use Patchlevel\Hydrator\Extension\Cryptography\CryptographyExtension;
+use Patchlevel\Hydrator\Extension\Lifecycle\LifecycleExtension;
 use Patchlevel\Hydrator\Guesser\BuiltInGuesser;
 use Patchlevel\Hydrator\Guesser\ChainGuesser;
 use Patchlevel\Hydrator\Guesser\Guesser;
 use Patchlevel\Hydrator\Hydrator;
 use Patchlevel\Hydrator\Metadata\AttributeMetadataFactory;
 use Patchlevel\Hydrator\Metadata\MetadataFactory;
 use Patchlevel\Hydrator\MetadataHydrator;
+use Patchlevel\Hydrator\StackHydrator;
+use Patchlevel\Hydrator\StackHydratorBuilder;
 use Patchlevel\Worker\Event\WorkerRunningEvent;
 use Symfony\Component\DependencyInjection\Argument\TaggedIteratorArgument;
 use Symfony\Component\DependencyInjection\ChildDefinition;
@@ -156,7 +166,6 @@
 use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
 use Symfony\Component\DependencyInjection\Extension\Extension;
 use Symfony\Component\DependencyInjection\Reference;
-
 use function class_exists;
 use function sprintf;
 
@@ -177,7 +186,7 @@ public function load(array $configs, ContainerBuilder $container): void
             return;
         }
 
-        $this->configureHydrator($container);
+        $this->configureHydrator($config, $container);
         $this->configureUpcaster($container);
         $this->configureSerializer($config, $container);
         $this->configureMessageDecorator($container);
@@ -622,38 +631,93 @@ static function (ChildDefinition $definition): void {
             ]);
     }
 
-    private function configureHydrator(ContainerBuilder $container): void
+    /** @param Config $config */
+    private function configureHydrator(array $config, ContainerBuilder $container): void
     {
-        $container->register(ChainGuesser::class)
-            ->setArguments([new TaggedIteratorArgument('event_sourcing.hydrator.guesser')]);
+        if (!$config['hydrator']['enabled']) { // legacy MetadataHydrator
+            $container->register(ChainGuesser::class)
+                ->setArguments([new TaggedIteratorArgument('event_sourcing.hydrator.guesser')]);
 
-        $container->register(BuiltInGuesser::class)
-            ->addTag('event_sourcing.hydrator.guesser', ['priority' => -100]);
+            $container->register(BuiltInGuesser::class)
+                ->addTag('event_sourcing.hydrator.guesser', ['priority' => -64]);
 
-        $container->register(SymfonyGuesser::class)
-            ->addTag('event_sourcing.hydrator.guesser', ['priority' => -50]);
+            $container->register(SymfonyGuesser::class)
+                ->addTag('event_sourcing.hydrator.guesser', ['priority' => -32]);
 
-        $container->registerForAutoconfiguration(Guesser::class)
-            ->addTag('event_sourcing.hydrator.guesser');
+            $container->registerForAutoconfiguration(Guesser::class)
+                ->addTag('event_sourcing.hydrator.guesser');
 
-        $container->register(AttributeMetadataFactory::class)
-            ->setArguments([
-                null,
-                new Reference(ChainGuesser::class),
-            ]);
+            $container->register(AttributeMetadataFactory::class)
+                ->setArguments([
+                    null,
+                    new Reference(ChainGuesser::class),
+                ]);
 
-        $container->setAlias(MetadataFactory::class, AttributeMetadataFactory::class);
+            $container->setAlias(MetadataFactory::class, AttributeMetadataFactory::class);
 
-        $container->register(MetadataHydrator::class)
-            ->setArguments([
-                new Reference(MetadataFactory::class),
-                new Reference(
-                    PayloadCryptographer::class,
-                    ContainerInterface::IGNORE_ON_INVALID_REFERENCE,
-                ),
-            ]);
+            $container->register(MetadataHydrator::class)
+                ->setArguments([
+                    new Reference(MetadataFactory::class),
+                    new Reference(
+                        PayloadCryptographer::class,
+                        ContainerInterface::IGNORE_ON_INVALID_REFERENCE,
+                    ),
+                ]);
+
+            $container->setAlias(Hydrator::class, MetadataHydrator::class);
+
+            return;
+        }
+
+        $container->registerForAutoconfiguration(HydratorExtension::class)
+            ->addTag('event_sourcing.hydrator.extension');
+
+        $container->register(CoreExtension::class)
+            ->addTag('event_sourcing.hydrator.extension');
+
+        $container->register(SymfonyExtension::class)
+            ->addTag('event_sourcing.hydrator.extension');
+
+        if ($config['hydrator']['cryptography']['enabled']) {
+            $container->register(ExtensionDoctrineCipherKeyStore::class)
+                ->setArguments([new Reference('event_sourcing.dbal_connection')])
+                ->addTag('event_sourcing.doctrine_schema_configurator');
+
+            $container->setAlias(
+                \Patchlevel\Hydrator\Extension\Cryptography\Store\CipherKeyStore::class,
+                ExtensionDoctrineCipherKeyStore::class,
+            );
+
+            $container->register(BaseCryptographer::class)
+                ->setFactory([BaseCryptographer::class, 'createWithOpenssl'])
+                ->setArguments([
+                    new Reference(\Patchlevel\Hydrator\Extension\Cryptography\Store\CipherKeyStore::class),
+                    $config['hydrator']['cryptography']['algorithm'],
+                ]);
+
+            $container->setAlias(Cryptographer::class, BaseCryptographer::class);
+
+            $container->register(CryptographyExtension::class)
+                ->setArguments([
+                    new Reference(Cryptographer::class),
+                    new Reference(PayloadCryptographer::class, ContainerInterface::IGNORE_ON_INVALID_REFERENCE),
+                    true,
+                ])
+                ->addTag('event_sourcing.hydrator.extension');
+        }
+
+        if ($config['hydrator']['lifecycle']['enabled']) {
+            $container->register(LifecycleExtension::class)
+                ->addTag('event_sourcing.hydrator.extension');
+        }
+
+        $builder = $container->register(StackHydratorBuilder::class);
+        $builder->addMethodCall('enableDefaultLazy', [$config['hydrator']['default_lazy']]);
+
+        $container->register(StackHydrator::class)
+            ->setFactory([new Reference(StackHydratorBuilder::class), 'build']);
 
-        $container->setAlias(Hydrator::class, MetadataHydrator::class);
+        $container->setAlias(Hydrator::class, StackHydrator::class);
     }
 
     private function configureUpcaster(ContainerBuilder $container): void

src/DependencyInjection/PatchlevelEventSourcingExtension.php

@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Patchlevel\EventSourcingBundle\Normalizer;
+
+use Patchlevel\Hydrator\Extension;
+use Patchlevel\Hydrator\StackHydratorBuilder;
+
+class SymfonyExtension implements Extension
+{
+    public function configure(StackHydratorBuilder $builder): void
+    {
+        $builder->addGuesser(new SymfonyGuesser(), -32);
+    }
+}

src/Normalizer/SymfonyExtension.php

@@ -7,6 +7,7 @@
 use Patchlevel\EventSourcingBundle\DependencyInjection\CommandHandlerCompilerPass;
 use Patchlevel\EventSourcingBundle\DependencyInjection\DoctrineCleanupCompilerPass;
 use Patchlevel\EventSourcingBundle\DependencyInjection\HandlerServiceLocatorCompilerPass;
+use Patchlevel\EventSourcingBundle\DependencyInjection\HydratorCompilerPass;
 use Patchlevel\EventSourcingBundle\DependencyInjection\QueryHandlerCompilerPass;
 use Patchlevel\EventSourcingBundle\DependencyInjection\RepositoryCompilerPass;
 use Patchlevel\EventSourcingBundle\DependencyInjection\SubscriberGuardCompilePass;
@@ -25,5 +26,6 @@ public function build(ContainerBuilder $container): void
         $container->addCompilerPass(new HandlerServiceLocatorCompilerPass(), priority: -100);
         $container->addCompilerPass(new TranslatorCompilerPass());
         $container->addCompilerPass(new DoctrineCleanupCompilerPass());
+        $container->addCompilerPass(new HydratorCompilerPass());
     }
 }

src/PatchlevelEventSourcingBundle.php

@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Fixtures;
+
+use Patchlevel\Hydrator\Extension;
+use Patchlevel\Hydrator\StackHydratorBuilder;
+
+final readonly class DummyExtension implements Extension
+{
+    public function configure(StackHydratorBuilder $builder): void
+    {
+        // do nothing
+    }
+}