C4tech\RayEmitter\Domain\Repository

Complexity

Total Complexity

7

Size/Duplication

Total Lines	73
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

100%

Importance

Changes	4
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	get()	0	6	1
B	handle()	0	30	4
	create()	0	1	?
A	find()	0	11	2

<?php namespace C4tech\RayEmitter\Domain;

use C4tech\RayEmitter\Contracts\Domain\Aggregate as AggregateInterface;
use C4tech\RayEmitter\Contracts\Domain\Command as CommandInterface;
use C4tech\RayEmitter\Contracts\Domain\Repository as RepositoryInterface;
use C4tech\RayEmitter\Facades\EventStore;
use C4tech\RayEmitter\Exceptions\OutdatedSequence;
use C4tech\RayEmitter\Exceptions\SequenceMismatch;

abstract class Repository implements RepositoryInterface
{
    /**
     * @inheritDoc
     */
    public static function get($identifier)
    {
        $aggregate = static::find($identifier);

        return $aggregate->getEntity();
    }

    /**
     * @inheritDoc
     */
    public static function handle(CommandInterface $command)
    {
        $aggregate = static::find($command->getAggregateId());

        // Optimistic concurrency handling
        $expected = $command->getExpectedSequence();
        $current = $aggregate->getSequence();
        if ($expected < $current) {
            throw new OutdatedSequence(
                sprintf(
                    'The Aggregate %s has newer data than expected.',
                    get_class($aggregate)
                ),
                409
            );
        } elseif ($expected > $current) {
            throw new SequenceMismatch(
                sprintf(
                    'The Aggregate %s is expected to have more data than it does',
                    get_class($aggregate)
                ),
                422
            );
        }

        if ($event = $aggregate->handle($command)) {
            $aggregate->apply($event);
            EventStore::enqueue($event);
        }
    }

    /**
     * Create
     *
     * Generate a new Aggregate with no history.
     * @return Aggregate
     */
    abstract protected static function create();

    /**
     * Find
     *
     * Restore an existing Aggregate from the recorded events related to it.
     * @param  void|string $identifier Aggregate root entity identifier.
     * @return Aggregate
     */
    protected static function find($identifier = null)
    {
        $aggregate = static::create();

        if ($identifier) {

The expression $identifier of type null|string is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

            $events = EventStore::getFor($identifier);
            $aggregate->hydrate($events);
        }

        return $aggregate;
    }
}