Extract aggregate root into traits to make it easier to avoid domain extending infrastructure

src/Aggregate/EventProducerTrait.php

@@ -0,0 +1,63 @@
+<?php
+/**
+ * This file is part of the prooph/event-sourcing.
+ * (c) 2014-2017 prooph software GmbH <[email protected]>
+ * (c) 2015-2017 Sascha-Oliver Prolic <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Prooph\EventSourcing\Aggregate;
+
+use Prooph\EventSourcing\AggregateChanged;
+
+trait EventProducerTrait
+{
+    /**
+     * Current version
+     *
+     * @var int
+     */
+    protected $version = 0;
+
+    /**
+     * List of events that are not committed to the EventStore
+     *
+     * @var AggregateChanged[]
+     */
+    protected $recordedEvents = [];
+
+    /**
+     * Get pending events and reset stack
+     *
+     * @return AggregateChanged[]
+     */
+    protected function popRecordedEvents(): array
+    {
+        $pendingEvents = $this->recordedEvents;
+
+        $this->recordedEvents = [];
+
+        return $pendingEvents;
+    }
+
+    /**
+     * Record an aggregate changed event
+     */
+    protected function recordThat(AggregateChanged $event): void
+    {
+        $this->version += 1;
+
+        $this->recordedEvents[] = $event->withVersion($this->version);
+
+        $this->apply($event);
+    }
+
+    /**
+     * Apply given event
+     */
+    abstract protected function apply(AggregateChanged $event): void;
+}

src/Aggregate/EventSourcedTrait.php

@@ -0,0 +1,58 @@
+<?php
+/**
+ * This file is part of the prooph/event-sourcing.
+ * (c) 2014-2017 prooph software GmbH <[email protected]>
+ * (c) 2015-2017 Sascha-Oliver Prolic <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Prooph\EventSourcing\Aggregate;
+
+use Iterator;
+use Prooph\EventSourcing\AggregateChanged;
+use RuntimeException;
+
+trait EventSourcedTrait
+{
+    /**
+     * Current version
+     *
+     * @var int
+     */
+    protected $version = 0;
+
+    /**
+     * @throws RuntimeException
+     */
+    protected static function reconstituteFromHistory(Iterator $historyEvents): self
+    {
+        $instance = new static();
+        $instance->replay($historyEvents);
+
+        return $instance;
+    }
+
+    /**
+     * Replay past events
+     *
+     * @throws RuntimeException
+     */
+    protected function replay(Iterator $historyEvents): void
+    {
+        foreach ($historyEvents as $pastEvent) {
+            /** @var AggregateChanged $pastEvent */
+            $this->version = $pastEvent->version();
+
+            $this->apply($pastEvent);
+        }
+    }
+
+    /**
+     * Apply given event
+     */
+    abstract protected function apply(AggregateChanged $event): void;
+}

src/AggregateRoot.php

@@ -12,35 +12,13 @@
 
 namespace Prooph\EventSourcing;
 
-use Iterator;
-use RuntimeException;
+use Prooph\EventSourcing\Aggregate\EventProducerTrait;
+use Prooph\EventSourcing\Aggregate\EventSourcedTrait;
 
 abstract class AggregateRoot
 {
-    /**
-     * Current version
-     *
-     * @var int
-     */
-    protected $version = 0;
-
-    /**
-     * List of events that are not committed to the EventStore
-     *
-     * @var AggregateChanged[]
-     */
-    protected $recordedEvents = [];
-
-    /**
-     * @throws RuntimeException
-     */
-    protected static function reconstituteFromHistory(Iterator $historyEvents): self
-    {
-        $instance = new static();
-        $instance->replay($historyEvents);
-
-        return $instance;
-    }
+    use EventProducerTrait;
+    use EventSourcedTrait;
 
     /**
      * We do not allow public access to __construct, this way we make sure that an aggregate root can only
@@ -51,50 +29,4 @@ protected function __construct()
     }
 
     abstract protected function aggregateId(): string;
-
-    /**
-     * Get pending events and reset stack
-     *
-     * @return AggregateChanged[]
-     */
-    protected function popRecordedEvents(): array
-    {
-        $pendingEvents = $this->recordedEvents;
-
-        $this->recordedEvents = [];
-
-        return $pendingEvents;
-    }
-
-    /**
-     * Record an aggregate changed event
-     */
-    protected function recordThat(AggregateChanged $event): void
-    {
-        $this->version += 1;
-
-        $this->recordedEvents[] = $event->withVersion($this->version);
-
-        $this->apply($event);
-    }
-
-    /**
-     * Replay past events
-     *
-     * @throws RuntimeException
-     */
-    protected function replay(Iterator $historyEvents): void
-    {
-        foreach ($historyEvents as $pastEvent) {
-            /** @var AggregateChanged $pastEvent */
-            $this->version = $pastEvent->version();
-
-            $this->apply($pastEvent);
-        }
-    }
-
-    /**
-     * Apply given event
-     */
-    abstract protected function apply(AggregateChanged $event): void;
 }

