Daikon\EventSourcing\Aggregate\AggregateRootTrait

Complexity

Total Complexity

15

Size/Duplication

Total Lines	102
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

90.74%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	getIdentifier()	0	4	1
A	getRevision()	0	4	1
A	getTrackedEvents()	0	4	1
A	markClean()	0	6	1
A	__construct()	0	6	1
A	reconstituteFromHistory()	0	10	2
A	reflectThat()	0	17	2
A	invokeEventHandler()	0	10	2
A	assertExpectedRevision()	0	10	2
A	assertExpectedIdentifier()	0	10	2

<?php
/**
 * This file is part of the daikon-cqrs/cqrs project.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace Daikon\EventSourcing\Aggregate;

trait AggregateRootTrait
{
    /** @var AggregateIdInterface */
    private $identifier;

    /** @var AggregateRevision */
    private $revision;

    /** @var DomainEventSequence */
    private $trackedEvents;

    public static function reconstituteFromHistory(
        AggregateIdInterface $aggregateId,
        DomainEventSequence $history
    ): AggregateRootInterface {
        $aggRoot = new static($aggregateId);
        foreach ($history as $eventOccured) {
            $aggRoot = $aggRoot->reflectThat($eventOccured, false);
        }
        return $aggRoot;
    }

    public function getIdentifier(): AggregateIdInterface
    {
        return $this->identifier;
    }

    public function getRevision(): AggregateRevision
    {
        return $this->revision;
    }

    public function getTrackedEvents(): DomainEventSequence
    {
        return $this->trackedEvents;
    }

    public function markClean(): AggregateRootInterface
    {
        $aggRoot = clone $this;
        $aggRoot->trackedEvents = DomainEventSequence::makeEmpty();
        return $aggRoot;
    }

    protected function __construct(AggregateIdInterface $aggregateId)
    {
        $this->identifier = $aggregateId;
        $this->revision = AggregateRevision::makeEmpty();
        $this->trackedEvents = DomainEventSequence::makeEmpty();
    }

    protected function reflectThat(DomainEventInterface $eventOccured, bool $track = true): self
    {
        $this->assertExpectedIdentifier($eventOccured, $this->getIdentifier());
        $aggRoot = clone $this;
        if ($track) {
            $aggRoot->revision = $aggRoot->revision->increment();
            $eventOccured = $eventOccured
                ->withAggregateRevision($aggRoot->revision);
            $aggRoot->trackedEvents = $aggRoot->trackedEvents->push($eventOccured);
        } else {
            $expectedAggregateRevision = $aggRoot->revision->increment();
            $this->assertExpectedRevision($eventOccured, $expectedAggregateRevision);
            $aggRoot->revision = $expectedAggregateRevision;
        }
        $aggRoot->invokeEventHandler($eventOccured);
        return $aggRoot;
    }

    private function invokeEventHandler(DomainEventInterface $event): void
    {
        $handlerName = preg_replace("/Event$/", "", (new \ReflectionClass($event))->getShortName());
        $handlerMethod = "when".ucfirst($handlerName);
        $handler = [ $this, $handlerMethod ];
        if (!is_callable($handler)) {
            throw new \Exception("Handler '$handlerMethod' isn't callable on ".static::class);
        }
        call_user_func($handler, $event);
    }

    private function assertExpectedRevision(DomainEventInterface $event, AggregateRevision $expectedRevision): void
    {
        if (!$expectedRevision->equals($event->getAggregateRevision())) {
            throw new \Exception(sprintf(
                "Given event-revision %s does not match expected AR revision at %s",
                $event->getAggregateRevision(),
                $expectedRevision
            ));
        }
    }

    private function assertExpectedIdentifier(DomainEventInterface $event, AggregateIdInterface $expectedId): void
    {
        if (!$expectedId->equals($event->getAggregateId())) {
            throw new \Exception(sprintf(
                "Given event-identifier %s does not match expected AR identifier at %s",
                $event->getAggregateId(),
                $expectedId
            ));
        }
    }
}