Update asserts and deps

daikon-cqrs · Jun 11, 2020 · f4c7d5c · f4c7d5c
1 parent 977f82b
commit f4c7d5c
Show file tree

Hide file tree

Showing 22 changed files with 496 additions and 144 deletions.
diff --git a/composer.json b/composer.json
@@ -9,7 +9,6 @@
     "minimum-stability": "dev",
     "require": {
         "php": "^7.4",
-        "beberlei/assert": "^3.0",
         "daikon/interop": "master@dev",
         "daikon/message-bus": "master@dev",
         "daikon/metadata": "master@dev",

diff --git a/composer.lock b/composer.lock
diff --git a/psalm.xml b/psalm.xml
@@ -39,6 +39,7 @@
         <MissingConstructor errorLevel="info" />
         <MissingClosureParamType errorLevel="info" />
         <MissingParamType errorLevel="info" />
+        <MixedClone errorLevel="suppress" />
 
         <RedundantCondition errorLevel="info" />
 

diff --git a/src/Aggregate/AggregateIdInterface.php b/src/Aggregate/AggregateIdInterface.php
@@ -12,5 +12,4 @@
 
 interface AggregateIdInterface extends ValueObjectInterface
 {
-    public function __toString(): string;
 }
diff --git a/src/Aggregate/AggregateIdTrait.php b/src/Aggregate/AggregateIdTrait.php
@@ -8,7 +8,7 @@
 
 namespace Daikon\EventSourcing\Aggregate;
 
-use Assert\Assertion;
+use Daikon\Interop\Assertion;
 
 trait AggregateIdTrait
 {
@@ -17,7 +17,9 @@ trait AggregateIdTrait
     /** @param string $id */
     public static function fromNative($id): self
     {
-        Assertion::regex($id, static::PATTERN);
+        if (defined('static::PATTERN')) {
+            Assertion::regex($id, static::PATTERN);
+        }
         return new static($id);
     }
 
@@ -26,7 +28,7 @@ public function toNative(): string
         return $this->id;
     }
 
-    /** @param self $comparator */
+    /** @param static $comparator */
     public function equals($comparator): bool
     {
         Assertion::isInstanceOf($comparator, static::class);

diff --git a/src/Aggregate/AggregateRevision.php b/src/Aggregate/AggregateRevision.php
@@ -9,9 +9,10 @@
 namespace Daikon\EventSourcing\Aggregate;
 
 use Assert\Assertion;
+use Daikon\Interop\MakeEmptyInterface;
 use Daikon\ValueObject\ValueObjectInterface;
 
-final class AggregateRevision implements ValueObjectInterface
+final class AggregateRevision implements MakeEmptyInterface, ValueObjectInterface
 {
     private const INITIAL = 1;
 

diff --git a/src/Aggregate/AggregateRootTrait.php b/src/Aggregate/AggregateRootTrait.php
@@ -8,10 +8,10 @@
 
 namespace Daikon\EventSourcing\Aggregate;
 
-use Assert\Assertion;
 use Daikon\EventSourcing\Aggregate\Event\DomainEventInterface;
 use Daikon\EventSourcing\Aggregate\Event\DomainEventSequence;
 use Daikon\EventSourcing\Aggregate\Event\DomainEventSequenceInterface;
+use Daikon\Interop\Assertion;
 use Daikon\Interop\RuntimeException;
 use ReflectionClass;
 
@@ -81,7 +81,7 @@ private function reconstitute(DomainEventInterface $historicalEvent): self
     private function assertExpectedRevision(DomainEventInterface $event, AggregateRevision $expectedRevision): void
     {
         Assertion::true($expectedRevision->equals($event->getAggregateRevision()), sprintf(
-            'Given event revision %s does not match expected AR revision at %s',
+            'Given event revision %s does not match expected AR revision at %s.',
             (string)$event->getAggregateRevision(),
             (string)$expectedRevision
         ));
@@ -90,7 +90,7 @@ private function assertExpectedRevision(DomainEventInterface $event, AggregateRe
     private function assertExpectedIdentifier(DomainEventInterface $event, AggregateIdInterface $expectedId): void
     {
         Assertion::true($expectedId->equals($event->getAggregateId()), sprintf(
-            'Given event identifier %s does not match expected AR identifier at %s',
+            'Given event identifier %s does not match expected AR identifier at %s.',
             (string)$event->getAggregateId(),
             (string)$expectedId
         ));
@@ -100,10 +100,12 @@ private function invokeEventHandler(DomainEventInterface $event): void
     {
         $handlerName = preg_replace('/Event$/', '', (new ReflectionClass($event))->getShortName());
         $handlerMethod = 'when'.ucfirst($handlerName);
-        $handler = [ $this, $handlerMethod ];
+        $handler = [$this, $handlerMethod];
         if (!is_callable($handler)) {
-            throw new RuntimeException(sprintf('Handler "%s" is not callable on '.static::class, $handlerMethod));
+            throw new RuntimeException(
+                sprintf("Handler '%s' is not callable on '%s'.", $handlerMethod, static::class)
+            );
         }
-        call_user_func($handler, $event);
+        $handler($event);
     }
 }
diff --git a/src/Aggregate/AnnotatesAggregate.php b/src/Aggregate/AnnotatesAggregate.php
@@ -8,7 +8,7 @@
 
 namespace Daikon\EventSourcing\Aggregate;
 
-use Daikon\Interop\RuntimeException;
+use Daikon\Interop\InvalidArgumentException;
 use ReflectionClass;
 
 trait AnnotatesAggregate
@@ -41,6 +41,6 @@ private static function getAnnotation(string $key): string
             }
         }
 
-        throw new RuntimeException("Missing @$key annotation on ".static::class);
+        throw new InvalidArgumentException(sprintf("Missing @%s annotation on '%s'.", $key, static::class));
     }
 }
diff --git a/src/Aggregate/Command/CommandHandler.php b/src/Aggregate/Command/CommandHandler.php
@@ -40,9 +40,11 @@ public function handle(EnvelopeInterface $envelope): void
         $handlerMethod = 'handle'.ucfirst($handlerName);
         $handler = [$this, $handlerMethod];
         if (!is_callable($handler)) {
-            throw new RuntimeException(sprintf('Handler "%s" is not callable on '.static::class, $handlerMethod));
+            throw new RuntimeException(
+                sprintf("Handler '%s' is not callable on '%s'.", $handlerMethod, static::class)
+            );
         }
-        $this->commit(...call_user_func($handler, $commandMessage, $envelope->getMetadata()));
+        $this->commit(...$handler($commandMessage, $envelope->getMetadata()));
     }
 
     protected function commit(AggregateRootInterface $aggregateRoot, MetadataInterface $metadata): void