src/EventStoreIntegration/ClosureAggregateTranslator.php

@@ -0,0 +1,117 @@
+<?php
+/**
+ * This file is part of the prooph/event-sourcing.
+ * (c) 2014-2017 prooph software GmbH <[email protected]>
+ * (c) 2015-2017 Sascha-Oliver Prolic <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Prooph\EventSourcing\EventStoreIntegration;
+
+use Iterator;
+use Prooph\Common\Messaging\Message;
+use Prooph\EventSourcing\Aggregate\AggregateTranslator as EventStoreAggregateTranslator;
+use Prooph\EventSourcing\Aggregate\AggregateType;
+use RuntimeException;
+
+final class ClosureAggregateTranslator implements EventStoreAggregateTranslator
+{
+    protected $aggregateIdExtractor;
+    protected $aggregateReconstructor;
+    protected $pendingEventsExtractor;
+    protected $replayStreamEvents;
+    protected $versionExtractor;
+
+    /**
+     * @param object $eventSourcedAggregateRoot
+     *
+     * @return int
+     */
+    public function extractAggregateVersion($eventSourcedAggregateRoot): int
+    {
+        if (null === $this->versionExtractor) {
+            $this->versionExtractor = function (): int {
+                return $this->version;
+            };
+        }
+
+        return $this->versionExtractor->call($eventSourcedAggregateRoot);
+    }
+
+    /**
+     * @param object $anEventSourcedAggregateRoot
+     *
+     * @return string
+     */
+    public function extractAggregateId($anEventSourcedAggregateRoot): string
+    {
+        if (null === $this->aggregateIdExtractor) {
+            $this->aggregateIdExtractor = function (): string {
+                return $this->aggregateId();
+            };
+        }
+
+        return $this->aggregateIdExtractor->call($anEventSourcedAggregateRoot);
+    }
+
+    /**
+     * @param AggregateType $aggregateType
+     * @param Iterator $historyEvents
+     *
+     * @return object reconstructed AggregateRoot
+     */
+    public function reconstituteAggregateFromHistory(AggregateType $aggregateType, Iterator $historyEvents)
+    {
+        if (null === $this->aggregateReconstructor) {
+            $this->aggregateReconstructor = function ($historyEvents) {
+                return static::reconstituteFromHistory($historyEvents);
+            };
+        }
+
+        $arClass = $aggregateType->toString();
+
+        if (! class_exists($arClass)) {
+            throw new RuntimeException(
+                sprintf('Aggregate root class %s cannot be found', $arClass)
+            );
+        }
+
+        return ($this->aggregateReconstructor->bindTo(null, $arClass))($historyEvents);
+    }
+
+    /**
+     * @param object $anEventSourcedAggregateRoot
+     *
+     * @return Message[]
+     */
+    public function extractPendingStreamEvents($anEventSourcedAggregateRoot): array
+    {
+        if (null === $this->pendingEventsExtractor) {
+            $this->pendingEventsExtractor = function (): array {
+                return $this->popRecordedEvents();
+            };
+        }
+
+        return $this->pendingEventsExtractor->call($anEventSourcedAggregateRoot);
+    }
+
+    /**
+     * @param object $anEventSourcedAggregateRoot
+     * @param Iterator $events
+     *
+     * @return void
+     */
+    public function replayStreamEvents($anEventSourcedAggregateRoot, Iterator $events): void
+    {
+        if (null === $this->replayStreamEvents) {
+            $this->replayStreamEvents = function ($events): void {
+                $this->replay($events);
+            };
+        }
+        $this->replayStreamEvents->call($anEventSourcedAggregateRoot, $events);
+    }
+}

tests/EventStoreIntegration/AggregateTranslatorTest.php

@@ -129,7 +129,7 @@ protected function resetRepository()
     {
         $this->repository = new AggregateRepository(
             $this->eventStore,
-            AggregateType::fromAggregateRootClass('ProophTest\EventSourcing\Mock\User'),
+            AggregateType::fromAggregateRootClass(User::class),
             new AggregateTranslator()
         );
     }