update readme

Author: DavidBadura

README.md

@@ -13,36 +13,57 @@ composer require patchlevel/event-sourcing-psr-container
 
 ## Documentation
 
+### Config Builder
+
+To create a configuration array, you can use the ConfigBuilder. 
+This offers methods to adjust the configuration.
+
+```php
+$eventSourcingConfig = (new ConfigBuilder())
+    ->singleTable()
+    ->databaseUrl('mysql://user:secret@localhost/app')
+    ->addAggregatePath(__DIR__ . '/Aggregate')
+    ->addEventPath(__DIR__ . '/Events')
+    ->addProcessor(SendEmailProcessor::class)
+    ->addProjector(ProfileProjection::class)
+    ->build();
+```
+
 ### Default Build-In Container
 
+The own PSR container implementation already integrates all necessary factories. 
+So we only have to pass the configuration.
+
 ```php
 use Patchlevel\EventSourcing\Container\ConfigBuilder;
 use Patchlevel\EventSourcing\Container\DefaultContainer;
 
-$config = (new ConfigBuilder())
-    ->singleTable()
-    ->databaseUrl('mysql://user:secret@localhost/app')
-    ->addAggregatePath('src/Domain/Hotel')
-    ->addEventPath('src/Domain/Hotel/Event')
-    ->addProjector(HotelProjection::class)
-    ->addProcessor(SendCheckInEmailProcessor::class)
-    ->build();
-    
 $container = new DefaultContainer(
-    $config,
+    $eventSourcingConfig,
     [
         HotelProjection::class => fn(DefaultContainer $container) 
             => new HotelProjection($container->connection()),
-        SendCheckInEmailProcessor::class => fn(DefaultContainer $container) 
-            => new SendCheckInEmailProcessor($container->get('mailer')),
+        SendEmailProcessor::class => fn(DefaultContainer $container) 
+            => new SendEmailProcessor($container->get('mailer')),
     ]
 );
 
+$container->get(SchemaDirector::class)->create();
+
 $hotelRepository = $container->repository(Hotel::class);
 ```
 
 ### Laminas Service Manager
 
