dcb poc

Author: DavidBadura

composer.json

@@ -19,7 +19,7 @@
     }
   ],
   "require": {
-    "php": "~8.2.0 || ~8.3.0 || ~8.4.0",
+    "php": "~8.4.0",
     "doctrine/dbal": "^4.0.0",
     "doctrine/migrations": "^3.3.2",
     "patchlevel/hydrator": "^1.8.0",

composer.lock

@@ -0,0 +1,2 @@
+# Dynamic Consistency Boundary
+

docs/pages/dynamic_consistency_boundary.md

@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Patchlevel\EventSourcing\Attribute;
+
+use Attribute;
+
+#[Attribute(Attribute::TARGET_PROPERTY)]
+final class EventTag
+{
+    public function __construct(
+        public readonly string|null $prefix = null,
+    ) {
+    }
+}

src/Attribute/EventTag.php

@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Patchlevel\EventSourcing\DCB;
+
+/** @experimental */
+final class AppendCondition
+{
+    /** @param list<list<string>> $tags */
+    public function __construct(
+        public readonly array $tags,
+        public readonly HighestSequenceNumber|null $expectedHighestSequenceNumber = null,
+    ) {
+    }
+}

src/DCB/AppendCondition.php

@@ -0,0 +1,58 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Patchlevel\EventSourcing\DCB;
+
+use Patchlevel\EventSourcing\Aggregate\AggregateRootId;
+use Patchlevel\EventSourcing\Attribute\EventTag;
+use ReflectionClass;
+use RuntimeException;
+
+use function array_keys;
+use function get_debug_type;
+use function is_int;
+use function is_string;
+use function sprintf;
+
+/** @experimental */
+final class AttributeEventTagExtractor implements EventTagExtractor
+{
+    /** @return list<string> */
+    public function extract(object $event): array
+    {
+        $reflectionClass = new ReflectionClass($event);
+
+        $tags = [];
+
+        foreach ($reflectionClass->getProperties() as $property) {
+            $attributes = $property->getAttributes(EventTag::class);
+
+            if ($attributes === []) {
+                continue;
+            }
+
+            $attribute = $attributes[0]->newInstance();
+
+            $value = $property->getValue($event);
+
+            if ($value instanceof AggregateRootId) {
+                $value = $value->toString();
+            }
+
+            if (!is_string($value) && !is_int($value)) {
+                throw new RuntimeException(
+                    sprintf('Event tag value must be a string or an int, %s given', get_debug_type($value)),
+                );
+            }
+
+            if ($attribute->prefix) {
+                $value = $attribute->prefix . ':' . $value;
+            }
+
+            $tags[(string)$value] = true;
+        }
+
+        return array_keys($tags);
+    }
+}

src/DCB/AttributeEventTagExtractor.php

@@ -0,0 +1,95 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Patchlevel\EventSourcing\DCB;
+
+use Patchlevel\EventSourcing\Message\Message;
+use Patchlevel\EventSourcing\Store\Header\TagsHeader;
+
+use function array_diff;
+use function array_map;
+use function array_merge;
+use function array_unique;
+use function array_values;
+use function in_array;
+use function sort;
+
+/**
+ * @experimental
+ * @extends Projection<array<string, mixed>>
+ */
+final class CompositeProjection extends Projection
+{
+    /** @param array<string, Projection> $projections */
+    public function __construct(
+        private readonly array $projections,
+    ) {
+    }
+
+    /** @return list<string> */
+    public function tagFilter(): array
+    {
+        $tags = [];
+
+        foreach ($this->projections as $projection) {
+            $tags = array_merge($tags, $projection->tagFilter());
+        }
+
+        return array_values(array_unique($tags));
+    }
+
+    /** @return list<list<string>> */
+    public function groupedTagFilter(): array
+    {
+        $result = [];
+
+        foreach ($this->projections as $projection) {
+            $tags = $projection->tagFilter();
+
+            sort($tags);
+
+            if (in_array($tags, $result, true)) {
+                continue;
+            }
+
+            $result[] = $tags;
+        }
+
+        return $result;
+    }
+
+    /** @return array<string, mixed> */
+    public function initialState(): array
+    {
+        return array_map(static function (Projection $projection) {
+            return $projection->initialState();
+        }, $this->projections);
+    }
+
+    public function apply(mixed $state, Message $message): mixed
+    {
+        $tags = $message->header(TagsHeader::class)->tags;
+
+        foreach ($this->projections as $name => $projection) {
+            $neededTags = $projection->tagFilter();
+
+            if (!$this->isSubset($neededTags, $tags)) {
+                continue;
+            }
+
+            $state[$name] = $projection->apply($state[$name], $message);
+        }
+
+        return $state;
+    }
+
+    /**
+     * @param list<string> $needle
+     * @param list<string> $haystack
+     */
+    private function isSubset(array $needle, array $haystack): bool
+    {
+        return empty(array_diff($needle, $haystack));
+    }
+}

src/DCB/CompositeProjection.php

@@ -0,0 +1,50 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Patchlevel\EventSourcing\DCB;
+
+use ArrayAccess;
+use LogicException;
+use OutOfBoundsException;
+
+use function array_key_exists;
+
+/**
+ * @experimental
+ * @psalm-immutable
+ * @implements ArrayAccess<string, mixed>
+ */
+final class DecisionModel implements ArrayAccess
+{
+    /** @param array<string, mixed> $state */
+    public function __construct(
+        public readonly array $state,
+        public readonly AppendCondition $appendCondition,
+    ) {
+    }
+
+    public function offsetExists(mixed $offset): bool
+    {
+        return array_key_exists($offset, $this->state);
+    }
+
+    public function offsetGet(mixed $offset): mixed
+    {
+        if (!$this->offsetExists($offset)) {
+            throw new OutOfBoundsException("Offset '$offset' does not exist in the state.");
+        }
+
+        return $this->state[$offset];
+    }
+
+    public function offsetSet(mixed $offset, mixed $value): void
+    {
+        throw new LogicException('State is immutable, cannot set value.');
+    }
+
+    public function offsetUnset(mixed $offset): void
+    {
+        throw new LogicException('State is immutable, cannot unset value.');
+    }
+}

src/DCB/DecisionModel.php

@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Patchlevel\EventSourcing\DCB;
+
+/** @experimental */
+interface DecisionModelBuilder
+{
+    /** @param array<string, Projection> $projections */
+    public function build(
+        array $projections,
+    ): DecisionModel;
+}

src/DCB/DecisionModelBuilder.php

@@ -0,0 +1,12 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Patchlevel\EventSourcing\DCB;
+
+/** @experimental */
+interface EventAppender
+{
+    /** @param iterable<object> $events */
+    public function append(iterable $events, AppendCondition|null $appendCondition = null): void;
+}