Blixit\EventSourcing\Store\InMemory\InMemoryEventPersister

Complexity

Total Complexity

16

Size/Duplication

Total Lines	62
Duplicated Lines	0 %

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	getLastEvent()	0	3	2
A	getByStream()	0	7	2
B	find()	0	26	11
A	persist()	0	5	1

<?php

declare(strict_types=1);

namespace Blixit\EventSourcing\Store\InMemory;

use Blixit\EventSourcing\Event\EventInterface;
use Blixit\EventSourcing\Store\Matcher\EventMatcherInterface;
use Blixit\EventSourcing\Store\Persistence\EventPersisterInterface;
use Blixit\EventSourcing\Stream\StreamName;
use function array_filter;
use function end;

class InMemoryEventPersister implements EventPersisterInterface
{
    /** @var EventInterface[] $events */
    private $events = [];

    /**
     * @return EventInterface[]
     */
    public function getByStream(StreamName $streamName, ?int $fromSequence = 0) : array
    {
        return array_filter($this->events, static function (EventInterface $event) use (
            $streamName,
            $fromSequence
        ) {
            return $event->getStreamName() === (string) $streamName && $event->getSequence() > $fromSequence;
        });
    }

    /**
     * Returns the last event stored into the stream
     */
    public function getLastEvent(StreamName $streamName) : ?EventInterface
    {
        return empty($this->events) ? null : end($this->events);
    }

    public function persist(EventInterface $event) : EventInterface
    {
        $this->events[] = $event;

        return $event;
    }

    /**
     * @return EventInterface[]
     */
    public function find(EventMatcherInterface $eventMatcher) : array
    {
        return array_filter($this->events, static function (EventInterface $event) use ($eventMatcher) {
            $aggregateId    = $eventMatcher->getAggregateId();
            $aggregateClass = $eventMatcher->getAggregateClass();
            $fromSequence   = $eventMatcher->getSequence();
            $streamName     = $eventMatcher->getStreamName();
            $timestamp      = $eventMatcher->getTimestamp();

            $condition = true;
            if (! empty($aggregateId)) {
                $condition = $condition && ($event->getAggregateId() === $aggregateId);
            }
            if (! empty($aggregateClass)) {
                $condition = $condition && ($event->getAggregateClass() === (string) $aggregateClass);
            }
            if (! empty($fromSequence)) {
                $condition = $condition && ($event->getSequence() > $fromSequence);
            }
            if (! empty($streamName)) {
                $condition = $condition && ($event->getStreamName() === (string) $streamName);
            }
            if (! empty($timestamp)) {
                $condition = $condition && ($event->getTimestamp() > $timestamp);
            }
            return $condition;
        });
    }
}