+Factories can also be used with other PSR-11 compatible libraries. 
+Here is an example with [Laminas](https://docs.laminas.dev/laminas-servicemanager/).
+
+```bash
+composer require laminas/laminas-servicemanager
+```
+
+We only have to specify the factories and pass the configuration.
+
 ```php
 use Laminas\ServiceManager\ServiceManager;
 use Patchlevel\EventSourcing\Repository\RepositoryManager;
@@ -52,29 +73,23 @@ use Patchlevel\EventSourcingPsrContainer\Factory\ConnectionFactory;
 use Patchlevel\EventSourcingPsrContainer\Factory\RepositoryManagerFactory;
 use Patchlevel\EventSourcingPsrContainer\Factory\SchemaDirectorFactory;
 
-$config = (new ConfigBuilder())
-    ->singleTable()
-    ->databaseUrl('sqlite:///:memory:')
-    ->addAggregatePath(__DIR__ . '/Aggregate')
-    ->addEventPath(__DIR__ . '/Events')
-    ->addProcessor(SendEmailProcessor::class)
-    ->addProjector(ProfileProjection::class)
-    ->build();
-
 $serviceManager = new ServiceManager([
     'services' => [
         'config' => [
-            'event_sourcing' => $config
+            'event_sourcing' => $eventSourcingConfig
         ],
         SendEmailProcessor::class => new SendEmailProcessor()
     ],
     'factories' => [
         'event_sourcing.connection' => new ConnectionFactory(),
         RepositoryManager::class => new RepositoryManagerFactory(),
         SchemaDirector::class => new SchemaDirectorFactory(),
-        ProfileProjection::class => static fn (ServiceManager $container) => new ProfileProjection($container->get('event_sourcing.connection')),
+        HotelProjection::class => static fn (ServiceManager $container) => new HotelProjection($container->get('event_sourcing.connection')),
     ],
 ]);
 
+$serviceManager->get(SchemaDirector::class)->create();
+
 $repositoryManager = $serviceManager->get(RepositoryManager::class);
+$hotelRepository = $repositoryManager->get(Hotel::class);
 ```

psalm.xml

@@ -16,8 +16,6 @@
     </projectFiles>
 
     <plugins>
-        <pluginClass class="Patchlevel\EventSourcingPsalmPlugin\Plugin"/>
         <pluginClass class="Psalm\PhpUnitPlugin\Plugin"/>
-        <pluginClass class="Cspray\Phinal\Plugin"/>
     </plugins>
 </psalm>

src/ConfigBuilder.php

@@ -4,18 +4,28 @@
 
 namespace Patchlevel\EventSourcingPsrContainer;
 
+use Patchlevel\EventSourcingPsrContainer\Factory\AggregateRootRegistryFactory;
+use Patchlevel\EventSourcingPsrContainer\Factory\ConnectionFactory;
+use Patchlevel\EventSourcingPsrContainer\Factory\EventBusFactory;
+use Patchlevel\EventSourcingPsrContainer\Factory\EventSerializerFactory;
+use Patchlevel\EventSourcingPsrContainer\Factory\ProjectorRepositoryFactory;
+use Patchlevel\EventSourcingPsrContainer\Factory\StoreFactory;
+
 /**
+ * @psalm-import-type Config from AggregateRootRegistryFactory as AggregateConfig
+ * @psalm-import-type Config from ConnectionFactory as ConnectionConfig
+ * @psalm-import-type Config from EventBusFactory as EventBusConfig
+ * @psalm-import-type Config from EventSerializerFactory as EventConfig
+ * @psalm-import-type Config from ProjectorRepositoryFactory as ProjectionConfig
+ * @psalm-import-type Config from StoreFactory as StoreConfig
+ *
  * @psalm-type Config = array{
- *     event_bus: ?array{type: string, service: string},
- *     projection: array{projectionist: bool},
- *     watch_server: array{enabled: bool, host: string},
- *     connection: ?array{service: ?string, url: ?string},
- *     store: array{type: string, merge_orm_schema: bool},
- *     aggregates: list<string>,
- *     events: list<string>,
- *     snapshot_stores: array<string, array{type: string, service: string}>,
- *     migration: array{path: string, namespace: string},
- *     clock: array{freeze: ?string, service: ?string}
+ *     event_bus: EventBusConfig,
+ *     projection: ProjectionConfig,
+ *     connection: ConnectionConfig,
+ *     store: StoreConfig,
+ *     aggregate: AggregateConfig,
+ *     event: EventConfig
  * }
  */
 final class ConfigBuilder
@@ -137,7 +147,9 @@ public function build(): array
             'event_bus' => [
                 'listeners' => $this->processors,
             ],
-            'projectors' => $this->projectors,
+            'projection' => [
+                'projectors' => $this->projectors
+            ],
         ];
     }
 }

src/Factory/AggregateRootRegistryFactory.php

@@ -4,21 +4,24 @@
 
 namespace Patchlevel\EventSourcingPsrContainer\Factory;
 
+use Patchlevel\EventSourcing\Aggregate\AggregateRoot;
 use Patchlevel\EventSourcing\Metadata\AggregateRoot\AggregateRootRegistry;
 use Patchlevel\EventSourcing\Metadata\AggregateRoot\AttributeAggregateRootRegistryFactory;
 use Psr\Container\ContainerInterface;
 
 /**
  * @psalm-type Config = array{
  *     paths: list<string>,
- *     classes: list<string>,
+ *     classes: array<string, class-string<AggregateRoot>>,
  * }
+ *
+ * @extends Factory<Config>
  */
 final class AggregateRootRegistryFactory extends Factory
 {
-    protected function createWithConfig(ContainerInterface $container): AggregateRootRegistry
+    public function __invoke(ContainerInterface $container): AggregateRootRegistry
     {
-        $config = $this->retrieveConfig($container, 'aggregate');
+        $config = $this->sectionConfig($container);
 
         $aggregateRootRegistry = new AggregateRootRegistry($config['classes']);
 
@@ -39,4 +42,9 @@ protected function defaultConfig(): array
             'classes' => [],
         ];
     }
+
+    protected function section(): string
+    {
+        return 'aggregate';
+    }
 }

src/Factory/ConnectionFactory.php

@@ -8,16 +8,28 @@
 use Doctrine\DBAL\DriverManager;
 use Psr\Container\ContainerInterface;
 
