Spatie\EventProjector\Projectionist

Complexity

Total Complexity

32

Size/Duplication

Total Lines	227
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	9

Importance

Changes

0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	handle()	0	12	1
A	handleImmediately()	0	10	1
A	__construct()	0	8	1
A	addProjector()	0	14	3
A	addProjectors()	0	8	2
A	getProjectors()	0	4	1
A	getProjector()	0	6	1
A	addReactor()	0	6	1
A	addReactors()	0	8	2
A	getReactors()	0	4	1
A	storeEvent()	0	14	2
A	isProjecting()	0	4	1
A	applyStoredEventToProjectors()	0	26	5
A	applyStoredEventToReactors()	0	6	2
A	callEventHandler()	0	18	3
A	isReplaying()	0	4	1
A	replay()	0	31	2
A	getStoredEventClass()	0	4	1
A	getStoredEventJob()	0	4	1

<?php

namespace Spatie\EventProjector;

use Exception;
use Illuminate\Support\Collection;
use Spatie\EventProjector\Models\StoredEvent;
use Spatie\EventProjector\Projectors\Projector;
use Spatie\EventProjector\EventHandlers\EventHandler;
use Spatie\EventProjector\Events\FinishedEventReplay;
use Spatie\EventProjector\Events\StartingEventReplay;
use Spatie\EventProjector\Exceptions\InvalidEventHandler;
use Spatie\EventProjector\EventHandlers\EventHandlerCollection;
use Spatie\EventProjector\Events\EventHandlerFailedHandlingEvent;
use Spatie\EventProjector\Events\ProjectorDidNotHandlePriorEvents;

class Projectionist
{
    /** @var array */
    protected $config;

    /** @var \Spatie\EventProjector\EventHandlers\EventHandlerCollection */
    protected $projectors;

    /** @var \Spatie\EventProjector\EventHandlers\EventHandlerCollection */
    protected $reactors;

    /** @var bool */
    protected $isProjecting = false;

    /** @var bool */
    protected $isReplaying = false;

    public function __construct(array $config = [])
    {
        $this->projectors = new EventHandlerCollection();

        $this->reactors = new EventHandlerCollection();

        $this->config = $config;
    }

    public function addProjector($projector): Projectionist
    {
        if (is_string($projector)) {
            $projector = app($projector);
        }

        if (! $projector instanceof Projector) {
            throw InvalidEventHandler::notAProjector($projector);
        }

        $this->projectors->add($projector);

        return $this;
    }

    public function addProjectors(array $projectors): Projectionist
    {
        foreach ($projectors as $projector) {
            $this->addProjector($projector);
        }

        return $this;
    }

    public function getProjectors(): Collection
    {
        return $this->projectors->all();
    }

    public function getProjector(string $name): ?Projector
    {
        return $this->projectors->all()->first(function (Projector $projector) use ($name) {
            return $projector->getName() === $name;
        });
    }

    public function addReactor($reactor): Projectionist
    {
        $this->reactors->add($reactor);

        return $this;
    }

    public function addReactors(array $reactors): Projectionist
    {
        foreach ($reactors as $reactor) {
            $this->addReactor($reactor);
        }

        return $this;
    }

    public function getReactors(): Collection
    {
        return $this->reactors->all();
    }

    public function storeEvent(ShouldBeStored $event)
    {
        $storedEvent = $this->getStoredEventClass()::createForEvent($event);

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

        $this->handleImmediately($storedEvent);

        if (method_exists($event, 'tags')) {
            $tags = $event->tags();

The method tags() does not seem to exist on object<Spatie\EventProjector\ShouldBeStored>.

        }

        $storedEventJob = $this->getStoredEventJob()::createForEvent($storedEvent, $tags ?? []);

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

        dispatch($storedEventJob->onQueue($this->config['queue']));
    }

    public function handle(StoredEvent $storedEvent)
    {
        $this->applyStoredEventToProjectors(
            $storedEvent,
            $this->projectors->forEvent($storedEvent)
        );

        $this->applyStoredEventToReactors(
            $storedEvent,
            $this->reactors->forEvent($storedEvent)
        );
    }

    public function handleImmediately(StoredEvent $storedEvent)
    {
        $projectors = $this->projectors
            ->forEvent($storedEvent)
            ->filter(function (Projector $projector) {
                return $projector->shouldBeCalledImmediately();
            });

        $this->applyStoredEventToProjectors($storedEvent, $projectors);
    }

    public function isProjecting(): bool
    {
        return $this->isProjecting;
    }

    protected function applyStoredEventToProjectors(StoredEvent $storedEvent, Collection $projectors)
    {
        $this->isProjecting = true;

        foreach ($projectors as $projector) {
            if ($projector->hasAlreadyReceivedEvent($storedEvent)) {
                continue;
            }

            if (! $projector->hasReceivedAllPriorEvents($storedEvent)) {
                event(new ProjectorDidNotHandlePriorEvents($projector, $storedEvent));

                $projector->markAsNotUpToDate($storedEvent);

                continue;
            }

            if (! $this->callEventHandler($projector, $storedEvent)) {
                continue;
            }

            $projector->rememberReceivedEvent($storedEvent);
        }

        $this->isProjecting = false;
    }

    protected function applyStoredEventToReactors(StoredEvent $storedEvent, Collection $reactors)
    {
        foreach ($reactors as $reactor) {
            $this->callEventHandler($reactor, $storedEvent);
        }
    }

    protected function callEventHandler(EventHandler $eventHandler, StoredEvent $storedEvent): bool
    {
        try {
            $eventHandler->handle($storedEvent);
        } catch (Exception $exception) {
            if (! $this->config['catch_exceptions']) {
                throw $exception;
            }

            $eventHandler->handleException($exception);

            event(new EventHandlerFailedHandlingEvent($eventHandler, $storedEvent, $exception));

            return false;
        }

        return true;
    }

    public function isReplaying(): bool
    {
        return $this->isReplaying;
    }

    public function replay(Collection $projectors, int $afterStoredEventId = 0, callable $onEventReplayed = null)
    {
        $this->isReplaying = true;

        $projectors = new EventHandlerCollection($projectors);

$projectors is of type object<Illuminate\Support\Collection>, but the function expects a array.

        event(new StartingEventReplay($projectors->all()));

        $projectors->call('onStartingEventReplay');

        $this->getStoredEventClass()::query()

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

            ->after($afterStoredEventId ?? 0)
            ->chunk($this->config['replay_chunk_size'], function (Collection $storedEvents) use ($projectors, $onEventReplayed) {
                $storedEvents->each(function (StoredEvent $storedEvent) use ($projectors, $onEventReplayed) {
                    $this->applyStoredEventToProjectors(
                        $storedEvent,
                        $projectors->forEvent($storedEvent)
                    );

                    if ($onEventReplayed) {
                        $onEventReplayed($storedEvent);
                    }
                });
            });

        $this->isReplaying = false;

        event(new FinishedEventReplay());

        $projectors->call('onFinishedEventReplay');
    }

    protected function getStoredEventClass(): string
    {
        return config('event-projector.stored_event_model');
    }

    protected function getStoredEventJob(): string
    {
        return config('event-projector.stored_event_job');
    }
}