diff --git a/src/Aggregate/Event/DomainEventSequence.php b/src/Aggregate/Event/DomainEventSequence.php
@@ -9,9 +9,9 @@
 namespace Daikon\EventSourcing\Aggregate\Event;
 
 use Daikon\EventSourcing\Aggregate\AggregateRevision;
+use Daikon\Interop\Assertion;
 use Daikon\Interop\RuntimeException;
 use Ds\Vector;
-use InvalidArgumentException;
 
 final class DomainEventSequence implements DomainEventSequenceInterface
 {
@@ -20,10 +20,10 @@ final class DomainEventSequence implements DomainEventSequenceInterface
     /** @param array $events */
     public static function fromNative($events): self
     {
-        return new self(array_map(function (array $state): DomainEventInterface {
-            $eventFqcn = self::resolveEventFqcn($state);
-            return call_user_func([$eventFqcn, 'fromNative'], $state);
-        }, $events));
+        return new self(array_map(
+            fn(array $state): DomainEventInterface => ([self::resolveEventFqcn($state), 'fromNative'])($state),
+            $events
+        ));
     }
 
     public static function makeEmpty(): self
@@ -43,7 +43,7 @@ public function push(DomainEventInterface $event): self
         $expectedRevision = $this->getHeadRevision()->increment();
         if (!$this->isEmpty() && !$expectedRevision->equals($event->getAggregateRevision())) {
             throw new RuntimeException(sprintf(
-                'Trying to add invalid revision %s to event-sequence, expected revision is %s',
+                'Trying to add invalid revision %s to event-sequence, expected revision is %s.',
                 (string)$event->getAggregateRevision(),
                 (string)$expectedRevision
             ));
@@ -131,13 +131,9 @@ public function getIterator(): Vector
 
     private static function resolveEventFqcn(array $eventState): string
     {
-        if (!isset($eventState['@type'])) {
-            throw new InvalidArgumentException("Missing expected key '@type' within given state array.");
-        }
+        Assertion::keyIsset($eventState, '@type', "Missing expected key '@type' within given state array.");
         $eventFqcn = $eventState['@type'];
-        if (!class_exists($eventFqcn)) {
-            throw new InvalidArgumentException("Cannot find event class '$eventFqcn' given within state array.");
-        }
+        Assertion::classExists($eventFqcn, "Cannot find event class '$eventFqcn' given within state array.");
         return $eventFqcn;
     }
 

diff --git a/src/Aggregate/Event/DomainEventSequenceInterface.php b/src/Aggregate/Event/DomainEventSequenceInterface.php
@@ -11,13 +11,17 @@
 use Countable;
 use Daikon\EventSourcing\Aggregate\AggregateRevision;
 use Daikon\Interop\FromNativeInterface;
+use Daikon\Interop\MakeEmptyInterface;
 use Daikon\Interop\ToNativeInterface;
 use IteratorAggregate;
 
-interface DomainEventSequenceInterface extends IteratorAggregate, Countable, FromNativeInterface, ToNativeInterface
+interface DomainEventSequenceInterface extends
+    IteratorAggregate,
+    Countable,
+    MakeEmptyInterface,
+    FromNativeInterface,
+    ToNativeInterface
 {
-    public static function makeEmpty(): self;
-
     public function push(DomainEventInterface $event): self;
 
     public function append(DomainEventSequenceInterface $events): self;
@@ -32,8 +36,6 @@ public function getTail(): DomainEventInterface;
 
     public function getHead(): DomainEventInterface;
 
-    public function isEmpty(): bool;
-
     /** @return int|bool */
     public function indexOf(DomainEventInterface $event);
 }
diff --git a/src/Aggregate/Event/DomainEventTrait.php b/src/Aggregate/Event/DomainEventTrait.php
@@ -20,6 +20,7 @@ public function getAggregateRevision(): AggregateRevision
         return $this->{static::getAnnotatedRevision()};
     }
 
+    /** @return static */
     public function withAggregateRevision(AggregateRevision $aggregateRevision): self
     {
         $copy = clone $this;

diff --git a/src/EventStore/Commit/Commit.php b/src/EventStore/Commit/Commit.php
@@ -10,13 +10,13 @@
 
 namespace Daikon\EventSourcing\EventStore\Commit;
 
-use Assert\Assertion;
 use Daikon\EventSourcing\Aggregate\AggregateId;
 use Daikon\EventSourcing\Aggregate\AggregateIdInterface;
 use Daikon\EventSourcing\Aggregate\AggregateRevision;
 use Daikon\EventSourcing\Aggregate\Event\DomainEventSequence;
 use Daikon\EventSourcing\Aggregate\Event\DomainEventSequenceInterface;
 use Daikon\EventSourcing\EventStore\Stream\Sequence;
+use Daikon\Interop\Assertion;
 use Daikon\Metadata\Metadata;
 use Daikon\Metadata\MetadataInterface;
 use DateTimeImmutable;

diff --git a/src/EventStore/Commit/CommitSequence.php b/src/EventStore/Commit/CommitSequence.php
@@ -43,7 +43,7 @@ public function push(CommitInterface $commit): self
             $nextRevision = $this->getHead()->getHeadRevision()->increment();
             if (!$nextRevision->equals($commit->getTailRevision())) {
                 throw new RuntimeException(sprintf(
-                    'Trying to add invalid revision %s to event-sequence, expected revision is %s',
+                    'Trying to add invalid revision %s to event-sequence, expected revision is %s.',
                     (string)$commit->getHeadRevision(),
                     (string)$nextRevision
                 ));
@@ -78,8 +78,7 @@ public function getHead(): CommitInterface
     public function has(Sequence $sequence): bool
     {
         $offset = $sequence->toNative() - 1;
-        /** @psalm-suppress UndefinedMethod */
-        return isset($this->compositeVector[$offset]);
+        return isset($this->compositeVector->{$offset});
     }
 
     public function get(Sequence $sequence): CommitInterface

diff --git a/src/EventStore/Commit/CommitSequenceInterface.php b/src/EventStore/Commit/CommitSequenceInterface.php
@@ -11,13 +11,17 @@
 use Countable;
 use Daikon\EventSourcing\EventStore\Stream\Sequence;
 use Daikon\Interop\FromNativeInterface;
+use Daikon\Interop\MakeEmptyInterface;
 use Daikon\Interop\ToNativeInterface;
 use IteratorAggregate;
 
-interface CommitSequenceInterface extends IteratorAggregate, Countable, FromNativeInterface, ToNativeInterface
+interface CommitSequenceInterface extends
+    IteratorAggregate,
+    Countable,
+    MakeEmptyInterface,
+    FromNativeInterface,
+    ToNativeInterface
 {
-    public static function makeEmpty(): self;
-
     public function push(CommitInterface $commit): self;
 
     public function getTail(): CommitInterface;
@@ -30,7 +34,5 @@ public function has(Sequence $Sequence): bool;
 
     public function getSlice(Sequence $start, Sequence $end): self;
 
-    public function isEmpty(): bool;
-
     public function revisionOf(CommitInterface $commit): Sequence;
 }
diff --git a/src/EventStore/ConcurrencyRaceLost.php b/src/EventStore/ConcurrencyRaceLost.php
@@ -10,9 +10,9 @@
 
 use Daikon\EventSourcing\Aggregate\Event\DomainEventSequenceInterface;
 use Daikon\EventSourcing\Aggregate\AggregateIdInterface;
-use Exception;
+use Daikon\Interop\RuntimeException;
 
-final class ConcurrencyRaceLost extends Exception
+final class ConcurrencyRaceLost extends RuntimeException
 {
     private AggregateIdInterface $aggregateId;
 
@@ -22,7 +22,7 @@ public function __construct(AggregateIdInterface $aggregateId, DomainEventSequen
     {
         $this->aggregateId = $aggregateId;
         $this->lostEvents = $lostEvents;
-        parent::__construct('Unable to catchup on stream: ' . $this->aggregateId);
+        parent::__construct('Unable to catchup on stream '.$this->aggregateId);
     }
 
     public function getAggregateId(): AggregateIdInterface

diff --git a/src/EventStore/Storage/StreamStorageMap.php b/src/EventStore/Storage/StreamStorageMap.php
@@ -8,13 +8,10 @@
 
 namespace Daikon\EventSourcing\EventStore\Storage;
 
-use Daikon\DataStructure\TypedMapInterface;
-use Daikon\DataStructure\TypedMapTrait;
+use Daikon\DataStructure\TypedMap;
 
-final class StreamStorageMap implements TypedMapInterface
+final class StreamStorageMap extends TypedMap
 {
-    use TypedMapTrait;
-
     public function __construct(iterable $streamStores = [])
     {
         $this->init($streamStores, [StreamStorageInterface::class]);

diff --git a/src/EventStore/Stream/Stream.php b/src/EventStore/Stream/Stream.php
@@ -8,7 +8,6 @@
 
 namespace Daikon\EventSourcing\EventStore\Stream;
 
-use Assert\Assertion;
 use Daikon\EventSourcing\Aggregate\AggregateId;
 use Daikon\EventSourcing\Aggregate\AggregateIdInterface;
 use Daikon\EventSourcing\Aggregate\AggregateRevision;
@@ -17,6 +16,7 @@
 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;
 
@@ -72,8 +72,7 @@ public function getHeadRevision(): AggregateRevision
     public function appendEvents(DomainEventSequenceInterface $eventLog, MetadataInterface $metadata): self
     {
         return $this->appendCommit(
-            call_user_func(
-                [$this->commitImplementor, 'make'],
+            ([$this->commitImplementor, 'make'])(
                 $this->aggregateId,
                 $this->getHeadSequence()->increment(),
                 $eventLog,

diff --git a/src/EventStore/Stream/StreamMap.php b/src/EventStore/Stream/StreamMap.php
@@ -8,15 +8,13 @@
 
 namespace Daikon\EventSourcing\EventStore\Stream;
 
-use Daikon\DataStructure\TypedMapInterface;
-use Daikon\DataStructure\TypedMapTrait;
+use Daikon\DataStructure\TypedMap;
 use Daikon\EventSourcing\Aggregate\AggregateIdInterface;
+use Daikon\Interop\MakeEmptyInterface;
 use Daikon\Interop\ToNativeInterface;
 
-final class StreamMap implements TypedMapInterface, ToNativeInterface
+final class StreamMap extends TypedMap implements MakeEmptyInterface, ToNativeInterface
 {
-    use TypedMapTrait;
-
     public function __construct(iterable $streams = [])
     {
         $this->init($streams, [StreamInterface::class]);