+/**
+ * @psalm-type Config = array{
+ *     url: string
+ * }
+ *
+ * @extends Factory<Config>
+ */
 final class ConnectionFactory extends Factory
 {
     public const SERVICE_NAME = 'event_sourcing.connection';
 
-    protected function createWithConfig(ContainerInterface $container): Connection
+    public function __invoke(ContainerInterface $container): Connection
     {
-        $config = $this->retrieveConfig($container, 'connection');
+        $config = $this->sectionConfig($container);
 
         return DriverManager::getConnection([
             'url' => $config['url'],
         ]);
     }
+
+    protected function section(): string
+    {
+        return 'connection';
+    }
 }

src/Factory/EventBusFactory.php

@@ -13,11 +13,18 @@
 
 use function array_map;
 
+/**
+ * @psalm-type Config = array{
+ *     listeners: list<string>
+ * }
+ *
+ * @extends Factory<Config>
+ */
 final class EventBusFactory extends Factory
 {
-    protected function createWithConfig(ContainerInterface $container): EventBus
+    public function __invoke(ContainerInterface $container): EventBus
     {
-        $config = $this->retrieveConfig($container, 'event_bus');
+        $config = $this->sectionConfig($container);
 
         $listeners = array_map(static fn (string $id): Listener => $container->get($id), $config['listeners']);
 
@@ -32,10 +39,18 @@ protected function createWithConfig(ContainerInterface $container): EventBus
         return new DefaultEventBus($listeners);
     }
 
+    /**
+     * @return Config
+     */
     protected function defaultConfig(): array
     {
         return [
             'listeners' => [],
         ];
     }
+
+    protected function section(): string
+    {
+        return 'event_bus';
+    }
 }

src/Factory/EventSerializerFactory.php

@@ -8,19 +8,34 @@
 use Patchlevel\EventSourcing\Serializer\EventSerializer;
 use Psr\Container\ContainerInterface;
 
+/**
+ * @psalm-type Config = array{
+ *     paths: list<string>
+ * }
+ *
+ * @extends Factory<Config>
+ */
 final class EventSerializerFactory extends Factory
 {
-    protected function createWithConfig(ContainerInterface $container): EventSerializer
+    public function __invoke(ContainerInterface $container): EventSerializer
     {
-        $config = $this->retrieveConfig($container, 'event');
+        $config = $this->sectionConfig($container);
 
         return DefaultEventSerializer::createFromPaths($config['paths']);
     }
 
+    /**
+     * @return Config
+     */
     protected function defaultConfig(): array
     {
         return [
             'paths' => [],
         ];
     }
+
+    protected function section(): string
+    {
+        return 'event';
+    }
 }

src/Factory/Factory.php

@@ -10,29 +10,41 @@
 use function array_replace_recursive;
 use function is_array;
 
+/**
+ * @template C as array
+ */
 abstract class Factory
 {
     final public function __construct()
     {
     }
 
-    public function __invoke(ContainerInterface $container): mixed
+    abstract public function __invoke(ContainerInterface $container): mixed;
+
+    protected function section(): ?string
     {
-        return $this->createWithConfig($container);
+        return null;
     }
 
-    abstract protected function createWithConfig(ContainerInterface $container): mixed;
-
     /**
-     * @return array<string, mixed>
+     * @return C
      */
     protected function defaultConfig(): array
     {
         return [];
     }
 
-    protected function retrieveConfig(ContainerInterface $container, string $section): array
+    /**
+     * @return C
+     */
+    protected function sectionConfig(ContainerInterface $container): array
     {
+        $section = $this->section();
+
+        if ($section === null) {
+            return $this->defaultConfig();
+        }
+
         $applicationConfig = $container->has('config') ? $container->get('config') : [];
 
         if (!is_array($applicationConfig)) {

src/Factory/ProjectorRepositoryFactory.php

@@ -11,14 +11,26 @@
 
 use function array_map;
 
+/**
+ * @psalm-type Config = array{
+ *     projectors: list<string>
+ * }
+ *
+ * @extends Factory<Config>
+ */
 final class ProjectorRepositoryFactory extends Factory
 {
-    protected function createWithConfig(ContainerInterface $container): ProjectorRepository
+    public function __invoke(ContainerInterface $container): ProjectorRepository
     {
-        $config = $this->retrieveConfig($container, 'projectors');
+        $config = $this->sectionConfig($container);
 
         return new InMemoryProjectorRepository(
-            array_map(static fn (string $id): Projector => $container->get($id), $config)
+            array_map(static fn (string $id): Projector => $container->get($id), $config['projectors'])
         );
     }
+
+    protected function section(): string
+    {
+        return 'projection';
+    }
 }