Spatie\EventProjector\AggregateRoot

Complexity

Total Complexity

10

Size/Duplication

Total Lines	83
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	retrieve()	0	8	1
A	recordThat()	0	8	1
A	persist()	0	10	1
A	getStoredEventModel()	0	4	1
A	getRecordedEvents()	0	4	1
A	getAndClearRecordedEvents()	0	8	1
A	reconstituteFromEvents()	0	8	1
A	apply()	0	12	2
A	fake()	0	4	1

<?php

namespace Spatie\EventProjector;

use Illuminate\Support\Str;
use Spatie\EventProjector\Models\StoredEvent;

abstract class AggregateRoot
{
    /** @var string */
    private $aggregateUuid;

    /** @var array */
    private $recordedEvents = [];

    public static function retrieve(string $uuid): AggregateRoot
    {
        $aggregateRoot = (new static());

        $aggregateRoot->aggregateUuid = $uuid;

        return $aggregateRoot->reconstituteFromEvents();
    }

    public function recordThat(ShouldBeStored $domainEvent): AggregateRoot
    {
        $this->recordedEvents[] = $domainEvent;

        $this->apply($domainEvent);

        return $this;
    }

    public function persist(): AggregateRoot
    {
        call_user_func(
            [$this->getStoredEventModel(), 'storeMany'],
            $this->getAndClearRecordedEvents(),
            $this->aggregateUuid
        );

        return $this;
    }

    protected function getStoredEventModel(): string
    {
        return $this->storedEventModel ?? config('event-projector.stored_event_model');

The property storedEventModel does not exist. Did you maybe forget to declare it?

    }

    public function getRecordedEvents(): array
    {
        return $this->recordedEvents;
    }

    private function getAndClearRecordedEvents(): array
    {
        $recordedEvents = $this->recordedEvents;

        $this->recordedEvents = [];

        return $recordedEvents;
    }

    private function reconstituteFromEvents(): AggregateRoot
    {
        $this->getStoredEventModel()::uuid($this->aggregateUuid)->each(function (StoredEvent $storedEvent) {

The method uuid cannot be called on $this->getStoredEventModel() (of type string).

            $this->apply($storedEvent->event);
        });

        return $this;
    }

    private function apply(ShouldBeStored $event): void
    {
        $classBaseName = class_basename($event);

        $camelCasedBaseName = ucfirst(Str::camel($classBaseName));

        $applyingMethodName = "apply{$camelCasedBaseName}";

        if (method_exists($this, $applyingMethodName)) {
            $this->$applyingMethodName($event);
        }
    }

    public static function fake(array $givenEvents = []): FakeAggregateRoot
    {
        return (new FakeAggregateRoot(app(static::class)))->given($givenEvents);
    }
}