Daikon\EventSourcing\EventStore\Stream\Stream

Complexity

Total Complexity

19

Size/Duplication

Total Lines	122
Duplicated Lines	0 %

Test Coverage

Coverage

0%

Importance

Changes	2
Bugs	0	Features	1

15 Methods

Rating	Name	Duplication	Size	Complexity
A	getHead()	0	3	1
A	getHeadSequence()	0	6	2
A	fromAggregateId()	0	5	1
A	findCommitsSince()	0	10	3
A	getIterator()	0	3	1
A	__construct()	0	8	1
A	getCommitRange()	0	3	1
A	getHeadRevision()	0	6	2
A	fromNative()	0	9	1
A	getAggregateId()	0	3	1
A	appendEvents()	0	8	1
A	isEmpty()	0	3	1
A	appendCommit()	0	5	1
A	toNative()	0	6	1
A	count()	0	3	1

<?php declare(strict_types=1);
/**
 * This file is part of the daikon-cqrs/event-sourcing project.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Daikon\EventSourcing\EventStore\Stream;

use Daikon\EventSourcing\Aggregate\AggregateId;
use Daikon\EventSourcing\Aggregate\AggregateIdInterface;
use Daikon\EventSourcing\Aggregate\AggregateRevision;
use Daikon\EventSourcing\Aggregate\Event\DomainEventSequenceInterface;
use Daikon\EventSourcing\EventStore\Commit\Commit;
use Daikon\EventSourcing\EventStore\Commit\CommitInterface;
use Daikon\EventSourcing\EventStore\Commit\CommitSequence;
use Daikon\EventSourcing\EventStore\Commit\CommitSequenceInterface;
use Daikon\Interop\Assertion;
use Daikon\Metadata\MetadataInterface;
use Ds\Vector;

final class Stream implements StreamInterface
{
    private AggregateIdInterface $aggregateId;

    private CommitSequenceInterface $commitSequence;

    private string $commitImplementor;

    public static function fromAggregateId(
        AggregateIdInterface $aggregateId,
        string $commitImplementor = Commit::class
    ): self {
        return new self($aggregateId);
    }

    /** @param array $state */
    public static function fromNative($state): self
    {
        Assertion::keyExists($state, 'aggregateId');
        Assertion::keyExists($state, 'commitSequence');

        return new self(
            AggregateId::fromNative($state['aggregateId']),
            CommitSequence::fromNative($state['commitSequence']),
            $state['commitImplementor'] ?? null
        );
    }

    public function getAggregateId(): AggregateIdInterface
    {
        return $this->aggregateId;
    }

    public function getHeadSequence(): Sequence
    {
        if ($this->isEmpty()) {
            return Sequence::makeInitial();
        }
        return $this->getHead()->getSequence();
    }

    public function getHeadRevision(): AggregateRevision
    {
        if ($this->isEmpty()) {
            return AggregateRevision::makeEmpty();
        }
        return $this->getHead()->getHeadRevision();
    }

    public function appendEvents(DomainEventSequenceInterface $eventLog, MetadataInterface $metadata): self
    {
        return $this->appendCommit(
            ([$this->commitImplementor, 'make'])(
                $this->aggregateId,
                $this->getHeadSequence()->increment(),
                $eventLog,
                $metadata
            )
        );
    }

    public function appendCommit(CommitInterface $commit): self
    {
        $stream = clone $this;
        $stream->commitSequence = $this->commitSequence->push($commit);
        return $stream;
    }

    public function getHead(): CommitInterface
    {
        return $this->commitSequence->getHead();
    }

    public function getCommitRange(Sequence $fromRev, Sequence $toRev = null): CommitSequenceInterface
    {
        return $this->commitSequence->getSlice($fromRev, $toRev ?? $this->getHeadSequence());
    }

    public function count(): int
    {
        return $this->commitSequence->count();
    }

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

    public function toNative(): array
    {
        return [
            'commitSequence' => $this->commitSequence->toNative(),
            'aggregateId' => $this->aggregateId->toNative(),
            'commitImplementor' => $this->commitImplementor
        ];
    }

    public function getIterator(): Vector
    {
        return $this->commitSequence->getIterator();

The expression return $this->commitSequence->getIterator() returns the type Traversable which includes types incompatible with the type-hinted return Ds\Vector.

    }

    public function findCommitsSince(AggregateRevision $incomingRevision): CommitSequenceInterface
    {
        $previousCommits = [];
        /** @var CommitInterface $commit */
        foreach ($this as $commit) {
            if ($commit->getTailRevision()->isGreaterThanOrEqual($incomingRevision)) {
                $previousCommits[] = clone $commit;
            }
        }
        return new CommitSequence($previousCommits);
    }

    private function __construct(
        AggregateIdInterface $aggregateId,
        CommitSequenceInterface $commitSequence = null,
        string $commitImplementor = null
    ) {
        $this->aggregateId = $aggregateId;
        $this->commitSequence = $commitSequence ?? CommitSequence::makeEmpty();
        $this->commitImplementor = $commitImplementor ?? Commit::class;
    }
}