Working prototype - baseline for writing exercises for attendees

composer.json

@@ -25,9 +25,11 @@
     "require-dev": {
         "doctrine/coding-standard": "^9.0.0",
         "doctrine/migrations": "^3.5",
+        "php-standard-library/psalm-plugin": "^2.0",
         "phpunit/phpunit": "^9.5.21",
         "psalm/plugin-phpunit": "^0.17.0",
         "qossmic/deptrac-shim": "^0.23.0",
+        "symfony/console": "^6.1",
         "vimeo/psalm": "^4.24.0"
     },
     "config": {

psalm.xml

@@ -5,18 +5,18 @@
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xmlns="https://getpsalm.org/schema/config"
     xsi:schemaLocation="https://getpsalm.org/schema/config vendor/vimeo/psalm/config.xsd"
+    findUnusedCode="true"
 >
-    <!-- findUnusedCode="true" -->
-
     <projectFiles>
-        <directory name="src" />
-        <directory name="test" />
+        <directory name="src"/>
+        <directory name="test"/>
         <ignoreFiles>
-            <directory name="vendor" />
+            <directory name="vendor"/>
         </ignoreFiles>
     </projectFiles>
-    
+
     <plugins>
         <pluginClass class="Psalm\PhpUnitPlugin\Plugin"/>
+        <pluginClass class="Psl\Psalm\Plugin"/>
     </plugins>
 </psalm>

src/Commanding/Infrastructure/CommandBus.php

@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace EventSourcingWorkshop\Commanding\Infrastructure;
+
+use EventSourcingWorkshop\Commanding\Domain\Command;
+use EventSourcingWorkshop\Commanding\Infrastructure\Exception\CommandNotHandled;
+
+interface CommandBus
+{
+    /** @throws CommandNotHandled */
+    public function __invoke(Command $command): void;
+}

src/Commanding/Infrastructure/CommandHandler.php

@@ -0,0 +1,17 @@
+<?php
+
+declare(strict_types=1);
+
+namespace EventSourcingWorkshop\Commanding\Infrastructure;
+
+use EventSourcingWorkshop\Commanding\Domain\Command;
+
+/** @template HandledCommand of Command */
+interface CommandHandler
+{
+    /** @param HandledCommand $command */
+    public function __invoke(Command $command): void;
+
+    /** @return class-string<HandledCommand> */
+    public function handlesCommand(): string;
+}

src/Commanding/Infrastructure/Exception/CommandNotHandled.php

@@ -0,0 +1,42 @@
+<?php
+
+declare(strict_types=1);
+
+namespace EventSourcingWorkshop\Commanding\Infrastructure\Exception;
+
+use EventSourcingWorkshop\Commanding\Domain\Command;
+use EventSourcingWorkshop\Commanding\Infrastructure\CommandHandler;
+use Psl\Json;
+use Psl\Str;
+use Psl\Vec;
+use RuntimeException;
+use function get_class;
+
+final class CommandNotHandled extends RuntimeException
+{
+    private function __construct(string $message, public readonly Command $command)
+    {
+        parent::__construct($message);
+    }
+
+    /** @param list<CommandHandler> $commandHandlers */
+    public static function fromCommandAndConfiguredCommandHandlers(
+        Command $command,
+        array $commandHandlers
+    ): self {
+        return new self(
+            Str\format(
+                "Could not handle command of type \"%s\".\nConfigured handlers:\n%s",
+                get_class($command),
+                Json\encode(
+                    array_combine(
+                        Vec\map($commandHandlers, static fn (CommandHandler $handler): string => $handler->handlesCommand()),
+                        Vec\map($commandHandlers, \get_class(...)),
+                    ),
+                    true
+                )
+            ),
+            $command
+        );
+    }
+}

src/Commanding/Infrastructure/HandleCommandThroughGivenCommandHandlers.php

@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+namespace EventSourcingWorkshop\Commanding\Infrastructure;
+
+use EventSourcingWorkshop\Commanding\Domain\Command;
+use EventSourcingWorkshop\Commanding\Infrastructure\Exception\CommandNotHandled;
+
+final class HandleCommandThroughGivenCommandHandlers implements CommandBus
+{
+    /**
+     * @template CommandType of Command
+     *
+     * @param list<CommandHandler<CommandType>> $handlers
+     */
+    public function __construct(private readonly array $handlers)
+    {
+    }
+
+    public function __invoke(Command $command): void
+    {
+        foreach ($this->handlers as $handler) {
+            $handledCommand = $handler->handlesCommand();
+
+            if ($command instanceof $handledCommand) {
+                $handler($command);
+
+                return;
+            }
+        }
+
+        throw CommandNotHandled::fromCommandAndConfiguredCommandHandlers($command, $this->handlers);
+    }
+}

src/EventSourcing/Domain/Aggregate/Aggregate.php

@@ -32,15 +32,4 @@ interface Aggregate
      * @psalm-pure
      */
     public static function fromHistory(AggregateId $id, array $history): static;
-
-    /**
-     * This method will tell us the type of aggregate identifier to be used with this specific
-     * aggregate: useful when we look for when we de-serialize an aggregate from memory, but
-     * don't have the aggregate nor aggregate id instance, but just the aggregate class name.
-     *
-     * @return class-string<AggregateId<static>>
-     *
-     * @psalm-pure
-     */
-    public static function idType(): string;
 }

src/EventSourcing/Domain/Aggregate/AggregateDomainEvent.php

