C4tech\RayEmitter\Domain\Repository

Complexity

Total Complexity

7

Size/Duplication

Total Lines	71
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

100%

Importance

Changes	3
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	find()	0	7	1
A	getEntity()	0	6	1
B	handle()	0	30	4
A	restore()	0	5	1

<?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 find($identifier)
    {
        $aggregate = static::create();
        static::restore($identifier, $aggregate);

        return $aggregate;
    }

    /**
     * @inheritDoc
     */
    public static function getEntity($identifier)
    {
        $aggregate = static::find($identifier);

        return $aggregate->getEntity();
    }

    /**
     * @inheritDoc
     */
    public static function handle(CommandInterface $command)
    {
        $aggregate = static::create();
        if ($aggregate_id = $command->getAggregateId()) {
            static::restore($aggregate_id, $aggregate);
        }

        // 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
            );
        }

        $aggregate->handle($command);
    }

    /**
     * Restore
     *
     * Hydrate an aggregate with its recorded events.
     * @param  string             $identifier Aggregate root entity identifier.
     * @param  AggregateInterface &$aggregate (Fresh) Aggregate to hydrate.
     * @return void
     */
    protected static function restore($identifier, AggregateInterface &$aggregate)
    {
        $events = EventStore::getFor($identifier);
        $aggregate->hydrate($events);
    }
}