LIN3S\SharedKernel\Infrastructure\Persistence\Sql\Event\SqlEventStore

Complexity

Total Complexity

18

Size/Duplication

Total Lines	150
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	append()	0	21	4
A	streamOfName()	0	9	1
A	eventsSince()	0	18	2
A	buildStoredEvents()	0	18	2
A	buildDomainEvent()	0	21	3
A	unSerialize()	0	21	3
A	createSchema()	0	16	1
A	removeSchema()	0	6	1

<?php

/*
 * This file is part of the Shared Kernel library.
 *
 * Copyright (c) 2016-present LIN3S <info@lin3s.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace LIN3S\SharedKernel\Infrastructure\Persistence\Sql\Event;

use LIN3S\SharedKernel\Domain\Model\DomainEvent;
use LIN3S\SharedKernel\Event\EventStore;
use LIN3S\SharedKernel\Event\StoredEvent;
use LIN3S\SharedKernel\Event\Stream;
use LIN3S\SharedKernel\Event\StreamName;
use LIN3S\SharedKernel\Event\StreamVersion;
use LIN3S\SharedKernel\Infrastructure\Persistence\Sql\Pdo;

/**
 * @author Beñat Espiña <benatespina@gmail.com>
 */
final class SqlEventStore implements EventStore
{
    private const TABLE_NAME = 'events';
    private const COLUMN_NAMES = ['type', 'payload', 'occurred_on', 'stream_name', 'stream_version'];

    private $pdo;

    public function __construct(Pdo $pdo)
    {
        $this->pdo = $pdo;
    }

    public function append(Stream $stream) : void
    {
        $storedEvents = [];
        foreach ($stream->events() as $event) {
            $storedEvents[] = new StoredEvent($event, $stream->name(), $stream->version());
        }

        $numberOfEvents = count($storedEvents);
        if (0 === $numberOfEvents) {
            return;
        }

        $this->pdo->insert(self::TABLE_NAME, self::COLUMN_NAMES, $numberOfEvents, function () use ($storedEvents) {
            $data = [];
            foreach ($storedEvents as $event) {
                $data = array_merge($data, $event->toArray());
            }

            return $data;
        });
    }

    public function streamOfName(StreamName $name) : Stream
    {
        $tableName = self::TABLE_NAME;
        $sql = "SELECT * FROM `$tableName` WHERE stream_name = :streamName ORDER BY `order` ASC";
        $storedEventRows = $this->pdo->query($sql, ['streamName' => $name->name()]);
        $domainEventsCollection = $this->buildDomainEventsCollection($storedEventRows);

The method buildDomainEventsCollection() does not exist on LIN3S\SharedKernel\Infrastructure\Persistence\Sql\Event\SqlEventStore. Did you maybe mean buildDomainEvent()?

        return new Stream($name, $domainEventsCollection);

The call to Stream::__construct() misses a required argument $events.

    }

    public function eventsSince(?\DateTimeInterface $since, int $offset = 0, int $limit = -1) : array
    {
        $since = null === $since ? 0 : $since->getTimestamp();
        $tableName = self::TABLE_NAME;

        $sql = <<<SQL
SELECT * FROM `$tableName`
WHERE occurred_on >= :occurredOn
ORDER BY `order` ASC
LIMIT $limit
OFFSET $offset
SQL;

        $storedEventRows = $this->pdo->query($sql, ['occurredOn' => $since]);
        $storedEvents = $this->buildStoredEvents($storedEventRows);

        return $storedEvents;
    }

    private function buildStoredEvents(array $storedEventRows) : array
    {
        $events = [];
        foreach ($storedEventRows as $storedEventRow) {
            $storedEvent = new StoredEvent(
                $this->buildDomainEvent($storedEventRow),
                StreamName::fromName($storedEventRow['stream_name']),
                new StreamVersion((int) $storedEventRow['stream_version'])
            );
            $orderProperty = new \ReflectionProperty(StoredEvent::class, 'order');
            $orderProperty->setAccessible(true);
            $orderProperty->setValue($storedEvent, $storedEventRow['order']);

            $events[] = $storedEvent;
        }

        return $events;
    }

    private function buildDomainEvent(array $storedEventRow) : DomainEvent
    {
        $type = $storedEventRow['type'];
        $payload = json_decode($storedEventRow['payload'], true);

        $eventReflection = new \ReflectionClass($type);
        $domainEvent = $eventReflection->newInstanceWithoutConstructor();
        foreach ($eventReflection->getProperties() as $property) {
            $property->setAccessible(true);

            if ('occurredOn' === $property->getName()) {
                $occurredOn = new \DateTimeImmutable();
                $occurredOn->setTimestamp((int) $storedEventRow['occurred_on']);
                $property->setValue($domainEvent, $occurredOn);
                continue;
            }
            $this->unSerialize($property, $payload[$property->getName()], $domainEvent);
        }

        return $domainEvent;
    }

    private function unSerialize(\ReflectionProperty $reflectedProperty, $value, $object)
    {
        if (is_scalar($value)) {
            $reflectedProperty->setValue($object, $value);

            return $object;
        }

        $className = key($value);
        $reflectedClass = new \ReflectionClass($className);
        $class = $reflectedClass->newInstanceWithoutConstructor();
        $classValues = $value[$className];
        foreach ($reflectedClass->getProperties() as $property) {
            $property->setAccessible(true);
            $attribute = $this->unSerialize($property, $classValues[$property->getName()], $class);
            $reflectedProperty->setAccessible(true);
            $reflectedProperty->setValue($object, $attribute);
        }

        return $object;
    }

    public static function createSchema() : string
    {
        $tableName = self::TABLE_NAME;

        return <<<SQL
CREATE TABLE IF NOT EXISTS `$tableName` (
  `order` BIGINT(20) NOT NULL AUTO_INCREMENT,
  `type` VARCHAR(150) COLLATE utf8_bin NOT NULL,
  `payload` JSON NOT NULL,
  `occurred_on` INT(10) NOT NULL,
  `stream_name` VARCHAR(255) NOT NULL,
  `stream_version` INT NOT NULL,
  PRIMARY KEY (`order`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin;
SQL;
    }

    public static function removeSchema() : string
    {
        $tableName = self::TABLE_NAME;

        return "DROP TABLE `$tableName`";
    }
}