@@ -15,17 +15,4 @@ interface AggregateDomainEvent extends DomainEvent
 {
     /** @psalm-return AggregateId<AggregateType> */
     public function aggregate(): AggregateId;
-
-    /**
-     * @param array<non-empty-string, string|int|bool|float|array|null> $data
-     * @psalm-param AggregateId<AggregateTypeForId>                     $aggregate
-     *
-     * @psalm-template AggregateTypeForId of Aggregate
-     * @psalm-pure
-     */
-    public static function tryFrom(
-        AggregateId $aggregate,
-        DateTimeImmutable $raisedAt,
-        array $data // @TODO use valinor here?
-    ): static; // @TODO JSONSerialize?
 }

src/EventSourcing/Domain/Aggregate/AggregateId.php

@@ -20,14 +20,4 @@ public function toUuid(): UuidInterface;
 
     /** @psalm-return class-string<AggregateType> */
     public function aggregateType(): string;
-
-    /**
-     * @psalm-param non-empty-string $id
-     *
-     * @psalm-pure
-     */
-    public static function fromString(string $id): static;
-
-    /** @psalm-pure */
-    public static function fromUuid(UuidInterface $id): static;
 }

src/EventSourcing/Domain/Policy.php

@@ -22,5 +22,5 @@ interface Policy
     public function __invoke(DomainEvent $event): array;
 
     /** @psalm-return class-string<HandledDomainEvent> */
-    public static function supportedDomainEvent(): string;
+    public function supportedDomainEvent(): string;
 }

src/EventSourcing/Infrastructure/Aggregate/EventStreamAggregateRepository.php

@@ -0,0 +1,118 @@
+<?php
+
+declare(strict_types=1);
+
+namespace EventSourcingWorkshop\EventSourcing\Infrastructure\Aggregate;
+
+use Doctrine\DBAL\Connection;
+use Doctrine\DBAL\Types\Types;
+use EventSourcingWorkshop\EventSourcing\Domain\Aggregate\Aggregate;
+use EventSourcingWorkshop\EventSourcing\Domain\Aggregate\AggregateChanged;
+use EventSourcingWorkshop\EventSourcing\Domain\Aggregate\AggregateDomainEvent;
+use EventSourcingWorkshop\EventSourcing\Domain\Aggregate\AggregateId;
+use EventSourcingWorkshop\EventSourcing\Domain\Aggregate\AggregateRepository;
+use EventSourcingWorkshop\EventSourcing\Domain\Aggregate\Exception\AggregateNotFound;
+use EventSourcingWorkshop\EventSourcing\Infrastructure\Serialization\DeSerializeEvent;
+use Webmozart\Assert\Assert;
+use function Psl\Json\typed;
+use function Psl\Type\dict;
+use function Psl\Type\mixed;
+use function Psl\Type\non_empty_string;
+
+/** @template-implements AggregateRepository<Aggregate> */
+final class EventStreamAggregateRepository implements AggregateRepository
+{
+    public function __construct(
+        private readonly Connection $db,
+        private readonly DeSerializeEvent $loadEvent
+    ) {
+    }
+
+    public function save(AggregateChanged $changed): void
+    {
+        $this->db->transactional(function () use ($changed) {
+            $version = $changed->previousVersion;
+
+            foreach ($changed->raisedEvents as $event) {
+                ++$version;
+
+                $this->db->insert(
+                    'event_stream',
+                    [
+                        'event_type'             => get_class($event),
+                        'aggregate_root_type'    => $event->aggregate()
+                            ->aggregateType(),
+                        'aggregate_root_id'      => $event->aggregate()
+                            ->toUuid()
+                            ->getBytes(),
+                        'aggregate_root_version' => $version,
+                        'time_of_recording'      => $event->raisedAt()
+                            ->format('Y-m-d H:i:s.u'),
+                        'payload'                => $event->toArray(),
+                    ],
+                    [
+                        'event_type'             => Types::STRING,
+                        'aggregate_root_type'    => Types::STRING,
+                        'aggregate_root_id'      => Types::STRING,
+                        'aggregate_root_version' => Types::INTEGER,
+                        'time_of_recording'      => Types::STRING,
+                        'payload'                => Types::JSON,
+                    ]
+                );
+            }
+        });
+    }
+
+    public function get(AggregateId $id): Aggregate
+    {
+        /**
+         * @psalm-var list<array{
+         *     event_type: class-string,
+         *     time_of_recording: non-empty-string,
+         *     payload: non-empty-string
+         * }>
+         */
+        $events = $this->db->fetchAllAssociative(<<<'SQL'
+SELECT
+    event_type,
+    time_of_recording,
+    payload
+FROM event_stream
+WHERE aggregate_root_id = :aggregateId 
+ORDER BY aggregate_root_version ASC
+SQL
+            ,
+            [
+                'aggregateId' => $id->toUuid()
+                    ->getBytes(),
+            ],
+            [
+                'aggregateId' => Types::STRING,
+            ]
+        );
+
+        if ([] === $events) {
+            throw AggregateNotFound::forAggregateId($id);
+        }
+
+        /** @psalm-var AggregateDomainEvent<Aggregate> $events */
+        $events = array_map(
+            function (array $row): AggregateDomainEvent {
+                Assert::implementsInterface($row['event_type'], AggregateDomainEvent::class);
+
+                return ($this->loadEvent)(
+                    $row['event_type'],
+                    typed($row['payload'], dict(non_empty_string(), mixed()))
+                );
+            },
+            $events
+        );
+
+        /**
+         * @psalm-suppress InvalidArgument it is impossible to reconcile AggregateDomainEvent<Aggregate&static>>
+         *                 with AggregateDomainEvent<Aggregate>> here, because Aggregate may have multiple
+         *                 levels of inheritance here: we'll have to roll with a suppression.
+         */
+        return $id->aggregateType()::fromHistory($id, $events);
+    }
+}