├── Dockerfile
├── LICENSE
├── Makefile
├── README.md
├── UPGRADE-2.0.md
├── UPGRADE-3.0.md
├── baseline.xml
├── composer.json
├── deptrac-baseline.yaml
├── deptrac.yaml
├── docker-compose.yaml
├── infection.json.dist
├── phpstan-baseline.neon
├── phpstan.neon.dist
├── psalm_docs.xml
├── renovate.json
└── src
    ├── Aggregate
        ├── AggregateException.php
        ├── AggregateHeader.php
        ├── AggregateRoot.php
        ├── AggregateRootAttributeBehaviour.php
        ├── AggregateRootBehaviour.php
        ├── AggregateRootId.php
        ├── AggregateRootIdNotSupported.php
        ├── AggregateRootMetadataAware.php
        ├── AggregateRootMetadataAwareBehaviour.php
        ├── ApplyMethodNotFound.php
        ├── BasicAggregateRoot.php
        ├── BasicChildAggregate.php
        ├── ChildAggregate.php
        ├── ChildAggregateBehaviour.php
        ├── CustomId.php
        ├── CustomIdBehaviour.php
        ├── InvalidAggregateStreamName.php
        ├── MetadataNotPossible.php
        ├── RamseyUuidV7Behaviour.php
        └── Uuid.php
    ├── Attribute
        ├── Aggregate.php
        ├── Answer.php
        ├── Apply.php
        ├── ChildAggregate.php
        ├── Event.php
        ├── Handle.php
        ├── Header.php
        ├── Id.php
        ├── Inject.php
        ├── OnFailed.php
        ├── Processor.php
        ├── Projector.php
        ├── RetryAggregateOutdated.php
        ├── RetryStrategy.php
        ├── Setup.php
        ├── Snapshot.php
        ├── SplitStream.php
        ├── Stream.php
        ├── Subscribe.php
        ├── Subscriber.php
        ├── SuppressMissingApply.php
        └── Teardown.php
    ├── Clock
        ├── FrozenClock.php
        └── SystemClock.php
    ├── CommandBus
        ├── AggregateHandlerProvider.php
        ├── ChainHandlerProvider.php
        ├── CommandBus.php
        ├── Handler
        │   ├── AggregateIdNotFound.php
        │   ├── CreateAggregateHandler.php
        │   ├── DefaultParameterResolver.php
        │   ├── ParameterResolver.php
        │   ├── ServiceNotResolvable.php
        │   └── UpdateAggregateHandler.php
        ├── HandlerDescriptor.php
        ├── HandlerFinder.php
        ├── HandlerNotFound.php
        ├── HandlerProvider.php
        ├── HandlerReference.php
        ├── InvalidHandleMethod.php
        ├── MultipleHandlersFound.php
        ├── RetryOutdatedAggregateCommandBus.php
        ├── ServiceHandlerProvider.php
        ├── ServiceLocator.php
        ├── ServiceNotFound.php
        └── SyncCommandBus.php
    ├── Console
        ├── Command
        │   ├── DatabaseCreateCommand.php
        │   ├── DatabaseDropCommand.php
        │   ├── DebugCommand.php
        │   ├── SchemaCreateCommand.php
        │   ├── SchemaDropCommand.php
        │   ├── SchemaUpdateCommand.php
        │   ├── ShowAggregateCommand.php
        │   ├── ShowCommand.php
        │   ├── SubscriptionBootCommand.php
        │   ├── SubscriptionCommand.php
        │   ├── SubscriptionPauseCommand.php
        │   ├── SubscriptionReactivateCommand.php
        │   ├── SubscriptionRemoveCommand.php
        │   ├── SubscriptionRunCommand.php
        │   ├── SubscriptionSetupCommand.php
        │   ├── SubscriptionStatusCommand.php
        │   ├── SubscriptionTeardownCommand.php
        │   └── WatchCommand.php
        ├── DoctrineHelper.php
        ├── InputHelper.php
        ├── InvalidArgumentGiven.php
        └── OutputStyle.php
    ├── Cryptography
        └── DoctrineCipherKeyStore.php
    ├── EventBus
        ├── AttributeListenerProvider.php
        ├── Consumer.php
        ├── DefaultConsumer.php
        ├── DefaultEventBus.php
        ├── EventBus.php
        ├── ListenerDescriptor.php
        ├── ListenerProvider.php
        └── Psr14EventBus.php
    ├── Message
        ├── HeaderNotFound.php
        ├── Message.php
        ├── Pipe.php
        ├── Reducer.php
        ├── Serializer
        │   ├── DefaultHeadersSerializer.php
        │   ├── HeadersSerializer.php
        │   └── InvalidArgument.php
        └── Translator
        │   ├── AggregateToStreamHeaderTranslator.php
        │   ├── ChainTranslator.php
        │   ├── ClosureMiddleware.php
        │   ├── ExcludeEventTranslator.php
        │   ├── ExcludeEventWithHeaderTranslator.php
        │   ├── FilterEventTranslator.php
        │   ├── IncludeEventTranslator.php
        │   ├── IncludeEventWithHeaderTranslator.php
        │   ├── RecalculatePlayheadTranslator.php
        │   ├── ReplaceEventTranslator.php
        │   ├── Translator.php
        │   └── UntilEventTranslator.php
    ├── Metadata
        ├── AggregateRoot
        │   ├── AggregateRootAlreadyInRegistry.php
        │   ├── AggregateRootClassNotRegistered.php
        │   ├── AggregateRootIdNotFound.php
        │   ├── AggregateRootMetadata.php
        │   ├── AggregateRootMetadataAwareMetadataFactory.php
        │   ├── AggregateRootMetadataFactory.php
        │   ├── AggregateRootNameNotRegistered.php
        │   ├── AggregateRootRegistry.php
        │   ├── AggregateRootRegistryFactory.php
        │   ├── AggregateWithoutMetadataAware.php
        │   ├── ArgumentTypeIsMissing.php
        │   ├── ArgumentTypeIsNotAClass.php
        │   ├── AttributeAggregateRootMetadataFactory.php
        │   ├── AttributeAggregateRootRegistryFactory.php
        │   ├── ClassIsNotAnAggregate.php
        │   ├── DuplicateApplyMethod.php
        │   ├── DuplicateEmptyApplyAttribute.php
        │   ├── MissingAggregateIdForStreamName.php
        │   ├── MissingDataSubjectId.php
        │   ├── MixedApplyAttributeUsage.php
        │   ├── MultipleDataSubjectId.php
        │   ├── NoAggregateRoot.php
        │   ├── Psr16AggregateRootMetadataFactory.php
        │   ├── Psr16AggregateRootRegistryFactory.php
        │   ├── Psr6AggregateRootMetadataFactory.php
        │   ├── Psr6AggregateRootRegistryFactory.php
        │   ├── Snapshot.php
        │   └── SubjectIdAndPersonalDataConflict.php
        ├── ClassFinder.php
        ├── Event
        │   ├── AttributeEventMetadataFactory.php
        │   ├── AttributeEventRegistryFactory.php
        │   ├── ClassIsNotAnEvent.php
        │   ├── EventAlreadyInRegistry.php
        │   ├── EventClassNotRegistered.php
        │   ├── EventMetadata.php
        │   ├── EventMetadataFactory.php
        │   ├── EventNameNotRegistered.php
        │   ├── EventRegistry.php
        │   ├── EventRegistryFactory.php
        │   ├── MissingDataSubjectId.php
        │   ├── MultipleDataSubjectId.php
        │   ├── Psr16EventMetadataFactory.php
        │   ├── Psr16EventRegistryFactory.php
        │   ├── Psr6EventMetadataFactory.php
        │   ├── Psr6EventRegistryFactory.php
        │   └── SubjectIdAndPersonalDataConflict.php
        ├── Message
        │   ├── AttributeMessageHeaderRegistryFactory.php
        │   ├── HeaderClassNotRegistered.php
        │   ├── HeaderNameNotRegistered.php
        │   ├── MessageHeaderRegistry.php
        │   └── MessageHeaderRegistryFactory.php
        ├── MetadataException.php
        └── Subscriber
        │   ├── ArgumentMetadata.php
        │   ├── ArgumentTypeNotSupported.php
        │   ├── AttributeSubscriberMetadataFactory.php
        │   ├── ClassIsNotASubscriber.php
        │   ├── DuplicateFailedMethod.php
        │   ├── DuplicateSetupMethod.php
        │   ├── DuplicateSubscribeMethod.php
        │   ├── DuplicateTeardownMethod.php
        │   ├── Psr16SubscriberMetadataFactory.php
        │   ├── Psr6SubscriberMetadataFactory.php
        │   ├── SubscribeMethodMetadata.php
        │   ├── SubscriberMetadata.php
        │   └── SubscriberMetadataFactory.php
    ├── QueryBus
        ├── ChainHandlerProvider.php
        ├── HandlerDescriptor.php
        ├── HandlerFinder.php
        ├── HandlerProvider.php
        ├── HandlerReference.php
        ├── InvalidHandleMethod.php
        ├── InvalidQueryHandler.php
        ├── QueryBus.php
        ├── ServiceHandlerProvider.php
        └── SyncQueryBus.php
    ├── Repository
        ├── AggregateAlreadyExists.php
        ├── AggregateDetached.php
        ├── AggregateNotFound.php
        ├── AggregateOutdated.php
        ├── AggregateUnknown.php
        ├── DefaultRepository.php
        ├── DefaultRepositoryManager.php
        ├── MessageDecorator
        │   ├── ChainMessageDecorator.php
        │   ├── MessageDecorator.php
        │   └── SplitStreamDecorator.php
        ├── PlayheadMismatch.php
        ├── Repository.php
        ├── RepositoryException.php
        ├── RepositoryManager.php
        ├── SnapshotRebuildFailed.php
        └── WrongAggregate.php
    ├── Schema
        ├── ChainDoctrineSchemaConfigurator.php
        ├── DoctrineMigrationSchemaProvider.php
        ├── DoctrineSchemaConfigurator.php
        ├── DoctrineSchemaDirector.php
        ├── DoctrineSchemaListener.php
        ├── DoctrineSchemaProvider.php
        ├── DoctrineSchemaSubscriber.php
        ├── DryRunSchemaDirector.php
        └── SchemaDirector.php
    ├── Serializer
        ├── DefaultEventSerializer.php
        ├── Encoder
        │   ├── DecodeNotPossible.php
        │   ├── EncodeNotPossible.php
        │   ├── Encoder.php
        │   └── JsonEncoder.php
        ├── EventSerializer.php
        ├── Normalizer
        │   └── IdNormalizer.php
        ├── SerializeException.php
        ├── SerializedEvent.php
        └── Upcast
        │   ├── Upcast.php
        │   ├── Upcaster.php
        │   └── UpcasterChain.php
    ├── Snapshot
        ├── Adapter
        │   ├── InMemorySnapshotAdapter.php
        │   ├── Psr16SnapshotAdapter.php
        │   ├── Psr6SnapshotAdapter.php
        │   ├── SnapshotAdapter.php
        │   └── SnapshotNotFound.php
        ├── AdapterNotFound.php
        ├── AdapterRepository.php
        ├── ArrayAdapterRepository.php
        ├── DefaultSnapshotStore.php
        ├── Snapshot.php
        ├── SnapshotException.php
        ├── SnapshotNotConfigured.php
        ├── SnapshotNotFound.php
        ├── SnapshotStore.php
        └── SnapshotVersionInvalid.php
    ├── Store
        ├── ArchivedHeader.php
        ├── ArrayStream.php
        ├── Criteria
        │   ├── AggregateIdCriterion.php
        │   ├── AggregateNameCriterion.php
        │   ├── ArchivedCriterion.php
        │   ├── Criteria.php
        │   ├── CriteriaBuilder.php
        │   ├── CriterionNotFound.php
        │   ├── EventIdCriterion.php
        │   ├── EventsCriterion.php
        │   ├── FromIndexCriterion.php
        │   ├── FromPlayheadCriterion.php
        │   ├── StreamCriterion.php
        │   ├── ToIndexCriterion.php
        │   └── ToPlayheadCriterion.php
        ├── DoctrineDbalStore.php
        ├── DoctrineDbalStoreStream.php
        ├── Header
        │   ├── EventIdHeader.php
        │   ├── IndexHeader.php
        │   ├── PlayheadHeader.php
        │   ├── RecordedOnHeader.php
        │   └── StreamNameHeader.php
        ├── InMemoryStore.php
        ├── InvalidStreamName.php
        ├── InvalidType.php
        ├── LockingNotImplemented.php
        ├── MissingDataForStorage.php
        ├── ReadOnlyStore.php
        ├── Store.php
        ├── StoreException.php
        ├── StoreIsReadOnly.php
        ├── Stream.php
        ├── StreamClosed.php
        ├── StreamDoctrineDbalStore.php
        ├── StreamDoctrineDbalStoreStream.php
        ├── StreamReadOnlyStore.php
        ├── StreamStartHeader.php
        ├── StreamStore.php
        ├── SubscriptionStore.php
        ├── UniqueConstraintViolation.php
        ├── UnsupportedCriterion.php
        └── WrongQueryResult.php
    ├── Subscription
        ├── Engine
        │   ├── AlreadyProcessing.php
        │   ├── CatchUpSubscriptionEngine.php
        │   ├── DefaultSubscriptionEngine.php
        │   ├── Error.php
        │   ├── ErrorDetected.php
        │   ├── EventFilteredStoreMessageLoader.php
        │   ├── GapResolverStoreMessageLoader.php
        │   ├── GeneratorStream.php
        │   ├── MessageLoader.php
        │   ├── ProcessedResult.php
        │   ├── Result.php
        │   ├── StoreMessageLoader.php
        │   ├── SubscriberNotFound.php
        │   ├── SubscriptionCollection.php
        │   ├── SubscriptionEngine.php
        │   ├── SubscriptionEngineCriteria.php
        │   ├── SubscriptionManager.php
        │   ├── ThrowOnErrorSubscriptionEngine.php
        │   └── UnexpectedError.php
        ├── Lookup
        │   ├── Lookup.php
        │   └── MessageNotFound.php
        ├── NoErrorToRetry.php
        ├── Repository
        │   ├── RunSubscriptionEngineRepository.php
        │   └── RunSubscriptionEngineRepositoryManager.php
        ├── RetryStrategy
        │   ├── ClockBasedRetryStrategy.php
        │   ├── ConditionalRetryStrategy.php
        │   ├── NoRetryStrategy.php
        │   ├── RetryStrategy.php
        │   ├── RetryStrategyNotFound.php
        │   ├── RetryStrategyRepository.php
        │   └── UnexpectedError.php
        ├── RunMode.php
        ├── Status.php
        ├── Store
        │   ├── DoctrineSubscriptionStore.php
        │   ├── InMemorySubscriptionStore.php
        │   ├── LockableSubscriptionStore.php
        │   ├── SubscriptionAlreadyExists.php
        │   ├── SubscriptionCriteria.php
        │   ├── SubscriptionNotFound.php
        │   ├── SubscriptionStore.php
        │   └── TransactionCommitNotPossible.php
        ├── Subscriber
        │   ├── ArgumentResolver
        │   │   ├── AggregateIdArgumentResolver.php
        │   │   ├── ArgumentResolver.php
        │   │   ├── EventArgumentResolver.php
        │   │   ├── LookupResolver.php
        │   │   ├── MessageArgumentResolver.php
        │   │   └── RecordedOnArgumentResolver.php
        │   ├── BatchableSubscriber.php
        │   ├── DuplicateSubscriberId.php
        │   ├── MetadataSubscriberAccessor.php
        │   ├── MetadataSubscriberAccessorRepository.php
        │   ├── NoSuitableResolver.php
        │   ├── RealSubscriberAccessor.php
        │   ├── SubscriberAccessor.php
        │   ├── SubscriberAccessorRepository.php
        │   ├── SubscriberHelper.php
        │   └── SubscriberUtil.php
        ├── Subscription.php
        ├── SubscriptionError.php
        └── ThrowableToErrorContextTransformer.php
    └── Test
        └── IncrementalRamseyUuidFactory.php


/Dockerfile:
--------------------------------------------------------------------------------
 1 | FROM php:8.3
 2 | 
 3 | ARG EXTENSIONS="pcntl zip intl bcmath"
 4 | 
 5 | RUN apt-get update && apt-get install -y \
 6 |     git \
 7 |     zip \
 8 |     unzip \
 9 |     curl \
10 |  && rm -rf /var/lib/apt/lists/*
11 | 
12 | COPY --from=composer /usr/bin/composer /usr/bin/composer
13 | 
14 | ADD https://github.com/mlocati/docker-php-extension-installer/releases/latest/download/install-php-extensions /usr/local/bin/
15 | 
16 | RUN chmod +x /usr/local/bin/install-php-extensions && \
17 |     install-php-extensions $EXTENSIONS
18 | 
19 | RUN mkdir -p /tmp/blackfire \
20 |     && architecture=$(uname -m) \
21 |     && curl -A "Docker" -L https://blackfire.io/api/v1/releases/cli/linux/$architecture | tar zxp -C /tmp/blackfire \
22 |     && mv /tmp/blackfire/blackfire /usr/bin/blackfire \
23 |     && rm -Rf /tmp/blackfire


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2020 Daniel Badura & David Badura
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/UPGRADE-3.0.md:
--------------------------------------------------------------------------------
1 | The upgrade path is located in our docs. Please have a look at 
2 | [here](https://patchlevel.github.io/event-sourcing-docs/3.0/UPGRADE-3.0/).
3 | 


--------------------------------------------------------------------------------
/deptrac-baseline.yaml:
--------------------------------------------------------------------------------
 1 | deptrac:
 2 |   skip_violations:
 3 |     Patchlevel\EventSourcing\Aggregate\AggregateRootId:
 4 |       - Patchlevel\EventSourcing\Serializer\Normalizer\IdNormalizer
 5 |     Patchlevel\EventSourcing\Aggregate\CustomId:
 6 |       - Patchlevel\EventSourcing\Serializer\Normalizer\IdNormalizer
 7 |     Patchlevel\EventSourcing\Aggregate\Uuid:
 8 |       - Patchlevel\EventSourcing\Serializer\Normalizer\IdNormalizer
 9 |     Patchlevel\EventSourcing\Attribute\Processor:
10 |       - Patchlevel\EventSourcing\Subscription\RunMode
11 |     Patchlevel\EventSourcing\Attribute\Projector:
12 |       - Patchlevel\EventSourcing\Subscription\RunMode
13 |     Patchlevel\EventSourcing\Attribute\Stream:
14 |       - Patchlevel\EventSourcing\Aggregate\AggregateRoot
15 |     Patchlevel\EventSourcing\Attribute\Subscriber:
16 |       - Patchlevel\EventSourcing\Subscription\RunMode
17 | 


--------------------------------------------------------------------------------
/docker-compose.yaml:
--------------------------------------------------------------------------------
 1 | services:
 2 |   postgres:
 3 |     image: postgres:alpine
 4 |     environment:
 5 |       - POSTGRES_PASSWORD=postgres
 6 |       - POSTGRES_DB=eventstore
 7 |     ports:
 8 |       - 5432:5432
 9 | 
10 |   mysql:
11 |     image: mysql:8
12 |     environment:
13 |       - MYSQL_ALLOW_EMPTY_PASSWORD="yes"
14 |       - MYSQL_DATABASE=eventstore
15 |     ports:
16 |       - 3306:3306


--------------------------------------------------------------------------------
/infection.json.dist:
--------------------------------------------------------------------------------
 1 | {
 2 |   "source": {
 3 |     "directories": [
 4 |       "src"
 5 |     ]
 6 |   },
 7 |   "logs": {
 8 |     "text": "infection.log",
 9 |     "html": "infection.html",
10 |     "stryker": {
11 |       "report": "/[0-9]+.[0-9]+.x/"
12 |     }
13 |   },
14 |   "mutators": {
15 |     "@default": true
16 |   },
17 |   "minMsi": 72,
18 |   "minCoveredMsi": 95,
19 |   "testFrameworkOptions": "--testsuite=unit"
20 | }
21 | 


--------------------------------------------------------------------------------
/phpstan.neon.dist:
--------------------------------------------------------------------------------
 1 | includes:
 2 | 	- phpstan-baseline.neon
 3 | 
 4 | parameters:
 5 | 	level: max
 6 | 	paths:
 7 | 		- src
 8 | 	ignoreErrors:
 9 | 		-
10 | 			identifier: missingType.generics
11 | 


--------------------------------------------------------------------------------
/psalm_docs.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0"?>
 2 | <psalm
 3 |         errorLevel="1"
 4 |         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 5 |         xmlns="https://getpsalm.org/schema/config"
 6 |         xsi:schemaLocation="https://getpsalm.org/schema/config vendor/vimeo/psalm/config.xsd"
 7 | >
 8 |     <projectFiles>
 9 |         <directory name="docs_php"/>
10 |         <ignoreFiles>
11 |             <directory name="vendor"/>
12 |         </ignoreFiles>
13 |     </projectFiles>
14 | 
15 |     <plugins>
16 |         <pluginClass class="Patchlevel\EventSourcingPsalmPlugin\Plugin"/>
17 |     </plugins>
18 | 
19 |     <issueHandlers>
20 |         <DuplicateClass errorLevel="suppress" />
21 |         <UnusedVariable errorLevel="suppress" />
22 |         <UndefinedGlobalVariable errorLevel="suppress" />
23 |         <UndefinedClass>
24 |             <errorLevel type="suppress">
25 |                 <referencedClass name="Email" />
26 |                 <referencedClass name="EmailChanged" />
27 |                 <referencedClass name="ComplexObject" />
28 |                 <referencedClass name="Status" />
29 |                 <referencedClass name="NameIsToShortException" />
30 |             </errorLevel>
31 |         </UndefinedClass>
32 |     </issueHandlers>
33 | </psalm>
34 | 


--------------------------------------------------------------------------------
/renovate.json:
--------------------------------------------------------------------------------
1 | {
2 |   "$schema": "https://docs.renovatebot.com/renovate-schema.json",
3 |   "extends": [
4 |     "local>patchlevel/.github:renovate-config"
5 |   ]
6 | }
7 | 


--------------------------------------------------------------------------------
/src/Aggregate/AggregateException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Aggregate;
 6 | 
 7 | use RuntimeException;
 8 | 
 9 | abstract class AggregateException extends RuntimeException
10 | {
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Aggregate/AggregateHeader.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Aggregate;
 6 | 
 7 | use DateTimeImmutable;
 8 | use Patchlevel\Hydrator\Normalizer\DateTimeImmutableNormalizer;
 9 | 
10 | /** @psalm-immutable */
11 | final class AggregateHeader
12 | {
13 |     /** @param positive-int $playhead */
14 |     public function __construct(
15 |         public readonly string $aggregateName,
16 |         public readonly string $aggregateId,
17 |         public readonly int $playhead,
18 |         #[DateTimeImmutableNormalizer]
19 |         public readonly DateTimeImmutable $recordedOn,
20 |     ) {
21 |     }
22 | 
23 |     public function streamName(): string
24 |     {
25 |         return $this->aggregateName . '-' . $this->aggregateId;
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Aggregate/AggregateRoot.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Aggregate;
 6 | 
 7 | interface AggregateRoot
 8 | {
 9 |     public function aggregateRootId(): AggregateRootId;
10 | 
11 |     /** @param iterable<object> $events */
12 |     public function catchUp(iterable $events): void;
13 | 
14 |     /** @return list<object> */
15 |     public function releaseEvents(): array;
16 | 
17 |     /**
18 |      * @param iterable<object> $events
19 |      * @param 0|positive-int   $startPlayhead
20 |      */
21 |     public static function createFromEvents(iterable $events, int $startPlayhead = 0): static;
22 | 
23 |     public function playhead(): int;
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Aggregate/AggregateRootId.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Aggregate;
 6 | 
 7 | use Patchlevel\EventSourcing\Serializer\Normalizer\IdNormalizer;
 8 | 
 9 | #[IdNormalizer]
10 | interface AggregateRootId
11 | {
12 |     public function toString(): string;
13 | 
14 |     public static function fromString(string $id): self;
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Aggregate/AggregateRootIdNotSupported.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Aggregate;
 6 | 
 7 | use RuntimeException;
 8 | 
 9 | use function get_debug_type;
10 | use function sprintf;
11 | 
12 | final class AggregateRootIdNotSupported extends RuntimeException
13 | {
14 |     /** @param class-string $aggregateRootClass */
15 |     public function __construct(string $aggregateRootClass, mixed $value)
16 |     {
17 |         parent::__construct(
18 |             sprintf(
19 |                 'aggregate root id in class "%s" must be instance of "%s", got "%s"',
20 |                 $aggregateRootClass,
21 |                 AggregateRootId::class,
22 |                 get_debug_type($value),
23 |             ),
24 |         );
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Aggregate/AggregateRootMetadataAware.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Aggregate;
 6 | 
 7 | use Patchlevel\EventSourcing\Metadata\AggregateRoot\AggregateRootMetadata;
 8 | use Patchlevel\EventSourcing\Metadata\AggregateRoot\AggregateRootMetadataFactory;
 9 | 
10 | interface AggregateRootMetadataAware
11 | {
12 |     public static function metadata(): AggregateRootMetadata;
13 | 
14 |     public static function setMetadataFactory(AggregateRootMetadataFactory $metadataFactory): void;
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Aggregate/AggregateRootMetadataAwareBehaviour.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Aggregate;
 6 | 
 7 | use Patchlevel\EventSourcing\Metadata\AggregateRoot\AggregateRootMetadata;
 8 | use Patchlevel\EventSourcing\Metadata\AggregateRoot\AggregateRootMetadataFactory;
 9 | use Patchlevel\EventSourcing\Metadata\AggregateRoot\AttributeAggregateRootMetadataFactory;
10 | use Patchlevel\Hydrator\Attribute\Ignore;
11 | 
12 | trait AggregateRootMetadataAwareBehaviour
13 | {
14 |     #[Ignore]
15 |     private static AggregateRootMetadataFactory|null $metadataFactory = null;
16 | 
17 |     /** @return AggregateRootMetadata<self> */
18 |     public static function metadata(): AggregateRootMetadata
19 |     {
20 |         if (!self::$metadataFactory) {
21 |             self::$metadataFactory = new AttributeAggregateRootMetadataFactory();
22 |         }
23 | 
24 |         return self::$metadataFactory->metadata(static::class);
25 |     }
26 | 
27 |     public static function setMetadataFactory(AggregateRootMetadataFactory $metadataFactory): void
28 |     {
29 |         self::$metadataFactory = $metadataFactory;
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/Aggregate/ApplyMethodNotFound.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Aggregate;
 6 | 
 7 | use function sprintf;
 8 | 
 9 | final class ApplyMethodNotFound extends AggregateException
10 | {
11 |     /**
12 |      * @param class-string<AggregateRoot> $aggregateRootClass
13 |      * @param class-string                $event
14 |      */
15 |     public function __construct(string $aggregateRootClass, string $event)
16 |     {
17 |         parent::__construct(
18 |             sprintf(
19 |                 'Apply method in "%s" could not be found for the event "%s"',
20 |                 $aggregateRootClass,
21 |                 $event,
22 |             ),
23 |         );
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Aggregate/BasicAggregateRoot.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Aggregate;
 6 | 
 7 | use Patchlevel\EventSourcing\Metadata\AggregateRoot\AggregateRootMetadata;
 8 | 
 9 | abstract class BasicAggregateRoot implements AggregateRoot, AggregateRootMetadataAware
10 | {
11 |     use AggregateRootAttributeBehaviour {
12 |         metadata as getMetadata;
13 |     }
14 | 
15 |     /** @return AggregateRootMetadata<self> */
16 |     public static function metadata(): AggregateRootMetadata
17 |     {
18 |         if (static::class === self::class) {
19 |             throw new MetadataNotPossible();
20 |         }
21 | 
22 |         return static::getMetadata();
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Aggregate/BasicChildAggregate.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Aggregate;
 6 | 
 7 | use Patchlevel\Hydrator\Normalizer\ObjectNormalizer;
 8 | 
 9 | /** @experimental  */
10 | #[ObjectNormalizer]
11 | abstract class BasicChildAggregate implements ChildAggregate
12 | {
13 |     use ChildAggregateBehaviour;
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Aggregate/ChildAggregate.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Aggregate;
 6 | 
 7 | /** @experimental  */
 8 | interface ChildAggregate
 9 | {
10 |     /** @param callable(object $event): void $recorder */
11 |     public function setRecorder(callable $recorder): void;
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Aggregate/ChildAggregateBehaviour.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Aggregate;
 6 | 
 7 | use Patchlevel\Hydrator\Attribute\Ignore;
 8 | 
 9 | /** @experimental  */
10 | trait ChildAggregateBehaviour
11 | {
12 |     /** @var callable(object $event): void */
13 |     #[Ignore]
14 |     private $recorder;
15 | 
16 |     protected function recordThat(object $event): void
17 |     {
18 |         ($this->recorder)($event);
19 |     }
20 | 
21 |     /** @param callable(object $event): void $recorder */
22 |     public function setRecorder(callable $recorder): void
23 |     {
24 |         $this->recorder = $recorder;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Aggregate/CustomId.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Aggregate;
 6 | 
 7 | final class CustomId implements AggregateRootId
 8 | {
 9 |     use CustomIdBehaviour;
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Aggregate/CustomIdBehaviour.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Aggregate;
 6 | 
 7 | trait CustomIdBehaviour
 8 | {
 9 |     public function __construct(
10 |         private readonly string $id,
11 |     ) {
12 |     }
13 | 
14 |     public static function fromString(string $id): self
15 |     {
16 |         return new self($id);
17 |     }
18 | 
19 |     public function toString(): string
20 |     {
21 |         return $this->id;
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Aggregate/InvalidAggregateStreamName.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Aggregate;
 6 | 
 7 | use RuntimeException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class InvalidAggregateStreamName extends RuntimeException
12 | {
13 |     public function __construct(string $stream)
14 |     {
15 |         parent::__construct(sprintf('Invalid aggregate stream name "%s". Expected format is "[aggregateName]-[aggregateId]".', $stream));
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Aggregate/MetadataNotPossible.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Aggregate;
 6 | 
 7 | final class MetadataNotPossible extends AggregateException
 8 | {
 9 |     public function __construct()
10 |     {
11 |         parent::__construct('Metadata method must be called on the concrete implementation');
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Aggregate/RamseyUuidV7Behaviour.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Aggregate;
 6 | 
 7 | use Ramsey\Uuid\Uuid;
 8 | use Ramsey\Uuid\UuidInterface;
 9 | 
10 | trait RamseyUuidV7Behaviour
11 | {
12 |     public function __construct(
13 |         private readonly UuidInterface $id,
14 |     ) {
15 |     }
16 | 
17 |     public static function fromString(string $id): self
18 |     {
19 |         return new self(Uuid::fromString($id));
20 |     }
21 | 
22 |     public function toString(): string
23 |     {
24 |         return $this->id->toString();
25 |     }
26 | 
27 |     public static function generate(): self
28 |     {
29 |         return new self(Uuid::uuid7());
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/Aggregate/Uuid.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Aggregate;
 6 | 
 7 | final class Uuid implements AggregateRootId
 8 | {
 9 |     use RamseyUuidV7Behaviour;
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Attribute/Aggregate.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Attribute;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_CLASS)]
10 | final class Aggregate
11 | {
12 |     public function __construct(
13 |         public readonly string $name,
14 |     ) {
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Attribute/Answer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Attribute;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_METHOD)]
10 | final class Answer
11 | {
12 |     /** @param class-string|null $queryClass */
13 |     public function __construct(
14 |         public readonly string|null $queryClass = null,
15 |     ) {
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Attribute/Apply.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Attribute;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_METHOD | Attribute::IS_REPEATABLE)]
10 | final class Apply
11 | {
12 |     /** @param class-string|null $eventClass */
13 |     public function __construct(
14 |         public readonly string|null $eventClass = null,
15 |     ) {
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Attribute/ChildAggregate.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Attribute;
 6 | 
 7 | use Attribute;
 8 | 
 9 | /** @experimental */
10 | #[Attribute(Attribute::TARGET_PROPERTY)]
11 | final class ChildAggregate
12 | {
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Attribute/Event.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Attribute;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_CLASS)]
10 | final class Event
11 | {
12 |     public function __construct(
13 |         public readonly string $name,
14 |         /** @var list<string> */
15 |         public readonly array $aliases = [],
16 |     ) {
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Attribute/Handle.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Attribute;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_METHOD)]
10 | final class Handle
11 | {
12 |     /** @param class-string|null $commandClass */
13 |     public function __construct(
14 |         public readonly string|null $commandClass = null,
15 |     ) {
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Attribute/Header.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Attribute;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_CLASS)]
10 | final class Header
11 | {
12 |     public function __construct(
13 |         public readonly string $name,
14 |     ) {
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Attribute/Id.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Attribute;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_PROPERTY)]
10 | final class Id
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Attribute/Inject.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Attribute;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_PARAMETER)]
10 | final class Inject
11 | {
12 |     public function __construct(
13 |         public readonly string $service,
14 |     ) {
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Attribute/OnFailed.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Attribute;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_METHOD)]
10 | final class OnFailed
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Attribute/Processor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Attribute;
 6 | 
 7 | use Attribute;
 8 | use Patchlevel\EventSourcing\Subscription\RunMode;
 9 | 
10 | #[Attribute(Attribute::TARGET_CLASS)]
11 | final class Processor extends Subscriber
12 | {
13 |     public function __construct(
14 |         string $id,
15 |         string $group = 'processor',
16 |         RunMode $runMode = RunMode::FromNow,
17 |     ) {
18 |         parent::__construct($id, $runMode, $group);
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Attribute/Projector.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Attribute;
 6 | 
 7 | use Attribute;
 8 | use Patchlevel\EventSourcing\Subscription\RunMode;
 9 | 
10 | #[Attribute(Attribute::TARGET_CLASS)]
11 | final class Projector extends Subscriber
12 | {
13 |     public function __construct(
14 |         string $id,
15 |         string $group = 'projector',
16 |         RunMode $runMode = RunMode::FromBeginning,
17 |     ) {
18 |         parent::__construct($id, $runMode, $group);
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Attribute/RetryAggregateOutdated.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Attribute;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_CLASS)]
10 | final class RetryAggregateOutdated
11 | {
12 |     public function __construct(
13 |         public readonly int $maxRetries = 3,
14 |     ) {
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Attribute/RetryStrategy.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Attribute;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_CLASS)]
10 | final class RetryStrategy
11 | {
12 |     public function __construct(
13 |         public readonly string $name,
14 |     ) {
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Attribute/Setup.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Attribute;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_METHOD)]
10 | final class Setup
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Attribute/Snapshot.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Attribute;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_CLASS)]
10 | final class Snapshot
11 | {
12 |     public function __construct(
13 |         public readonly string $name,
14 |         public readonly int|null $batch = null,
15 |         public readonly string|null $version = null,
16 |     ) {
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Attribute/SplitStream.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Attribute;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_CLASS)]
10 | final class SplitStream
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Attribute/Stream.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Attribute;
 6 | 
 7 | use Attribute;
 8 | use Patchlevel\EventSourcing\Aggregate\AggregateRoot;
 9 | 
10 | #[Attribute(Attribute::TARGET_CLASS)]
11 | final class Stream
12 | {
13 |     /** @param string|class-string<AggregateRoot> $name */
14 |     public function __construct(
15 |         public readonly string $name,
16 |     ) {
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Attribute/Subscribe.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Attribute;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_METHOD | Attribute::IS_REPEATABLE)]
10 | final class Subscribe
11 | {
12 |     public const ALL = '*';
13 | 
14 |     /** @param class-string|self::ALL $eventClass */
15 |     public function __construct(
16 |         public readonly string $eventClass,
17 |     ) {
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Attribute/Subscriber.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Attribute;
 6 | 
 7 | use Attribute;
 8 | use Cspray\Phinal\AllowInheritance;
 9 | use Patchlevel\EventSourcing\Subscription\RunMode;
10 | 
11 | #[Attribute(Attribute::TARGET_CLASS)]
12 | #[AllowInheritance('You can create specific attributes with default group and run mode')]
13 | class Subscriber
14 | {
15 |     public function __construct(
16 |         public readonly string $id,
17 |         public readonly RunMode $runMode,
18 |         public readonly string $group = 'default',
19 |     ) {
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Attribute/SuppressMissingApply.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Attribute;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_CLASS)]
10 | final class SuppressMissingApply
11 | {
12 |     public const ALL = '*';
13 | 
14 |     /** @var list<class-string> */
15 |     public readonly array $suppressEvents;
16 |     public readonly bool $suppressAll;
17 | 
18 |     /** @param list<class-string>|self::ALL $suppress */
19 |     public function __construct(string|array $suppress)
20 |     {
21 |         if ($suppress === self::ALL) {
22 |             $this->suppressEvents = [];
23 |             $this->suppressAll = true;
24 | 
25 |             return;
26 |         }
27 | 
28 |         $this->suppressEvents = $suppress;
29 |         $this->suppressAll = false;
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/Attribute/Teardown.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Attribute;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_METHOD)]
10 | final class Teardown
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Clock/FrozenClock.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Clock;
 6 | 
 7 | use DateTimeImmutable;
 8 | use Psr\Clock\ClockInterface;
 9 | 
10 | use function sprintf;
11 | 
12 | final class FrozenClock implements ClockInterface
13 | {
14 |     public function __construct(
15 |         private DateTimeImmutable $frozenDateTime,
16 |     ) {
17 |     }
18 | 
19 |     public function now(): DateTimeImmutable
20 |     {
21 |         return clone $this->frozenDateTime;
22 |     }
23 | 
24 |     public function update(DateTimeImmutable $frozenDateTime): void
25 |     {
26 |         $this->frozenDateTime = $frozenDateTime;
27 |     }
28 | 
29 |     /** @param positive-int $seconds */
30 |     public function sleep(int $seconds): void
31 |     {
32 |         $this->frozenDateTime = $this->frozenDateTime->modify(sprintf('+%s seconds', $seconds));
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Clock/SystemClock.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Clock;
 6 | 
 7 | use DateTimeImmutable;
 8 | use Psr\Clock\ClockInterface;
 9 | 
10 | final class SystemClock implements ClockInterface
11 | {
12 |     public function now(): DateTimeImmutable
13 |     {
14 |         return new DateTimeImmutable();
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/CommandBus/ChainHandlerProvider.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\CommandBus;
 6 | 
 7 | final class ChainHandlerProvider implements HandlerProvider
 8 | {
 9 |     /** @param iterable<HandlerProvider> $providers */
10 |     public function __construct(
11 |         private readonly iterable $providers,
12 |     ) {
13 |     }
14 | 
15 |     /**
16 |      * @param class-string $commandClass
17 |      *
18 |      * @return iterable<int, HandlerDescriptor>
19 |      */
20 |     public function handlerForCommand(string $commandClass): iterable
21 |     {
22 |         $handlers = [];
23 | 
24 |         foreach ($this->providers as $provider) {
25 |             $handlers = [
26 |                 ...$handlers,
27 |                 ...$provider->handlerForCommand($commandClass),
28 |             ];
29 |         }
30 | 
31 |         return $handlers;
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/CommandBus/CommandBus.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\CommandBus;
 6 | 
 7 | interface CommandBus
 8 | {
 9 |     /** @throws HandlerNotFound */
10 |     public function dispatch(object $command): void;
11 | }
12 | 


--------------------------------------------------------------------------------
/src/CommandBus/Handler/AggregateIdNotFound.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\CommandBus\Handler;
 6 | 
 7 | use RuntimeException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class AggregateIdNotFound extends RuntimeException
12 | {
13 |     /** @param class-string $commandClass */
14 |     public function __construct(string $commandClass)
15 |     {
16 |         parent::__construct(sprintf('Missing `Id` Attribute in command %s', $commandClass));
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/CommandBus/Handler/CreateAggregateHandler.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\CommandBus\Handler;
 6 | 
 7 | use InvalidArgumentException;
 8 | use Patchlevel\EventSourcing\Aggregate\AggregateRoot;
 9 | use Patchlevel\EventSourcing\Repository\RepositoryManager;
10 | use ReflectionClass;
11 | 
12 | final class CreateAggregateHandler
13 | {
14 |     /** @param class-string<AggregateRoot> $aggregateClass */
15 |     public function __construct(
16 |         private readonly RepositoryManager $repositoryManager,
17 |         private readonly string $aggregateClass,
18 |         private readonly string $methodName,
19 |         private readonly ParameterResolver $parameterResolver,
20 |     ) {
21 |     }
22 | 
23 |     public function __invoke(object $command): void
24 |     {
25 |         $repository = $this->repositoryManager->get($this->aggregateClass);
26 | 
27 |         $reflection = new ReflectionClass($this->aggregateClass);
28 |         $reflectionMethod = $reflection->getMethod($this->methodName);
29 | 
30 |         $aggregate = $reflectionMethod->invokeArgs(
31 |             null,
32 |             [...$this->parameterResolver->resolve($reflectionMethod, $command)],
33 |         );
34 | 
35 |         if (!$aggregate instanceof AggregateRoot) {
36 |             throw new InvalidArgumentException('create method must return an instance of AggregateRoot');
37 |         }
38 | 
39 |         $repository->save($aggregate);
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/src/CommandBus/Handler/ParameterResolver.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\CommandBus\Handler;
 6 | 
 7 | use ReflectionMethod;
 8 | 
 9 | interface ParameterResolver
10 | {
11 |     /** @return iterable<mixed> */
12 |     public function resolve(ReflectionMethod $method, object $command): iterable;
13 | }
14 | 


--------------------------------------------------------------------------------
/src/CommandBus/Handler/ServiceNotResolvable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\CommandBus\Handler;
 6 | 
 7 | use RuntimeException;
 8 | use Throwable;
 9 | 
10 | use function sprintf;
11 | 
12 | final class ServiceNotResolvable extends RuntimeException
13 | {
14 |     /** @param class-string $class */
15 |     public static function missingType(string $class, string $propertyName): self
16 |     {
17 |         return new self(sprintf('Missing type for property "%s" in class "%s"', $propertyName, $class));
18 |     }
19 | 
20 |     /** @param class-string $class */
21 |     public static function typeNotObject(string $class, string $propertyName): self
22 |     {
23 |         return new self(sprintf('Type for property "%s" in class "%s" must be object', $propertyName, $class));
24 |     }
25 | 
26 |     public static function missingContainer(): self
27 |     {
28 |         return new self('Container is not configured');
29 |     }
30 | 
31 |     public static function missingService(string $class, string $method, string $parameter, Throwable $exception): self
32 |     {
33 |         return new self(
34 |             sprintf(
35 |                 'Missing service for parameter "%s" in "%s::%s" . Exception: %s',
36 |                 $parameter,
37 |                 $class,
38 |                 $method,
39 |                 $exception->getMessage(),
40 |             ),
41 |             0,
42 |             $exception,
43 |         );
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/CommandBus/HandlerDescriptor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\CommandBus;
 6 | 
 7 | use Closure;
 8 | use ReflectionFunction;
 9 | 
10 | final class HandlerDescriptor
11 | {
12 |     private readonly Closure $callable;
13 |     private readonly string $name;
14 | 
15 |     public function __construct(callable $callable)
16 |     {
17 |         $this->callable = $callable(...);
18 |         $this->name = self::closureName($this->callable);
19 |     }
20 | 
21 |     public function name(): string
22 |     {
23 |         return $this->name;
24 |     }
25 | 
26 |     public function callable(): callable
27 |     {
28 |         return $this->callable;
29 |     }
30 | 
31 |     private static function closureName(Closure $closure): string
32 |     {
33 |         $reflectionFunction = new ReflectionFunction($closure);
34 | 
35 |         if ($reflectionFunction->isAnonymous()) {
36 |             return 'Closure';
37 |         }
38 | 
39 |         $closureThis = $reflectionFunction->getClosureThis();
40 | 
41 |         if (!$closureThis) {
42 |             $class = $reflectionFunction->getClosureCalledClass();
43 | 
44 |             return ($class ? $class->name . '::' : '') . $reflectionFunction->name;
45 |         }
46 | 
47 |         return $closureThis::class . '::' . $reflectionFunction->name;
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/src/CommandBus/HandlerNotFound.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\CommandBus;
 6 | 
 7 | use RuntimeException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class HandlerNotFound extends RuntimeException
12 | {
13 |     /** @param class-string $commandClass */
14 |     public function __construct(string $commandClass)
15 |     {
16 |         parent::__construct(sprintf('Handler for command "%s" not found', $commandClass));
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/CommandBus/HandlerProvider.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\CommandBus;
 6 | 
 7 | interface HandlerProvider
 8 | {
 9 |     /**
10 |      * @param class-string $commandClass
11 |      *
12 |      * @return iterable<int, HandlerDescriptor>
13 |      */
14 |     public function handlerForCommand(string $commandClass): iterable;
15 | }
16 | 


--------------------------------------------------------------------------------
/src/CommandBus/HandlerReference.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\CommandBus;
 6 | 
 7 | final class HandlerReference
 8 | {
 9 |     /** @param class-string $commandClass */
10 |     public function __construct(
11 |         public readonly string $commandClass,
12 |         public readonly string $method,
13 |         public readonly bool $static,
14 |     ) {
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/CommandBus/InvalidHandleMethod.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\CommandBus;
 6 | 
 7 | use InvalidArgumentException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class InvalidHandleMethod extends InvalidArgumentException
12 | {
13 |     public static function noParameters(string $aggregateClass, string $method): self
14 |     {
15 |         return new self(sprintf('Method "%s" in aggregate "%s" has no parameters', $method, $aggregateClass));
16 |     }
17 | 
18 |     public static function incompatibleType(string $aggregateClass, string $method): self
19 |     {
20 |         return new self(sprintf('Method "%s" in aggregate "%s" has no compatible type', $method, $aggregateClass));
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/CommandBus/MultipleHandlersFound.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\CommandBus;
 6 | 
 7 | use RuntimeException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class MultipleHandlersFound extends RuntimeException
12 | {
13 |     /** @param class-string $commandClass */
14 |     public function __construct(string $commandClass)
15 |     {
16 |         parent::__construct(sprintf('Multiple handlers found for command "%s"', $commandClass));
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/CommandBus/RetryOutdatedAggregateCommandBus.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\CommandBus;
 6 | 
 7 | use Patchlevel\EventSourcing\Attribute\RetryAggregateOutdated;
 8 | use Patchlevel\EventSourcing\Repository\AggregateOutdated;
 9 | use ReflectionClass;
10 | 
11 | final class RetryOutdatedAggregateCommandBus implements CommandBus
12 | {
13 |     public function __construct(
14 |         private readonly CommandBus $commandBus,
15 |     ) {
16 |     }
17 | 
18 |     public function dispatch(object $command): void
19 |     {
20 |         $this->doDispatch($command, 0);
21 |     }
22 | 
23 |     private function doDispatch(object $command, int $retry, int|null $maxRetries = null): void
24 |     {
25 |         try {
26 |             $this->commandBus->dispatch($command);
27 |         } catch (AggregateOutdated $exception) {
28 |             $maxRetries ??= $this->maxRetries($command);
29 | 
30 |             if ($retry >= $maxRetries) {
31 |                 throw $exception;
32 |             }
33 | 
34 |             $this->doDispatch($command, $retry + 1, $maxRetries);
35 |         }
36 |     }
37 | 
38 |     private function maxRetries(object $command): int|null
39 |     {
40 |         $reflectionClass = new ReflectionClass($command);
41 |         $attributes = $reflectionClass->getAttributes(RetryAggregateOutdated::class);
42 | 
43 |         if ($attributes === []) {
44 |             return 0;
45 |         }
46 | 
47 |         return $attributes[0]->newInstance()->maxRetries;
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/src/CommandBus/ServiceHandlerProvider.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\CommandBus;
 6 | 
 7 | final class ServiceHandlerProvider implements HandlerProvider
 8 | {
 9 |     private bool $initialized = false;
10 | 
11 |     /** @var array<class-string, list<HandlerDescriptor>> */
12 |     private array $handlers = [];
13 | 
14 |     /** @param iterable<object> $services */
15 |     public function __construct(
16 |         private readonly iterable $services,
17 |     ) {
18 |     }
19 | 
20 |     /**
21 |      * @param class-string $commandClass
22 |      *
23 |      * @return iterable<int, HandlerDescriptor>
24 |      */
25 |     public function handlerForCommand(string $commandClass): iterable
26 |     {
27 |         if (!$this->initialized) {
28 |             $this->initialize();
29 |         }
30 | 
31 |         return $this->handlers[$commandClass] ?? [];
32 |     }
33 | 
34 |     private function initialize(): void
35 |     {
36 |         foreach ($this->services as $service) {
37 |             foreach (HandlerFinder::findInClass($service::class) as $handler) {
38 |                 if ($handler->static) {
39 |                     $this->handlers[$handler->commandClass][] = new HandlerDescriptor(
40 |                         $service::{$handler->method}(...),
41 |                     );
42 | 
43 |                     continue;
44 |                 }
45 | 
46 |                 $this->handlers[$handler->commandClass][] = new HandlerDescriptor(
47 |                     $service->{$handler->method}(...),
48 |                 );
49 |             }
50 |         }
51 | 
52 |         $this->initialized = true;
53 |     }
54 | }
55 | 


--------------------------------------------------------------------------------
/src/CommandBus/ServiceLocator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\CommandBus;
 6 | 
 7 | use Psr\Container\ContainerInterface;
 8 | 
 9 | use function array_key_exists;
10 | 
11 | final class ServiceLocator implements ContainerInterface
12 | {
13 |     /** @param array<string, mixed> $services */
14 |     public function __construct(
15 |         private readonly array $services = [],
16 |     ) {
17 |     }
18 | 
19 |     public function get(string $id): mixed
20 |     {
21 |         if (!array_key_exists($id, $this->services)) {
22 |             throw new ServiceNotFound($id);
23 |         }
24 | 
25 |         return $this->services[$id];
26 |     }
27 | 
28 |     public function has(string $id): bool
29 |     {
30 |         return array_key_exists($id, $this->services);
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/CommandBus/ServiceNotFound.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\CommandBus;
 6 | 
 7 | use Psr\Container\NotFoundExceptionInterface;
 8 | use RuntimeException;
 9 | 
10 | use function sprintf;
11 | 
12 | final class ServiceNotFound extends RuntimeException implements NotFoundExceptionInterface
13 | {
14 |     public function __construct(string $id)
15 |     {
16 |         parent::__construct(sprintf('service "%s" not found', $id));
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Console/Command/SubscriptionPauseCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Console\Command;
 6 | 
 7 | use Symfony\Component\Console\Attribute\AsCommand;
 8 | use Symfony\Component\Console\Input\InputInterface;
 9 | use Symfony\Component\Console\Output\OutputInterface;
10 | 
11 | #[AsCommand(
12 |     'event-sourcing:subscription:pause',
13 |     'Set subscription to pause',
14 | )]
15 | final class SubscriptionPauseCommand extends SubscriptionCommand
16 | {
17 |     protected function execute(InputInterface $input, OutputInterface $output): int
18 |     {
19 |         $criteria = $this->subscriptionEngineCriteria($input);
20 |         $this->engine->pause($criteria);
21 | 
22 |         return 0;
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Console/Command/SubscriptionReactivateCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Console\Command;
 6 | 
 7 | use Symfony\Component\Console\Attribute\AsCommand;
 8 | use Symfony\Component\Console\Input\InputInterface;
 9 | use Symfony\Component\Console\Output\OutputInterface;
10 | 
11 | #[AsCommand(
12 |     'event-sourcing:subscription:reactivate',
13 |     'Reactivate subscriptions',
14 | )]
15 | final class SubscriptionReactivateCommand extends SubscriptionCommand
16 | {
17 |     protected function execute(InputInterface $input, OutputInterface $output): int
18 |     {
19 |         $criteria = $this->subscriptionEngineCriteria($input);
20 |         $this->engine->reactivate($criteria);
21 | 
22 |         return 0;
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Console/Command/SubscriptionRemoveCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Console\Command;
 6 | 
 7 | use Patchlevel\EventSourcing\Console\OutputStyle;
 8 | use Symfony\Component\Console\Attribute\AsCommand;
 9 | use Symfony\Component\Console\Input\InputInterface;
10 | use Symfony\Component\Console\Output\OutputInterface;
11 | 
12 | #[AsCommand(
13 |     'event-sourcing:subscription:remove',
14 |     'Delete all subscriptions',
15 | )]
16 | final class SubscriptionRemoveCommand extends SubscriptionCommand
17 | {
18 |     protected function execute(InputInterface $input, OutputInterface $output): int
19 |     {
20 |         $io = new OutputStyle($input, $output);
21 | 
22 |         $criteria = $this->subscriptionEngineCriteria($input);
23 | 
24 |         if ($criteria->ids === null) {
25 |             if (!$io->confirm('do you want to remove all subscriptions?', false)) {
26 |                 return 1;
27 |             }
28 |         }
29 | 
30 |         $this->engine->remove($criteria);
31 | 
32 |         return 0;
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Console/Command/SubscriptionSetupCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Console\Command;
 6 | 
 7 | use Patchlevel\EventSourcing\Console\InputHelper;
 8 | use Symfony\Component\Console\Attribute\AsCommand;
 9 | use Symfony\Component\Console\Input\InputInterface;
10 | use Symfony\Component\Console\Input\InputOption;
11 | use Symfony\Component\Console\Output\OutputInterface;
12 | 
13 | #[AsCommand(
14 |     'event-sourcing:subscription:setup',
15 |     'Setup new subscriptions',
16 | )]
17 | final class SubscriptionSetupCommand extends SubscriptionCommand
18 | {
19 |     protected function configure(): void
20 |     {
21 |         parent::configure();
22 | 
23 |         $this
24 |             ->addOption(
25 |                 'skip-booting',
26 |                 null,
27 |                 InputOption::VALUE_NONE,
28 |                 'Skip booting',
29 |             );
30 |     }
31 | 
32 |     protected function execute(InputInterface $input, OutputInterface $output): int
33 |     {
34 |         $skipBooting = InputHelper::bool($input->getOption('skip-booting'));
35 | 
36 |         $criteria = $this->subscriptionEngineCriteria($input);
37 |         $this->engine->setup($criteria, $skipBooting);
38 | 
39 |         return 0;
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/src/Console/Command/SubscriptionTeardownCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Console\Command;
 6 | 
 7 | use Symfony\Component\Console\Attribute\AsCommand;
 8 | use Symfony\Component\Console\Input\InputInterface;
 9 | use Symfony\Component\Console\Output\OutputInterface;
10 | 
11 | #[AsCommand(
12 |     'event-sourcing:subscription:teardown',
13 |     'Shut down and delete the outdated subscriptions',
14 | )]
15 | final class SubscriptionTeardownCommand extends SubscriptionCommand
16 | {
17 |     protected function execute(InputInterface $input, OutputInterface $output): int
18 |     {
19 |         $criteria = $this->subscriptionEngineCriteria($input);
20 |         $this->engine->teardown($criteria);
21 | 
22 |         return 0;
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Console/InvalidArgumentGiven.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Console;
 6 | 
 7 | use InvalidArgumentException;
 8 | 
 9 | use function get_debug_type;
10 | use function sprintf;
11 | 
12 | final class InvalidArgumentGiven extends InvalidArgumentException
13 | {
14 |     public function __construct(
15 |         private readonly mixed $value,
16 |         private readonly string $need,
17 |     ) {
18 |         parent::__construct(
19 |             sprintf(
20 |                 'Invalid argument given: need type "%s" got "%s"',
21 |                 $need,
22 |                 get_debug_type($value),
23 |             ),
24 |         );
25 |     }
26 | 
27 |     public function value(): mixed
28 |     {
29 |         return $this->value;
30 |     }
31 | 
32 |     public function need(): string
33 |     {
34 |         return $this->need;
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/EventBus/Consumer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\EventBus;
 6 | 
 7 | use Patchlevel\EventSourcing\Message\Message;
 8 | 
 9 | interface Consumer
10 | {
11 |     public function consume(Message $message): void;
12 | }
13 | 


--------------------------------------------------------------------------------
/src/EventBus/DefaultConsumer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\EventBus;
 6 | 
 7 | use Patchlevel\EventSourcing\Message\Message;
 8 | use Psr\Log\LoggerInterface;
 9 | 
10 | use function sprintf;
11 | 
12 | final class DefaultConsumer implements Consumer
13 | {
14 |     public function __construct(
15 |         private readonly ListenerProvider $listenerProvider,
16 |         private readonly LoggerInterface|null $logger = null,
17 |     ) {
18 |     }
19 | 
20 |     public function consume(Message $message): void
21 |     {
22 |         $eventClass = $message->event()::class;
23 | 
24 |         $this->logger?->debug(sprintf(
25 |             'EventBus: Consume message "%s".',
26 |             $eventClass,
27 |         ));
28 | 
29 |         $listeners = $this->listenerProvider->listenersForEvent($eventClass);
30 | 
31 |         foreach ($listeners as $listener) {
32 |             $this->logger?->info(sprintf(
33 |                 'EventBus: Listener "%s" consume message with event "%s".',
34 |                 $listener->name(),
35 |                 $eventClass,
36 |             ));
37 | 
38 |             ($listener->callable())($message);
39 |         }
40 |     }
41 | 
42 |     /** @param iterable<object> $listeners */
43 |     public static function create(iterable $listeners = []): self
44 |     {
45 |         return new self(new AttributeListenerProvider($listeners));
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/src/EventBus/EventBus.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\EventBus;
 6 | 
 7 | use Patchlevel\EventSourcing\Message\Message;
 8 | 
 9 | interface EventBus
10 | {
11 |     public function dispatch(Message ...$messages): void;
12 | }
13 | 


--------------------------------------------------------------------------------
/src/EventBus/ListenerDescriptor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\EventBus;
 6 | 
 7 | use Closure;
 8 | use ReflectionFunction;
 9 | 
10 | use function method_exists;
11 | 
12 | final class ListenerDescriptor
13 | {
14 |     private readonly Closure $callable;
15 |     private readonly string $name;
16 | 
17 |     public function __construct(callable $callable)
18 |     {
19 |         $this->callable = $callable(...);
20 |         $this->name = self::closureName($this->callable);
21 |     }
22 | 
23 |     public function name(): string
24 |     {
25 |         return $this->name;
26 |     }
27 | 
28 |     public function callable(): callable
29 |     {
30 |         return $this->callable;
31 |     }
32 | 
33 |     private static function closureName(Closure $closure): string
34 |     {
35 |         $reflectionFunction = new ReflectionFunction($closure);
36 | 
37 |         if (method_exists($reflectionFunction, 'isAnonymous') && $reflectionFunction->isAnonymous()) {
38 |             return 'Closure';
39 |         }
40 | 
41 |         $closureThis = $reflectionFunction->getClosureThis();
42 | 
43 |         if (!$closureThis) {
44 |             $class = $reflectionFunction->getClosureCalledClass();
45 | 
46 |             return ($class ? $class->name . '::' : '') . $reflectionFunction->name;
47 |         }
48 | 
49 |         return $closureThis::class . '::' . $reflectionFunction->name;
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/src/EventBus/ListenerProvider.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\EventBus;
 6 | 
 7 | interface ListenerProvider
 8 | {
 9 |     /**
10 |      * @param class-string $eventClass
11 |      *
12 |      * @return iterable<ListenerDescriptor>
13 |      */
14 |     public function listenersForEvent(string $eventClass): iterable;
15 | }
16 | 


--------------------------------------------------------------------------------
/src/EventBus/Psr14EventBus.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\EventBus;
 6 | 
 7 | use Patchlevel\EventSourcing\Message\Message;
 8 | use Psr\EventDispatcher\EventDispatcherInterface;
 9 | 
10 | final class Psr14EventBus implements EventBus
11 | {
12 |     public function __construct(
13 |         private readonly EventDispatcherInterface $eventDispatcher,
14 |     ) {
15 |     }
16 | 
17 |     public function dispatch(Message ...$messages): void
18 |     {
19 |         foreach ($messages as $message) {
20 |             $this->eventDispatcher->dispatch($message);
21 |         }
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Message/HeaderNotFound.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Message;
 6 | 
 7 | use RuntimeException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class HeaderNotFound extends RuntimeException
12 | {
13 |     public function __construct(
14 |         public readonly string $name,
15 |     ) {
16 |         parent::__construct(sprintf('message header "%s" is not defined', $name));
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Message/Pipe.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Message;
 6 | 
 7 | use Generator;
 8 | use IteratorAggregate;
 9 | use Patchlevel\EventSourcing\Message\Translator\ChainTranslator;
10 | use Patchlevel\EventSourcing\Message\Translator\Translator;
11 | use Traversable;
12 | 
13 | use function array_values;
14 | use function iterator_to_array;
15 | 
16 | /** @implements IteratorAggregate<int, Message> */
17 | final class Pipe implements IteratorAggregate
18 | {
19 |     private Translator $translator;
20 | 
21 |     /** @param iterable<Message> $messages */
22 |     public function __construct(
23 |         private readonly iterable $messages,
24 |         Translator ...$translators,
25 |     ) {
26 |         $this->translator = new ChainTranslator($translators);
27 |     }
28 | 
29 |     /** @return Traversable<Message> */
30 |     public function getIterator(): Traversable
31 |     {
32 |         return $this->createGenerator(
33 |             $this->messages,
34 |             $this->translator,
35 |         );
36 |     }
37 | 
38 |     /** @return list<Message> */
39 |     public function toArray(): array
40 |     {
41 |         return array_values(
42 |             iterator_to_array($this->getIterator()),
43 |         );
44 |     }
45 | 
46 |     /**
47 |      * @param iterable<Message> $messages
48 |      *
49 |      * @return Generator<Message>
50 |      */
51 |     private function createGenerator(iterable $messages, Translator $translator): Generator
52 |     {
53 |         foreach ($messages as $message) {
54 |             foreach ($translator($message) as $translatedMessage) {
55 |                 yield $translatedMessage;
56 |             }
57 |         }
58 |     }
59 | }
60 | 


--------------------------------------------------------------------------------
/src/Message/Serializer/HeadersSerializer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Message\Serializer;
 6 | 
 7 | interface HeadersSerializer
 8 | {
 9 |     /**
10 |      * @param list<object>         $headers
11 |      * @param array<string, mixed> $options
12 |      */
13 |     public function serialize(array $headers, array $options = []): string;
14 | 
15 |     /**
16 |      * @param array<string, mixed> $options
17 |      *
18 |      * @return list<object>
19 |      */
20 |     public function deserialize(string $string, array $options = []): array;
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Message/Serializer/InvalidArgument.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Message\Serializer;
 6 | 
 7 | use RuntimeException;
 8 | 
 9 | final class InvalidArgument extends RuntimeException
10 | {
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Message/Translator/AggregateToStreamHeaderTranslator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Message\Translator;
 6 | 
 7 | use Patchlevel\EventSourcing\Aggregate\AggregateHeader;
 8 | use Patchlevel\EventSourcing\Message\Message;
 9 | use Patchlevel\EventSourcing\Store\Header\PlayheadHeader;
10 | use Patchlevel\EventSourcing\Store\Header\RecordedOnHeader;
11 | use Patchlevel\EventSourcing\Store\Header\StreamNameHeader;
12 | 
13 | final class AggregateToStreamHeaderTranslator implements Translator
14 | {
15 |     /** @return list<Message> */
16 |     public function __invoke(Message $message): array
17 |     {
18 |         if (!$message->hasHeader(AggregateHeader::class)) {
19 |             return [$message];
20 |         }
21 | 
22 |         $aggregateHeader = $message->header(AggregateHeader::class);
23 | 
24 |         return [
25 |             $message
26 |                 ->removeHeader(AggregateHeader::class)
27 |                 ->withHeader(new StreamNameHeader($aggregateHeader->streamName()))
28 |                 ->withHeader(new PlayheadHeader($aggregateHeader->playhead))
29 |                 ->withHeader(new RecordedOnHeader($aggregateHeader->recordedOn)),
30 |         ];
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Message/Translator/ChainTranslator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Message\Translator;
 6 | 
 7 | use Patchlevel\EventSourcing\Message\Message;
 8 | 
 9 | final class ChainTranslator implements Translator
10 | {
11 |     /** @param iterable<Translator> $translators */
12 |     public function __construct(
13 |         private readonly iterable $translators,
14 |     ) {
15 |     }
16 | 
17 |     /** @return list<Message> */
18 |     public function __invoke(Message $message): array
19 |     {
20 |         $messages = [$message];
21 | 
22 |         foreach ($this->translators as $middleware) {
23 |             $messages = $this->process($middleware, $messages);
24 |         }
25 | 
26 |         return $messages;
27 |     }
28 | 
29 |     /**
30 |      * @param list<Message> $messages
31 |      *
32 |      * @return list<Message>
33 |      */
34 |     private function process(Translator $translator, array $messages): array
35 |     {
36 |         $result = [];
37 | 
38 |         foreach ($messages as $message) {
39 |             $result = [...$result, ...$translator($message)];
40 |         }
41 | 
42 |         return $result;
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/src/Message/Translator/ClosureMiddleware.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Message\Translator;
 6 | 
 7 | use Closure;
 8 | use Patchlevel\EventSourcing\Message\Message;
 9 | 
10 | final class ClosureMiddleware implements Translator
11 | {
12 |     /** @param Closure(Message): list<Message> $callable */
13 |     public function __construct(
14 |         private readonly Closure $callable,
15 |     ) {
16 |     }
17 | 
18 |     /** @return list<Message> */
19 |     public function __invoke(Message $message): array
20 |     {
21 |         return ($this->callable)($message);
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Message/Translator/ExcludeEventTranslator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Message\Translator;
 6 | 
 7 | use Patchlevel\EventSourcing\Message\Message;
 8 | 
 9 | final class ExcludeEventTranslator implements Translator
10 | {
11 |     /** @param list<class-string> $classes */
12 |     public function __construct(
13 |         private readonly array $classes,
14 |     ) {
15 |     }
16 | 
17 |     /** @return list<Message> */
18 |     public function __invoke(Message $message): array
19 |     {
20 |         foreach ($this->classes as $class) {
21 |             if ($message->event() instanceof $class) {
22 |                 return [];
23 |             }
24 |         }
25 | 
26 |         return [$message];
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Message/Translator/ExcludeEventWithHeaderTranslator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Message\Translator;
 6 | 
 7 | use Patchlevel\EventSourcing\Message\Message;
 8 | 
 9 | final class ExcludeEventWithHeaderTranslator implements Translator
10 | {
11 |     /** @param class-string $header */
12 |     public function __construct(
13 |         private readonly string $header,
14 |     ) {
15 |     }
16 | 
17 |     /** @return list<Message> */
18 |     public function __invoke(Message $message): array
19 |     {
20 |         if ($message->hasHeader($this->header)) {
21 |             return [];
22 |         }
23 | 
24 |         return [$message];
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Message/Translator/FilterEventTranslator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Message\Translator;
 6 | 
 7 | use Patchlevel\EventSourcing\Message\Message;
 8 | 
 9 | final class FilterEventTranslator implements Translator
10 | {
11 |     /** @var callable(object $event):bool */
12 |     private $callable;
13 | 
14 |     /** @param callable(object $event):bool $callable */
15 |     public function __construct(callable $callable)
16 |     {
17 |         $this->callable = $callable;
18 |     }
19 | 
20 |     /** @return list<Message> */
21 |     public function __invoke(Message $message): array
22 |     {
23 |         $result = ($this->callable)($message->event());
24 | 
25 |         if ($result) {
26 |             return [$message];
27 |         }
28 | 
29 |         return [];
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/Message/Translator/IncludeEventTranslator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Message\Translator;
 6 | 
 7 | use Patchlevel\EventSourcing\Message\Message;
 8 | 
 9 | final class IncludeEventTranslator implements Translator
10 | {
11 |     /** @param list<class-string> $classes */
12 |     public function __construct(
13 |         private readonly array $classes,
14 |     ) {
15 |     }
16 | 
17 |     /** @return list<Message> */
18 |     public function __invoke(Message $message): array
19 |     {
20 |         foreach ($this->classes as $class) {
21 |             if ($message->event() instanceof $class) {
22 |                 return [$message];
23 |             }
24 |         }
25 | 
26 |         return [];
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Message/Translator/IncludeEventWithHeaderTranslator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Message\Translator;
 6 | 
 7 | use Patchlevel\EventSourcing\Message\Message;
 8 | 
 9 | final class IncludeEventWithHeaderTranslator implements Translator
10 | {
11 |     /** @param class-string $header */
12 |     public function __construct(
13 |         private readonly string $header,
14 |     ) {
15 |     }
16 | 
17 |     /** @return list<Message> */
18 |     public function __invoke(Message $message): array
19 |     {
20 |         if ($message->hasHeader($this->header)) {
21 |             return [$message];
22 |         }
23 | 
24 |         return [];
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Message/Translator/ReplaceEventTranslator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Message\Translator;
 6 | 
 7 | use Patchlevel\EventSourcing\Message\Message;
 8 | 
 9 | /** @template T of object */
10 | final class ReplaceEventTranslator implements Translator
11 | {
12 |     /** @var callable(T $event):object */
13 |     private $callable;
14 | 
15 |     /**
16 |      * @param class-string<T> $class
17 |      * @param callable(T      $event):object $callable
18 |      */
19 |     public function __construct(
20 |         private readonly string $class,
21 |         callable $callable,
22 |     ) {
23 |         $this->callable = $callable;
24 |     }
25 | 
26 |     /** @return list<Message> */
27 |     public function __invoke(Message $message): array
28 |     {
29 |         $event = $message->event();
30 | 
31 |         if (!$event instanceof $this->class) {
32 |             return [$message];
33 |         }
34 | 
35 |         $callable = $this->callable;
36 |         $newEvent = $callable($event);
37 | 
38 |         return [Message::createWithHeaders($newEvent, $message->headers())];
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Message/Translator/Translator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Message\Translator;
 6 | 
 7 | use Patchlevel\EventSourcing\Message\Message;
 8 | 
 9 | interface Translator
10 | {
11 |     /** @return list<Message> */
12 |     public function __invoke(Message $message): array;
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Message/Translator/UntilEventTranslator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Message\Translator;
 6 | 
 7 | use DateTimeImmutable;
 8 | use Patchlevel\EventSourcing\Aggregate\AggregateHeader;
 9 | use Patchlevel\EventSourcing\Message\Message;
10 | use Patchlevel\EventSourcing\Store\Header\RecordedOnHeader;
11 | 
12 | final class UntilEventTranslator implements Translator
13 | {
14 |     public function __construct(
15 |         private readonly DateTimeImmutable $until,
16 |     ) {
17 |     }
18 | 
19 |     /** @return list<Message> */
20 |     public function __invoke(Message $message): array
21 |     {
22 |         if ($message->hasHeader(AggregateHeader::class)) {
23 |             $header = $message->header(AggregateHeader::class);
24 | 
25 |             if ($header->recordedOn < $this->until) {
26 |                 return [$message];
27 |             }
28 | 
29 |             return [];
30 |         }
31 | 
32 |         if ($message->hasHeader(RecordedOnHeader::class)) {
33 |             $header = $message->header(RecordedOnHeader::class);
34 | 
35 |             if ($header->recordedOn < $this->until) {
36 |                 return [$message];
37 |             }
38 | 
39 |             return [];
40 |         }
41 | 
42 |         return [$message];
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/src/Metadata/AggregateRoot/AggregateRootAlreadyInRegistry.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\AggregateRoot;
 6 | 
 7 | use Patchlevel\EventSourcing\Metadata\MetadataException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class AggregateRootAlreadyInRegistry extends MetadataException
12 | {
13 |     public function __construct(string $aggregateName)
14 |     {
15 |         parent::__construct(sprintf(
16 |             'The aggregate name "%s" is already used in the registry. Maybe you defined 2 aggregates with the same name.',
17 |             $aggregateName,
18 |         ));
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Metadata/AggregateRoot/AggregateRootClassNotRegistered.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\AggregateRoot;
 6 | 
 7 | use Patchlevel\EventSourcing\Metadata\MetadataException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class AggregateRootClassNotRegistered extends MetadataException
12 | {
13 |     public function __construct(string $aggregateRootClass)
14 |     {
15 |         parent::__construct(
16 |             sprintf(
17 |                 'Aggregate root class "%s" is not registered',
18 |                 $aggregateRootClass,
19 |             ),
20 |         );
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Metadata/AggregateRoot/AggregateRootIdNotFound.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\AggregateRoot;
 6 | 
 7 | use RuntimeException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class AggregateRootIdNotFound extends RuntimeException
12 | {
13 |     public function __construct(string $aggregateRootClass)
14 |     {
15 |         parent::__construct(sprintf('class %s has no property marked as aggregate root id', $aggregateRootClass));
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Metadata/AggregateRoot/AggregateRootMetadata.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\AggregateRoot;
 6 | 
 7 | use Patchlevel\EventSourcing\Aggregate\AggregateRoot;
 8 | 
 9 | use function str_contains;
10 | use function str_replace;
11 | 
12 | /** @template T of AggregateRoot */
13 | final class AggregateRootMetadata
14 | {
15 |     public readonly string $streamName;
16 | 
17 |     public function __construct(
18 |         /** @var class-string<T> */
19 |         public readonly string $className,
20 |         public readonly string $name,
21 |         public readonly string $idProperty,
22 |         /** @var array<class-string, string> */
23 |         public readonly array $applyMethods,
24 |         /** @var array<class-string, true> */
25 |         public readonly array $suppressEvents,
26 |         public readonly bool $suppressAll,
27 |         public readonly Snapshot|null $snapshot,
28 |         /** @var list<string> */
29 |         public readonly array $childAggregates = [],
30 |         string|null $streamName = null,
31 |     ) {
32 |         $this->streamName = $streamName ?? $this->name . '-{id}';
33 |     }
34 | 
35 |     public function streamName(string|null $aggregateId = null): string
36 |     {
37 |         if ($aggregateId === null) {
38 |             if (str_contains($this->streamName, '{id}')) {
39 |                 throw new MissingAggregateIdForStreamName($this->streamName);
40 |             }
41 | 
42 |             return $this->streamName;
43 |         }
44 | 
45 |         return str_replace('{id}', $aggregateId, $this->streamName);
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/src/Metadata/AggregateRoot/AggregateRootMetadataAwareMetadataFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\AggregateRoot;
 6 | 
 7 | use Patchlevel\EventSourcing\Aggregate\AggregateRoot;
 8 | use Patchlevel\EventSourcing\Aggregate\AggregateRootMetadataAware;
 9 | 
10 | use function is_a;
11 | 
12 | final class AggregateRootMetadataAwareMetadataFactory implements AggregateRootMetadataFactory
13 | {
14 |     /**
15 |      * @param class-string<T> $aggregate
16 |      *
17 |      * @return AggregateRootMetadata<T>
18 |      *
19 |      * @template T of AggregateRoot
20 |      */
21 |     public function metadata(string $aggregate): AggregateRootMetadata
22 |     {
23 |         if (!is_a($aggregate, AggregateRootMetadataAware::class, true)) {
24 |             throw new AggregateWithoutMetadataAware($aggregate);
25 |         }
26 | 
27 |         return $aggregate::metadata();
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Metadata/AggregateRoot/AggregateRootMetadataFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\AggregateRoot;
 6 | 
 7 | use Patchlevel\EventSourcing\Aggregate\AggregateRoot;
 8 | 
 9 | interface AggregateRootMetadataFactory
10 | {
11 |     /**
12 |      * @param class-string<T> $aggregate
13 |      *
14 |      * @return AggregateRootMetadata<T>
15 |      *
16 |      * @template T of AggregateRoot
17 |      */
18 |     public function metadata(string $aggregate): AggregateRootMetadata;
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Metadata/AggregateRoot/AggregateRootNameNotRegistered.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\AggregateRoot;
 6 | 
 7 | use Patchlevel\EventSourcing\Metadata\MetadataException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class AggregateRootNameNotRegistered extends MetadataException
12 | {
13 |     public function __construct(string $name)
14 |     {
15 |         parent::__construct(
16 |             sprintf(
17 |                 'Aggregate root name "%s" is not registered',
18 |                 $name,
19 |             ),
20 |         );
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Metadata/AggregateRoot/AggregateRootRegistryFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\AggregateRoot;
 6 | 
 7 | interface AggregateRootRegistryFactory
 8 | {
 9 |     /** @param list<string> $paths */
10 |     public function create(array $paths): AggregateRootRegistry;
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Metadata/AggregateRoot/AggregateWithoutMetadataAware.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\AggregateRoot;
 6 | 
 7 | use Patchlevel\EventSourcing\Metadata\MetadataException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class AggregateWithoutMetadataAware extends MetadataException
12 | {
13 |     /** @param class-string $aggregateRootClass */
14 |     public function __construct(string $aggregateRootClass)
15 |     {
16 |         parent::__construct(sprintf('The class "%s" does not implements AggregateRootMetadataAware', $aggregateRootClass));
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Metadata/AggregateRoot/ArgumentTypeIsMissing.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\AggregateRoot;
 6 | 
 7 | use Patchlevel\EventSourcing\Metadata\MetadataException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class ArgumentTypeIsMissing extends MetadataException
12 | {
13 |     public function __construct(string $methodName)
14 |     {
15 |         parent::__construct(sprintf('The method [%s] is no type specified.', $methodName));
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Metadata/AggregateRoot/ArgumentTypeIsNotAClass.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\AggregateRoot;
 6 | 
 7 | use Patchlevel\EventSourcing\Metadata\MetadataException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class ArgumentTypeIsNotAClass extends MetadataException
12 | {
13 |     public function __construct(string $methodName, string $type)
14 |     {
15 |         parent::__construct(sprintf('The type [%s] is not a valid class for method [%s].', $type, $methodName));
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Metadata/AggregateRoot/AttributeAggregateRootRegistryFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\AggregateRoot;
 6 | 
 7 | use Patchlevel\EventSourcing\Aggregate\AggregateRoot;
 8 | use Patchlevel\EventSourcing\Attribute\Aggregate;
 9 | use Patchlevel\EventSourcing\Metadata\ClassFinder;
10 | use ReflectionClass;
11 | 
12 | use function array_key_exists;
13 | use function count;
14 | use function is_subclass_of;
15 | 
16 | final class AttributeAggregateRootRegistryFactory implements AggregateRootRegistryFactory
17 | {
18 |     /** @param list<string> $paths */
19 |     public function create(array $paths): AggregateRootRegistry
20 |     {
21 |         $classes = (new ClassFinder())->findClassNames($paths);
22 | 
23 |         $result = [];
24 | 
25 |         foreach ($classes as $class) {
26 |             $reflection = new ReflectionClass($class);
27 |             $attributes = $reflection->getAttributes(Aggregate::class);
28 | 
29 |             if (count($attributes) === 0) {
30 |                 continue;
31 |             }
32 | 
33 |             if (!is_subclass_of($class, AggregateRoot::class)) {
34 |                 throw new NoAggregateRoot($class);
35 |             }
36 | 
37 |             $aggregateName = $attributes[0]->newInstance()->name;
38 | 
39 |             if (array_key_exists($aggregateName, $result)) {
40 |                 throw new AggregateRootAlreadyInRegistry($aggregateName);
41 |             }
42 | 
43 |             $result[$aggregateName] = $class;
44 |         }
45 | 
46 |         return new AggregateRootRegistry($result);
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/src/Metadata/AggregateRoot/ClassIsNotAnAggregate.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\AggregateRoot;
 6 | 
 7 | use Patchlevel\EventSourcing\Metadata\MetadataException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class ClassIsNotAnAggregate extends MetadataException
12 | {
13 |     /** @param class-string $class */
14 |     public function __construct(string $class)
15 |     {
16 |         parent::__construct(sprintf('class %s is not an aggregate root', $class));
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Metadata/AggregateRoot/DuplicateApplyMethod.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\AggregateRoot;
 6 | 
 7 | use Patchlevel\EventSourcing\Aggregate\AggregateRoot;
 8 | use Patchlevel\EventSourcing\Metadata\MetadataException;
 9 | 
10 | use function sprintf;
11 | 
12 | final class DuplicateApplyMethod extends MetadataException
13 | {
14 |     /**
15 |      * @param class-string<AggregateRoot> $aggregateRootClass
16 |      * @param class-string                $event
17 |      */
18 |     public function __construct(string $aggregateRootClass, string $event, string $fistMethod, string $secondMethod)
19 |     {
20 |         parent::__construct(
21 |             sprintf(
22 |                 'Two methods "%s" and "%s" on the aggregate "%s" want to apply the same event "%s". Only one method can apply an event.',
23 |                 $fistMethod,
24 |                 $secondMethod,
25 |                 $aggregateRootClass,
26 |                 $event,
27 |             ),
28 |         );
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Metadata/AggregateRoot/DuplicateEmptyApplyAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\AggregateRoot;
 6 | 
 7 | use Patchlevel\EventSourcing\Metadata\MetadataException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class DuplicateEmptyApplyAttribute extends MetadataException
12 | {
13 |     public function __construct(string $methodName)
14 |     {
15 |         parent::__construct(sprintf(
16 |             'The method [%s] has multiple apply attributes given without an event name which is not allowed.',
17 |             $methodName,
18 |         ));
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Metadata/AggregateRoot/MissingAggregateIdForStreamName.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\AggregateRoot;
 6 | 
 7 | use Patchlevel\EventSourcing\Metadata\MetadataException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class MissingAggregateIdForStreamName extends MetadataException
12 | {
13 |     public function __construct(string $streamName)
14 |     {
15 |         parent::__construct(sprintf('Missing aggregate id for stream name "%s"', $streamName));
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Metadata/AggregateRoot/MissingDataSubjectId.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\AggregateRoot;
 6 | 
 7 | use Patchlevel\EventSourcing\Metadata\MetadataException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class MissingDataSubjectId extends MetadataException
12 | {
13 |     /** @param class-string $class */
14 |     public function __construct(string $class)
15 |     {
16 |         parent::__construct(
17 |             sprintf('Personal data cannot used without a subject id. Please provide a subject id for %s.', $class),
18 |         );
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Metadata/AggregateRoot/MixedApplyAttributeUsage.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\AggregateRoot;
 6 | 
 7 | use Patchlevel\EventSourcing\Metadata\MetadataException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class MixedApplyAttributeUsage extends MetadataException
12 | {
13 |     public function __construct(string $methodName)
14 |     {
15 |         parent::__construct(sprintf(
16 |             'The method [%s] has at least one apply attribute with an event name and one without which is not allowed.',
17 |             $methodName,
18 |         ));
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Metadata/AggregateRoot/MultipleDataSubjectId.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\AggregateRoot;
 6 | 
 7 | use Patchlevel\EventSourcing\Metadata\MetadataException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class MultipleDataSubjectId extends MetadataException
12 | {
13 |     public function __construct(string $firstProperty, string $secondProperty)
14 |     {
15 |         parent::__construct(
16 |             sprintf(
17 |                 'Multiple data subject id found: %s and %s.',
18 |                 $firstProperty,
19 |                 $secondProperty,
20 |             ),
21 |         );
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Metadata/AggregateRoot/NoAggregateRoot.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\AggregateRoot;
 6 | 
 7 | use Patchlevel\EventSourcing\Metadata\MetadataException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class NoAggregateRoot extends MetadataException
12 | {
13 |     /** @param class-string $aggregateRootClass */
14 |     public function __construct(string $aggregateRootClass)
15 |     {
16 |         parent::__construct(sprintf('The class "%s" does not implement AggregateRoot', $aggregateRootClass));
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Metadata/AggregateRoot/Psr16AggregateRootMetadataFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\AggregateRoot;
 6 | 
 7 | use Patchlevel\EventSourcing\Aggregate\AggregateRoot;
 8 | use Psr\SimpleCache\CacheInterface;
 9 | 
10 | final class Psr16AggregateRootMetadataFactory implements AggregateRootMetadataFactory
11 | {
12 |     public function __construct(
13 |         private readonly AggregateRootMetadataFactory $aggregateRootMetadataFactory,
14 |         private readonly CacheInterface $cache,
15 |     ) {
16 |     }
17 | 
18 |     /**
19 |      * @param class-string<T> $aggregate
20 |      *
21 |      * @return AggregateRootMetadata<T>
22 |      *
23 |      * @template T of AggregateRoot
24 |      */
25 |     public function metadata(string $aggregate): AggregateRootMetadata
26 |     {
27 |         /** @var ?AggregateRootMetadata<T> $metadata */
28 |         $metadata = $this->cache->get($aggregate);
29 | 
30 |         if ($metadata !== null) {
31 |             return $metadata;
32 |         }
33 | 
34 |         $metadata = $this->aggregateRootMetadataFactory->metadata($aggregate);
35 | 
36 |         $this->cache->set($aggregate, $metadata);
37 | 
38 |         return $metadata;
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Metadata/AggregateRoot/Psr16AggregateRootRegistryFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\AggregateRoot;
 6 | 
 7 | use Psr\SimpleCache\CacheInterface;
 8 | 
 9 | final class Psr16AggregateRootRegistryFactory implements AggregateRootRegistryFactory
10 | {
11 |     private const CACHE_KEY = 'aggregate_root_registry';
12 | 
13 |     public function __construct(
14 |         private readonly AggregateRootRegistryFactory $aggregateRootRegistryFactory,
15 |         private readonly CacheInterface $cache,
16 |     ) {
17 |     }
18 | 
19 |     /** @param list<string> $paths */
20 |     public function create(array $paths): AggregateRootRegistry
21 |     {
22 |         /** @var ?AggregateRootRegistry $registry */
23 |         $registry = $this->cache->get(self::CACHE_KEY);
24 | 
25 |         if ($registry !== null) {
26 |             return $registry;
27 |         }
28 | 
29 |         $registry = $this->aggregateRootRegistryFactory->create($paths);
30 | 
31 |         $this->cache->set(self::CACHE_KEY, $registry);
32 | 
33 |         return $registry;
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/Metadata/AggregateRoot/Psr6AggregateRootMetadataFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\AggregateRoot;
 6 | 
 7 | use Patchlevel\EventSourcing\Aggregate\AggregateRoot;
 8 | use Psr\Cache\CacheItemPoolInterface;
 9 | 
10 | final class Psr6AggregateRootMetadataFactory implements AggregateRootMetadataFactory
11 | {
12 |     public function __construct(
13 |         private readonly AggregateRootMetadataFactory $aggregateRootMetadataFactory,
14 |         private readonly CacheItemPoolInterface $cache,
15 |     ) {
16 |     }
17 | 
18 |     /**
19 |      * @param class-string<T> $aggregate
20 |      *
21 |      * @return AggregateRootMetadata<T>
22 |      *
23 |      * @template T of AggregateRoot
24 |      */
25 |     public function metadata(string $aggregate): AggregateRootMetadata
26 |     {
27 |         $item = $this->cache->getItem($aggregate);
28 | 
29 |         if ($item->isHit()) {
30 |             /** @var AggregateRootMetadata<T> $data */
31 |             $data = $item->get();
32 | 
33 |             return $data;
34 |         }
35 | 
36 |         $metadata = $this->aggregateRootMetadataFactory->metadata($aggregate);
37 | 
38 |         $item->set($metadata);
39 |         $this->cache->save($item);
40 | 
41 |         return $metadata;
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/src/Metadata/AggregateRoot/Psr6AggregateRootRegistryFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\AggregateRoot;
 6 | 
 7 | use Psr\Cache\CacheItemPoolInterface;
 8 | 
 9 | use function assert;
10 | 
11 | final class Psr6AggregateRootRegistryFactory implements AggregateRootRegistryFactory
12 | {
13 |     private const CACHE_KEY = 'aggregate_root_registry';
14 | 
15 |     public function __construct(
16 |         private readonly AggregateRootRegistryFactory $aggregateRootRegistryFactory,
17 |         private readonly CacheItemPoolInterface $cache,
18 |     ) {
19 |     }
20 | 
21 |     /** @param list<string> $paths */
22 |     public function create(array $paths): AggregateRootRegistry
23 |     {
24 |         $item = $this->cache->getItem(self::CACHE_KEY);
25 | 
26 |         if ($item->isHit()) {
27 |             $data = $item->get();
28 |             assert($data instanceof AggregateRootRegistry);
29 | 
30 |             return $data;
31 |         }
32 | 
33 |         $registry = $this->aggregateRootRegistryFactory->create($paths);
34 | 
35 |         $item->set($registry);
36 |         $this->cache->save($item);
37 | 
38 |         return $registry;
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Metadata/AggregateRoot/Snapshot.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\AggregateRoot;
 6 | 
 7 | final class Snapshot
 8 | {
 9 |     public function __construct(
10 |         public readonly string $store,
11 |         public readonly int|null $batch = null,
12 |         public readonly string|null $version = null,
13 |     ) {
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Metadata/AggregateRoot/SubjectIdAndPersonalDataConflict.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\AggregateRoot;
 6 | 
 7 | use Patchlevel\EventSourcing\Metadata\MetadataException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class SubjectIdAndPersonalDataConflict extends MetadataException
12 | {
13 |     /** @param class-string $class */
14 |     public function __construct(string $class, string $property)
15 |     {
16 |         parent::__construct(
17 |             sprintf(
18 |                 'Personal data cannot be used as a subject id. Fix subject id for %s::%s.',
19 |                 $class,
20 |                 $property,
21 |             ),
22 |         );
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Metadata/Event/AttributeEventMetadataFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\Event;
 6 | 
 7 | use Patchlevel\EventSourcing\Attribute\Event;
 8 | use Patchlevel\EventSourcing\Attribute\SplitStream;
 9 | use ReflectionClass;
10 | 
11 | use function array_key_exists;
12 | use function count;
13 | 
14 | final class AttributeEventMetadataFactory implements EventMetadataFactory
15 | {
16 |     /** @var array<class-string, EventMetadata> */
17 |     private array $eventMetadata = [];
18 | 
19 |     /** @param class-string $event */
20 |     public function metadata(string $event): EventMetadata
21 |     {
22 |         if (array_key_exists($event, $this->eventMetadata)) {
23 |             return $this->eventMetadata[$event];
24 |         }
25 | 
26 |         $reflectionClass = new ReflectionClass($event);
27 | 
28 |         $attributeReflectionList = $reflectionClass->getAttributes(Event::class);
29 | 
30 |         if (!$attributeReflectionList) {
31 |             throw new ClassIsNotAnEvent($event);
32 |         }
33 | 
34 |         $eventAttribute = $attributeReflectionList[0]->newInstance();
35 | 
36 |         $this->eventMetadata[$event] = new EventMetadata(
37 |             $eventAttribute->name,
38 |             $this->splitStream($reflectionClass),
39 |             $eventAttribute->aliases,
40 |         );
41 | 
42 |         return $this->eventMetadata[$event];
43 |     }
44 | 
45 |     private function splitStream(ReflectionClass $reflectionClass): bool
46 |     {
47 |         return count($reflectionClass->getAttributes(SplitStream::class)) !== 0;
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/src/Metadata/Event/AttributeEventRegistryFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\Event;
 6 | 
 7 | use Patchlevel\EventSourcing\Attribute\Event;
 8 | use Patchlevel\EventSourcing\Metadata\ClassFinder;
 9 | use ReflectionClass;
10 | 
11 | use function array_key_exists;
12 | use function count;
13 | 
14 | final class AttributeEventRegistryFactory implements EventRegistryFactory
15 | {
16 |     /** @param list<string> $paths */
17 |     public function create(array $paths): EventRegistry
18 |     {
19 |         $classes = (new ClassFinder())->findClassNames($paths);
20 | 
21 |         $result = [];
22 | 
23 |         foreach ($classes as $class) {
24 |             $reflection = new ReflectionClass($class);
25 |             $attributes = $reflection->getAttributes(Event::class);
26 | 
27 |             if (count($attributes) === 0) {
28 |                 continue;
29 |             }
30 | 
31 |             $attribute = $attributes[0]->newInstance();
32 | 
33 |             if (array_key_exists($attribute->name, $result)) {
34 |                 throw new EventAlreadyInRegistry($attribute->name);
35 |             }
36 | 
37 |             $result[$attribute->name] = $class;
38 | 
39 |             foreach ($attribute->aliases as $alias) {
40 |                 if (array_key_exists($alias, $result)) {
41 |                     throw new EventAlreadyInRegistry($alias);
42 |                 }
43 | 
44 |                 $result[$alias] = $class;
45 |             }
46 |         }
47 | 
48 |         return new EventRegistry($result);
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/src/Metadata/Event/ClassIsNotAnEvent.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\Event;
 6 | 
 7 | use Patchlevel\EventSourcing\Metadata\MetadataException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class ClassIsNotAnEvent extends MetadataException
12 | {
13 |     /** @param class-string $class */
14 |     public function __construct(string $class)
15 |     {
16 |         parent::__construct(sprintf('class %s is not an event', $class));
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Metadata/Event/EventAlreadyInRegistry.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\Event;
 6 | 
 7 | use Patchlevel\EventSourcing\Metadata\MetadataException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class EventAlreadyInRegistry extends MetadataException
12 | {
13 |     public function __construct(string $eventName)
14 |     {
15 |         parent::__construct(sprintf(
16 |             'The event name "%s" is already used in the registry. Maybe you defined 2 events with the same name.',
17 |             $eventName,
18 |         ));
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Metadata/Event/EventClassNotRegistered.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\Event;
 6 | 
 7 | use Patchlevel\EventSourcing\Metadata\MetadataException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class EventClassNotRegistered extends MetadataException
12 | {
13 |     public function __construct(string $eventClass)
14 |     {
15 |         parent::__construct(
16 |             sprintf(
17 |                 'Event class "%s" is not registered',
18 |                 $eventClass,
19 |             ),
20 |         );
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Metadata/Event/EventMetadata.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\Event;
 6 | 
 7 | final class EventMetadata
 8 | {
 9 |     public function __construct(
10 |         public readonly string $name,
11 |         public readonly bool $splitStream = false,
12 |         /** @var list<string> */
13 |         public readonly array $aliases = [],
14 |     ) {
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Metadata/Event/EventMetadataFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\Event;
 6 | 
 7 | interface EventMetadataFactory
 8 | {
 9 |     /** @param class-string $event */
10 |     public function metadata(string $event): EventMetadata;
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Metadata/Event/EventNameNotRegistered.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\Event;
 6 | 
 7 | use Patchlevel\EventSourcing\Metadata\MetadataException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class EventNameNotRegistered extends MetadataException
12 | {
13 |     public function __construct(string $name)
14 |     {
15 |         parent::__construct(
16 |             sprintf(
17 |                 'Event name "%s" is not registered',
18 |                 $name,
19 |             ),
20 |         );
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Metadata/Event/EventRegistryFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\Event;
 6 | 
 7 | interface EventRegistryFactory
 8 | {
 9 |     /** @param list<string> $paths */
10 |     public function create(array $paths): EventRegistry;
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Metadata/Event/MissingDataSubjectId.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\Event;
 6 | 
 7 | use Patchlevel\EventSourcing\Metadata\MetadataException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class MissingDataSubjectId extends MetadataException
12 | {
13 |     /** @param class-string $class */
14 |     public function __construct(string $class)
15 |     {
16 |         parent::__construct(
17 |             sprintf('Personal data cannot used without a subject id. Please provide a subject id for %s.', $class),
18 |         );
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Metadata/Event/MultipleDataSubjectId.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\Event;
 6 | 
 7 | use Patchlevel\EventSourcing\Metadata\MetadataException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class MultipleDataSubjectId extends MetadataException
12 | {
13 |     public function __construct(string $firstProperty, string $secondProperty)
14 |     {
15 |         parent::__construct(
16 |             sprintf(
17 |                 'Multiple data subject id found: %s and %s.',
18 |                 $firstProperty,
19 |                 $secondProperty,
20 |             ),
21 |         );
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Metadata/Event/Psr16EventMetadataFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\Event;
 6 | 
 7 | use Psr\SimpleCache\CacheInterface;
 8 | 
 9 | final class Psr16EventMetadataFactory implements EventMetadataFactory
10 | {
11 |     public function __construct(
12 |         private readonly EventMetadataFactory $eventMetadataFactory,
13 |         private readonly CacheInterface $cache,
14 |     ) {
15 |     }
16 | 
17 |     /** @param class-string $event */
18 |     public function metadata(string $event): EventMetadata
19 |     {
20 |         /** @var ?EventMetadata $metadata */
21 |         $metadata = $this->cache->get($event);
22 | 
23 |         if ($metadata !== null) {
24 |             return $metadata;
25 |         }
26 | 
27 |         $metadata = $this->eventMetadataFactory->metadata($event);
28 | 
29 |         $this->cache->set($event, $metadata);
30 | 
31 |         return $metadata;
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/Metadata/Event/Psr16EventRegistryFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\Event;
 6 | 
 7 | use Psr\SimpleCache\CacheInterface;
 8 | 
 9 | final class Psr16EventRegistryFactory implements EventRegistryFactory
10 | {
11 |     private const CACHE_KEY = 'event_registry';
12 | 
13 |     public function __construct(
14 |         private readonly EventRegistryFactory $eventRegistryFactory,
15 |         private readonly CacheInterface $cache,
16 |     ) {
17 |     }
18 | 
19 |     /** @param list<string> $paths */
20 |     public function create(array $paths): EventRegistry
21 |     {
22 |         /** @var ?EventRegistry $registry */
23 |         $registry = $this->cache->get(self::CACHE_KEY);
24 | 
25 |         if ($registry !== null) {
26 |             return $registry;
27 |         }
28 | 
29 |         $registry = $this->eventRegistryFactory->create($paths);
30 | 
31 |         $this->cache->set(self::CACHE_KEY, $registry);
32 | 
33 |         return $registry;
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/Metadata/Event/Psr6EventMetadataFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\Event;
 6 | 
 7 | use Psr\Cache\CacheItemPoolInterface;
 8 | 
 9 | use function assert;
10 | 
11 | final class Psr6EventMetadataFactory implements EventMetadataFactory
12 | {
13 |     public function __construct(
14 |         private readonly EventMetadataFactory $eventMetadataFactory,
15 |         private readonly CacheItemPoolInterface $cache,
16 |     ) {
17 |     }
18 | 
19 |     /** @param class-string $event */
20 |     public function metadata(string $event): EventMetadata
21 |     {
22 |         $item = $this->cache->getItem($event);
23 | 
24 |         if ($item->isHit()) {
25 |             $data = $item->get();
26 |             assert($data instanceof EventMetadata);
27 | 
28 |             return $data;
29 |         }
30 | 
31 |         $metadata = $this->eventMetadataFactory->metadata($event);
32 | 
33 |         $item->set($metadata);
34 |         $this->cache->save($item);
35 | 
36 |         return $metadata;
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/Metadata/Event/Psr6EventRegistryFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\Event;
 6 | 
 7 | use Psr\Cache\CacheItemPoolInterface;
 8 | 
 9 | use function assert;
10 | 
11 | final class Psr6EventRegistryFactory implements EventRegistryFactory
12 | {
13 |     private const CACHE_KEY = 'event_registry';
14 | 
15 |     public function __construct(
16 |         private readonly EventRegistryFactory $eventRegistryFactory,
17 |         private readonly CacheItemPoolInterface $cache,
18 |     ) {
19 |     }
20 | 
21 |     /** @param list<string> $paths */
22 |     public function create(array $paths): EventRegistry
23 |     {
24 |         $item = $this->cache->getItem(self::CACHE_KEY);
25 | 
26 |         if ($item->isHit()) {
27 |             $data = $item->get();
28 |             assert($data instanceof EventRegistry);
29 | 
30 |             return $data;
31 |         }
32 | 
33 |         $registry = $this->eventRegistryFactory->create($paths);
34 | 
35 |         $item->set($registry);
36 |         $this->cache->save($item);
37 | 
38 |         return $registry;
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Metadata/Event/SubjectIdAndPersonalDataConflict.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\Event;
 6 | 
 7 | use Patchlevel\EventSourcing\Metadata\MetadataException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class SubjectIdAndPersonalDataConflict extends MetadataException
12 | {
13 |     /** @param class-string $class */
14 |     public function __construct(string $class, string $property)
15 |     {
16 |         parent::__construct(
17 |             sprintf(
18 |                 'Personal data cannot be used as a subject id. Fix subject id for %s::%s.',
19 |                 $class,
20 |                 $property,
21 |             ),
22 |         );
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Metadata/Message/AttributeMessageHeaderRegistryFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\Message;
 6 | 
 7 | use Patchlevel\EventSourcing\Attribute\Header;
 8 | use Patchlevel\EventSourcing\Metadata\ClassFinder;
 9 | use ReflectionClass;
10 | 
11 | use function count;
12 | 
13 | final class AttributeMessageHeaderRegistryFactory implements MessageHeaderRegistryFactory
14 | {
15 |     /** @param list<string> $paths */
16 |     public function create(array $paths): MessageHeaderRegistry
17 |     {
18 |         $classes = (new ClassFinder())->findClassNames($paths);
19 | 
20 |         $result = [];
21 | 
22 |         foreach ($classes as $class) {
23 |             $reflection = new ReflectionClass($class);
24 |             $attributes = $reflection->getAttributes(Header::class);
25 | 
26 |             if (count($attributes) === 0) {
27 |                 continue;
28 |             }
29 | 
30 |             $aggregateName = $attributes[0]->newInstance()->name;
31 |             $result[$aggregateName] = $class;
32 |         }
33 | 
34 |         return MessageHeaderRegistry::createWithInternalHeaders($result);
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/Metadata/Message/HeaderClassNotRegistered.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\Message;
 6 | 
 7 | use Patchlevel\EventSourcing\Metadata\MetadataException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class HeaderClassNotRegistered extends MetadataException
12 | {
13 |     public function __construct(string $headerClass)
14 |     {
15 |         parent::__construct(
16 |             sprintf(
17 |                 'Header class "%s" is not registered',
18 |                 $headerClass,
19 |             ),
20 |         );
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Metadata/Message/HeaderNameNotRegistered.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\Message;
 6 | 
 7 | use Patchlevel\EventSourcing\Metadata\MetadataException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class HeaderNameNotRegistered extends MetadataException
12 | {
13 |     public function __construct(string $name)
14 |     {
15 |         parent::__construct(
16 |             sprintf(
17 |                 'Header name "%s" is not registered',
18 |                 $name,
19 |             ),
20 |         );
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Metadata/Message/MessageHeaderRegistryFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\Message;
 6 | 
 7 | interface MessageHeaderRegistryFactory
 8 | {
 9 |     /** @param list<string> $paths */
10 |     public function create(array $paths): MessageHeaderRegistry;
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Metadata/MetadataException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata;
 6 | 
 7 | use RuntimeException;
 8 | 
 9 | abstract class MetadataException extends RuntimeException
10 | {
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Metadata/Subscriber/ArgumentMetadata.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\Subscriber;
 6 | 
 7 | final class ArgumentMetadata
 8 | {
 9 |     public function __construct(
10 |         public readonly string $name,
11 |         public readonly string $type,
12 |     ) {
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Metadata/Subscriber/ArgumentTypeNotSupported.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\Subscriber;
 6 | 
 7 | use Patchlevel\EventSourcing\Metadata\MetadataException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class ArgumentTypeNotSupported extends MetadataException
12 | {
13 |     public static function missingType(string $class, string $method, string $argumentName): self
14 |     {
15 |         return new self(
16 |             sprintf(
17 |                 'Argument type for method "%s" in class "%s" is not supported. Argument "%s" must have a type.',
18 |                 $method,
19 |                 $class,
20 |                 $argumentName,
21 |             ),
22 |         );
23 |     }
24 | 
25 |     public static function onlyNamedTypeSupported(string $class, string $method, string $argumentName): self
26 |     {
27 |         return new self(
28 |             sprintf(
29 |                 'Argument type for method "%s" in class "%s" is not supported. Argument "%s" must not have a union or intersection type.',
30 |                 $method,
31 |                 $class,
32 |                 $argumentName,
33 |             ),
34 |         );
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/Metadata/Subscriber/ClassIsNotASubscriber.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\Subscriber;
 6 | 
 7 | use Patchlevel\EventSourcing\Metadata\MetadataException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class ClassIsNotASubscriber extends MetadataException
12 | {
13 |     /** @param class-string $class */
14 |     public function __construct(string $class)
15 |     {
16 |         parent::__construct(
17 |             sprintf(
18 |                 'Class "%s" is not a subscriber',
19 |                 $class,
20 |             ),
21 |         );
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Metadata/Subscriber/DuplicateFailedMethod.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\Subscriber;
 6 | 
 7 | use Patchlevel\EventSourcing\Metadata\MetadataException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class DuplicateFailedMethod extends MetadataException
12 | {
13 |     /** @param class-string $subscriber */
14 |     public function __construct(string $subscriber, string $fistMethod, string $secondMethod)
15 |     {
16 |         parent::__construct(
17 |             sprintf(
18 |                 'Two methods "%s" and "%s" on the subscriber "%s" have been marked as "OnFailed" methods. Only one method can be defined like this.',
19 |                 $fistMethod,
20 |                 $secondMethod,
21 |                 $subscriber,
22 |             ),
23 |         );
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Metadata/Subscriber/DuplicateSetupMethod.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\Subscriber;
 6 | 
 7 | use Patchlevel\EventSourcing\Metadata\MetadataException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class DuplicateSetupMethod extends MetadataException
12 | {
13 |     /** @param class-string $subscriber */
14 |     public function __construct(string $subscriber, string $fistMethod, string $secondMethod)
15 |     {
16 |         parent::__construct(
17 |             sprintf(
18 |                 'Two methods "%s" and "%s" on the subscriber "%s" have been marked as "setup" methods. Only one method can be defined like this.',
19 |                 $fistMethod,
20 |                 $secondMethod,
21 |                 $subscriber,
22 |             ),
23 |         );
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Metadata/Subscriber/DuplicateSubscribeMethod.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\Subscriber;
 6 | 
 7 | use Patchlevel\EventSourcing\Metadata\MetadataException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class DuplicateSubscribeMethod extends MetadataException
12 | {
13 |     public static function duplicateEvent(
14 |         string $subscriber,
15 |         string $event,
16 |         string $fistMethod,
17 |         string $secondMethod,
18 |     ): self {
19 |         return new self(
20 |             sprintf(
21 |                 'Two methods "%s" and "%s" on the subscriber "%s" are subscribing the event "%s". A subscriber can only listen once to a event, thus this is not allowed.',
22 |                 $fistMethod,
23 |                 $secondMethod,
24 |                 $subscriber,
25 |                 $event,
26 |             ),
27 |         );
28 |     }
29 | 
30 |     public static function mixedWithAll(string $subscriber): self
31 |     {
32 |         return new self(sprintf(
33 |             'The subscriber "%s" is subscribing explicit events and all events. A subscriber can only listen once to a event, thus this is not allowed.',
34 |             $subscriber,
35 |         ));
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/Metadata/Subscriber/DuplicateTeardownMethod.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\Subscriber;
 6 | 
 7 | use Patchlevel\EventSourcing\Metadata\MetadataException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class DuplicateTeardownMethod extends MetadataException
12 | {
13 |     /** @param class-string $subscriber */
14 |     public function __construct(string $subscriber, string $fistMethod, string $secondMethod)
15 |     {
16 |         parent::__construct(
17 |             sprintf(
18 |                 'Two methods "%s" and "%s" on the subscriber "%s" have been marked as "teardown" methods. Only one method can be defined like this.',
19 |                 $fistMethod,
20 |                 $secondMethod,
21 |                 $subscriber,
22 |             ),
23 |         );
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Metadata/Subscriber/Psr16SubscriberMetadataFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\Subscriber;
 6 | 
 7 | use Psr\SimpleCache\CacheInterface;
 8 | 
 9 | final class Psr16SubscriberMetadataFactory implements SubscriberMetadataFactory
10 | {
11 |     public function __construct(
12 |         private readonly SubscriberMetadataFactory $subscriberMetadataFactory,
13 |         private readonly CacheInterface $cache,
14 |     ) {
15 |     }
16 | 
17 |     /** @param class-string $subscriber */
18 |     public function metadata(string $subscriber): SubscriberMetadata
19 |     {
20 |         /** @var ?SubscriberMetadata $metadata */
21 |         $metadata = $this->cache->get($subscriber);
22 | 
23 |         if ($metadata !== null) {
24 |             return $metadata;
25 |         }
26 | 
27 |         $metadata = $this->subscriberMetadataFactory->metadata($subscriber);
28 | 
29 |         $this->cache->set($subscriber, $metadata);
30 | 
31 |         return $metadata;
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/Metadata/Subscriber/Psr6SubscriberMetadataFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\Subscriber;
 6 | 
 7 | use Psr\Cache\CacheItemPoolInterface;
 8 | 
 9 | use function assert;
10 | 
11 | final class Psr6SubscriberMetadataFactory implements SubscriberMetadataFactory
12 | {
13 |     public function __construct(
14 |         private readonly SubscriberMetadataFactory $subscriberMetadataFactory,
15 |         private readonly CacheItemPoolInterface $cache,
16 |     ) {
17 |     }
18 | 
19 |     /** @param class-string $subscriber */
20 |     public function metadata(string $subscriber): SubscriberMetadata
21 |     {
22 |         $item = $this->cache->getItem($subscriber);
23 | 
24 |         if ($item->isHit()) {
25 |             $data = $item->get();
26 |             assert($data instanceof SubscriberMetadata);
27 | 
28 |             return $data;
29 |         }
30 | 
31 |         $metadata = $this->subscriberMetadataFactory->metadata($subscriber);
32 | 
33 |         $item->set($metadata);
34 |         $this->cache->save($item);
35 | 
36 |         return $metadata;
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/Metadata/Subscriber/SubscribeMethodMetadata.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\Subscriber;
 6 | 
 7 | final class SubscribeMethodMetadata
 8 | {
 9 |     /** @param list<ArgumentMetadata> $arguments */
10 |     public function __construct(
11 |         public readonly string $name,
12 |         public readonly array $arguments = [],
13 |     ) {
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Metadata/Subscriber/SubscriberMetadata.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\Subscriber;
 6 | 
 7 | use Patchlevel\EventSourcing\Subscription\RunMode;
 8 | use Patchlevel\EventSourcing\Subscription\Subscription;
 9 | 
10 | final class SubscriberMetadata
11 | {
12 |     public function __construct(
13 |         public readonly string $id,
14 |         public readonly string $group = Subscription::DEFAULT_GROUP,
15 |         public readonly RunMode $runMode = RunMode::FromBeginning,
16 |         /** @var array<class-string|"*", list<SubscribeMethodMetadata>> */
17 |         public readonly array $subscribeMethods = [],
18 |         public readonly string|null $setupMethod = null,
19 |         public readonly string|null $teardownMethod = null,
20 |         public readonly string|null $failedMethod = null,
21 |         public readonly string|null $retryStrategy = null,
22 |     ) {
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Metadata/Subscriber/SubscriberMetadataFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Metadata\Subscriber;
 6 | 
 7 | interface SubscriberMetadataFactory
 8 | {
 9 |     /** @param class-string $subscriber */
10 |     public function metadata(string $subscriber): SubscriberMetadata;
11 | }
12 | 


--------------------------------------------------------------------------------
/src/QueryBus/ChainHandlerProvider.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\QueryBus;
 6 | 
 7 | final class ChainHandlerProvider implements HandlerProvider
 8 | {
 9 |     /** @param iterable<HandlerProvider> $providers */
10 |     public function __construct(
11 |         private readonly iterable $providers,
12 |     ) {
13 |     }
14 | 
15 |     /**
16 |      * @param class-string $queryClass
17 |      *
18 |      * @return iterable<int, HandlerDescriptor>
19 |      */
20 |     public function handlerForQuery(string $queryClass): iterable
21 |     {
22 |         $handlers = [];
23 | 
24 |         foreach ($this->providers as $provider) {
25 |             $handlers = [
26 |                 ...$handlers,
27 |                 ...$provider->handlerForQuery($queryClass),
28 |             ];
29 |         }
30 | 
31 |         return $handlers;
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/QueryBus/HandlerDescriptor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\QueryBus;
 6 | 
 7 | use Closure;
 8 | use ReflectionFunction;
 9 | 
10 | final class HandlerDescriptor
11 | {
12 |     private readonly Closure $callable;
13 |     private readonly string $name;
14 | 
15 |     public function __construct(callable $callable)
16 |     {
17 |         $this->callable = $callable(...);
18 |         $this->name = self::closureName($this->callable);
19 |     }
20 | 
21 |     public function name(): string
22 |     {
23 |         return $this->name;
24 |     }
25 | 
26 |     public function callable(): callable
27 |     {
28 |         return $this->callable;
29 |     }
30 | 
31 |     private static function closureName(Closure $closure): string
32 |     {
33 |         $reflectionFunction = new ReflectionFunction($closure);
34 | 
35 |         if ($reflectionFunction->isAnonymous()) {
36 |             return 'Closure';
37 |         }
38 | 
39 |         $closureThis = $reflectionFunction->getClosureThis();
40 | 
41 |         if (!$closureThis) {
42 |             $class = $reflectionFunction->getClosureCalledClass();
43 | 
44 |             return ($class ? $class->name . '::' : '') . $reflectionFunction->name;
45 |         }
46 | 
47 |         return $closureThis::class . '::' . $reflectionFunction->name;
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/src/QueryBus/HandlerProvider.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\QueryBus;
 6 | 
 7 | interface HandlerProvider
 8 | {
 9 |     /**
10 |      * @param class-string $queryClass
11 |      *
12 |      * @return iterable<int, HandlerDescriptor>
13 |      */
14 |     public function handlerForQuery(string $queryClass): iterable;
15 | }
16 | 


--------------------------------------------------------------------------------
/src/QueryBus/HandlerReference.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\QueryBus;
 6 | 
 7 | final class HandlerReference
 8 | {
 9 |     /** @param class-string $queryClass */
10 |     public function __construct(
11 |         public readonly string $queryClass,
12 |         public readonly string $method,
13 |         public readonly bool $static,
14 |     ) {
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/QueryBus/InvalidHandleMethod.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\QueryBus;
 6 | 
 7 | use InvalidArgumentException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class InvalidHandleMethod extends InvalidArgumentException
12 | {
13 |     public static function noParameters(string $class, string $method): self
14 |     {
15 |         return new self(sprintf('Query handling method "%s" in class "%s" has no parameters', $method, $class));
16 |     }
17 | 
18 |     public static function incompatibleType(string $class, string $method): self
19 |     {
20 |         return new self(sprintf('Query handling method "%s" in class "%s" has no compatible type', $method, $class));
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/QueryBus/InvalidQueryHandler.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\QueryBus;
 6 | 
 7 | use InvalidArgumentException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class InvalidQueryHandler extends InvalidArgumentException
12 | {
13 |     public static function noHandler(string $queryClass): self
14 |     {
15 |         return new self(sprintf('No handler found for query %s', $queryClass));
16 |     }
17 | 
18 |     public static function multipleHandler(string $queryClass): self
19 |     {
20 |         return new self(sprintf('Multiple handlers found for query %s', $queryClass));
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/QueryBus/QueryBus.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\QueryBus;
 6 | 
 7 | interface QueryBus
 8 | {
 9 |     public function dispatch(object $query): mixed;
10 | }
11 | 


--------------------------------------------------------------------------------
/src/QueryBus/ServiceHandlerProvider.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\QueryBus;
 6 | 
 7 | final class ServiceHandlerProvider implements HandlerProvider
 8 | {
 9 |     private bool $initialized = false;
10 | 
11 |     /** @var array<class-string, list<HandlerDescriptor>> */
12 |     private array $handlers = [];
13 | 
14 |     /** @param iterable<object> $services */
15 |     public function __construct(
16 |         private readonly iterable $services,
17 |     ) {
18 |     }
19 | 
20 |     /**
21 |      * @param class-string $queryClass
22 |      *
23 |      * @return iterable<int, HandlerDescriptor>
24 |      */
25 |     public function handlerForQuery(string $queryClass): iterable
26 |     {
27 |         if (!$this->initialized) {
28 |             $this->initialize();
29 |         }
30 | 
31 |         return $this->handlers[$queryClass] ?? [];
32 |     }
33 | 
34 |     private function initialize(): void
35 |     {
36 |         foreach ($this->services as $service) {
37 |             foreach (HandlerFinder::findInClass($service::class) as $handler) {
38 |                 if ($handler->static) {
39 |                     $this->handlers[$handler->queryClass][] = new HandlerDescriptor(
40 |                         $service::{$handler->method}(...),
41 |                     );
42 | 
43 |                     continue;
44 |                 }
45 | 
46 |                 $this->handlers[$handler->queryClass][] = new HandlerDescriptor(
47 |                     $service->{$handler->method}(...),
48 |                 );
49 |             }
50 |         }
51 | 
52 |         $this->initialized = true;
53 |     }
54 | }
55 | 


--------------------------------------------------------------------------------
/src/QueryBus/SyncQueryBus.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\QueryBus;
 6 | 
 7 | use Psr\Log\LoggerInterface;
 8 | 
 9 | use function count;
10 | use function is_array;
11 | use function iterator_to_array;
12 | 
13 | final class SyncQueryBus implements QueryBus
14 | {
15 |     private readonly HandlerProvider $handlerProvider;
16 | 
17 |     /** @param iterable<HandlerProvider>|HandlerProvider $handlerProviders */
18 |     public function __construct(
19 |         iterable|HandlerProvider $handlerProviders,
20 |         private readonly LoggerInterface|null $logger = null,
21 |     ) {
22 |         if (!$handlerProviders instanceof HandlerProvider) {
23 |             $this->handlerProvider = new ChainHandlerProvider($handlerProviders);
24 |         } else {
25 |             $this->handlerProvider = $handlerProviders;
26 |         }
27 |     }
28 | 
29 |     /** @throws InvalidQueryHandler */
30 |     public function dispatch(object $query): mixed
31 |     {
32 |         $this->logger?->debug('QueryBus: dispatch query', ['query' => $query::class]);
33 | 
34 |         $handlers = $this->handlerProvider->handlerForQuery($query::class);
35 | 
36 |         if (!is_array($handlers)) {
37 |             $handlers = iterator_to_array($handlers);
38 |         }
39 | 
40 |         $count = count($handlers);
41 | 
42 |         if ($count === 0) {
43 |             throw InvalidQueryHandler::noHandler($query::class);
44 |         }
45 | 
46 |         if ($count > 1) {
47 |             throw InvalidQueryHandler::multipleHandler($query::class);
48 |         }
49 | 
50 |         return ($handlers[0]->callable())($query);
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/src/Repository/AggregateAlreadyExists.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Repository;
 6 | 
 7 | use Patchlevel\EventSourcing\Aggregate\AggregateRoot;
 8 | use Patchlevel\EventSourcing\Aggregate\AggregateRootId;
 9 | 
10 | use function sprintf;
11 | 
12 | final class AggregateAlreadyExists extends RepositoryException
13 | {
14 |     /** @param class-string<AggregateRoot> $aggregate */
15 |     public function __construct(string $aggregate, AggregateRootId $id)
16 |     {
17 |         parent::__construct(
18 |             sprintf(
19 |                 'aggregate %s with id %s already exists',
20 |                 $aggregate,
21 |                 $id->toString(),
22 |             ),
23 |         );
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Repository/AggregateDetached.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Repository;
 6 | 
 7 | use Patchlevel\EventSourcing\Aggregate\AggregateRoot;
 8 | use Patchlevel\EventSourcing\Aggregate\AggregateRootId;
 9 | 
10 | use function sprintf;
11 | 
12 | final class AggregateDetached extends RepositoryException
13 | {
14 |     /** @param class-string<AggregateRoot> $aggregateRootClass */
15 |     public function __construct(string $aggregateRootClass, AggregateRootId $aggregateRootId)
16 |     {
17 |         parent::__construct(
18 |             sprintf(
19 |                 'An error occurred while saving the aggregate "%s" with the ID "%s", causing the uncommitted events to be lost. Please reload the aggregate.',
20 |                 $aggregateRootClass,
21 |                 $aggregateRootId->toString(),
22 |             ),
23 |         );
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Repository/AggregateNotFound.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Repository;
 6 | 
 7 | use Patchlevel\EventSourcing\Aggregate\AggregateRootId;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class AggregateNotFound extends RepositoryException
12 | {
13 |     public function __construct(string $aggregateRootClass, AggregateRootId $rootId)
14 |     {
15 |         parent::__construct(sprintf('aggregate "%s::%s" not found', $aggregateRootClass, $rootId->toString()));
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Repository/AggregateOutdated.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Repository;
 6 | 
 7 | use Patchlevel\EventSourcing\Aggregate\AggregateRoot;
 8 | use Patchlevel\EventSourcing\Aggregate\AggregateRootId;
 9 | 
10 | use function sprintf;
11 | 
12 | final class AggregateOutdated extends RepositoryException
13 | {
14 |     /** @param class-string<AggregateRoot> $aggregate */
15 |     public function __construct(string $aggregate, AggregateRootId $id)
16 |     {
17 |         parent::__construct(
18 |             sprintf(
19 |                 'Aggregate %s with id %s is outdated. There are new events in the store. Please reload the aggregate.',
20 |                 $aggregate,
21 |                 $id->toString(),
22 |             ),
23 |         );
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Repository/AggregateUnknown.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Repository;
 6 | 
 7 | use Patchlevel\EventSourcing\Aggregate\AggregateRoot;
 8 | use Patchlevel\EventSourcing\Aggregate\AggregateRootId;
 9 | 
10 | use function sprintf;
11 | 
12 | final class AggregateUnknown extends RepositoryException
13 | {
14 |     /** @param class-string<AggregateRoot> $aggregateRootClass */
15 |     public function __construct(string $aggregateRootClass, AggregateRootId $aggregateRootId)
16 |     {
17 |         parent::__construct(
18 |             sprintf(
19 |                 'The aggregate %s with the ID "%s" was not loaded from this repository. Please reload the aggregate.',
20 |                 $aggregateRootClass,
21 |                 $aggregateRootId->toString(),
22 |             ),
23 |         );
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Repository/MessageDecorator/ChainMessageDecorator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Repository\MessageDecorator;
 6 | 
 7 | use Patchlevel\EventSourcing\Message\Message;
 8 | 
 9 | final class ChainMessageDecorator implements MessageDecorator
10 | {
11 |     /** @param iterable<MessageDecorator> $messageDecorators */
12 |     public function __construct(
13 |         private readonly iterable $messageDecorators,
14 |     ) {
15 |     }
16 | 
17 |     public function __invoke(Message $message): Message
18 |     {
19 |         foreach ($this->messageDecorators as $messageDecorator) {
20 |             $message = ($messageDecorator)($message);
21 |         }
22 | 
23 |         return $message;
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Repository/MessageDecorator/MessageDecorator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Repository\MessageDecorator;
 6 | 
 7 | use Patchlevel\EventSourcing\Message\Message;
 8 | 
 9 | interface MessageDecorator
10 | {
11 |     public function __invoke(Message $message): Message;
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Repository/MessageDecorator/SplitStreamDecorator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Repository\MessageDecorator;
 6 | 
 7 | use Patchlevel\EventSourcing\Message\Message;
 8 | use Patchlevel\EventSourcing\Metadata\Event\EventMetadataFactory;
 9 | use Patchlevel\EventSourcing\Store\StreamStartHeader;
10 | 
11 | final class SplitStreamDecorator implements MessageDecorator
12 | {
13 |     public function __construct(
14 |         private readonly EventMetadataFactory $eventMetadataFactory,
15 |     ) {
16 |     }
17 | 
18 |     public function __invoke(Message $message): Message
19 |     {
20 |         $event = $message->event();
21 |         $metadata = $this->eventMetadataFactory->metadata($event::class);
22 | 
23 |         if (!$metadata->splitStream) {
24 |             return $message;
25 |         }
26 | 
27 |         return $message->withHeader(new StreamStartHeader());
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Repository/PlayheadMismatch.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Repository;
 6 | 
 7 | use Patchlevel\EventSourcing\Aggregate\AggregateRootId;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class PlayheadMismatch extends RepositoryException
12 | {
13 |     public function __construct(string $aggregateRootClass, AggregateRootId $aggregateRootId, int $playhead, int $eventCount)
14 |     {
15 |         parent::__construct(sprintf(
16 |             'There is a mismatch between the playhead [%s] and the event count [%s] for the aggregate [%s] with the id [%s]',
17 |             $playhead,
18 |             $eventCount,
19 |             $aggregateRootClass,
20 |             $aggregateRootId->toString(),
21 |         ));
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Repository/Repository.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Repository;
 6 | 
 7 | use Patchlevel\EventSourcing\Aggregate\AggregateRoot;
 8 | use Patchlevel\EventSourcing\Aggregate\AggregateRootId;
 9 | 
10 | /** @template T of AggregateRoot */
11 | interface Repository
12 | {
13 |     /**
14 |      * @return T
15 |      *
16 |      * @throws AggregateNotFound
17 |      */
18 |     public function load(AggregateRootId $id): AggregateRoot;
19 | 
20 |     public function has(AggregateRootId $id): bool;
21 | 
22 |     /**
23 |      * @param T $aggregate
24 |      *
25 |      * @throws WrongAggregate
26 |      * @throws AggregateDetached
27 |      * @throws AggregateUnknown
28 |      * @throws PlayheadMismatch
29 |      * @throws AggregateAlreadyExists
30 |      * @throws AggregateOutdated
31 |      */
32 |     public function save(AggregateRoot $aggregate): void;
33 | }
34 | 


--------------------------------------------------------------------------------
/src/Repository/RepositoryException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Repository;
 6 | 
 7 | use RuntimeException;
 8 | 
 9 | abstract class RepositoryException extends RuntimeException
10 | {
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Repository/RepositoryManager.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Repository;
 6 | 
 7 | use Patchlevel\EventSourcing\Aggregate\AggregateRoot;
 8 | 
 9 | interface RepositoryManager
10 | {
11 |     /**
12 |      * @param class-string<T> $aggregateClass
13 |      *
14 |      * @return Repository<T>
15 |      *
16 |      * @template T of AggregateRoot
17 |      */
18 |     public function get(string $aggregateClass): Repository;
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Repository/SnapshotRebuildFailed.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Repository;
 6 | 
 7 | use Patchlevel\EventSourcing\Aggregate\AggregateRoot;
 8 | use Patchlevel\EventSourcing\Aggregate\AggregateRootId;
 9 | use Throwable;
10 | 
11 | use function sprintf;
12 | 
13 | final class SnapshotRebuildFailed extends RepositoryException
14 | {
15 |     /** @param class-string<AggregateRoot> $aggregateRootClass */
16 |     public function __construct(
17 |         private string $aggregateRootClass,
18 |         private AggregateRootId $aggregateRootId,
19 |         Throwable $previous,
20 |     ) {
21 |         parent::__construct(
22 |             sprintf(
23 |                 'Rebuild from snapshot of aggregate "%s" with the id "%s" failed',
24 |                 $aggregateRootClass,
25 |                 $aggregateRootId->toString(),
26 |             ),
27 |             0,
28 |             $previous,
29 |         );
30 |     }
31 | 
32 |     /** @return class-string<AggregateRoot> */
33 |     public function aggregateClass(): string
34 |     {
35 |         return $this->aggregateRootClass;
36 |     }
37 | 
38 |     public function aggregateRootId(): AggregateRootId
39 |     {
40 |         return $this->aggregateRootId;
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/src/Repository/WrongAggregate.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Repository;
 6 | 
 7 | use function sprintf;
 8 | 
 9 | final class WrongAggregate extends RepositoryException
10 | {
11 |     /**
12 |      * @param class-string $aggregateRootClass
13 |      * @param class-string $expected
14 |      */
15 |     public function __construct(string $aggregateRootClass, string $expected)
16 |     {
17 |         parent::__construct(
18 |             sprintf('Wrong aggregate given: got "%s" but expected "%s"', $aggregateRootClass, $expected),
19 |         );
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Schema/ChainDoctrineSchemaConfigurator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Schema;
 6 | 
 7 | use Doctrine\DBAL\Connection;
 8 | use Doctrine\DBAL\Schema\Schema;
 9 | 
10 | final class ChainDoctrineSchemaConfigurator implements DoctrineSchemaConfigurator
11 | {
12 |     /** @param iterable<DoctrineSchemaConfigurator> $schemaConfigurator */
13 |     public function __construct(
14 |         private readonly iterable $schemaConfigurator,
15 |     ) {
16 |     }
17 | 
18 |     public function configureSchema(Schema $schema, Connection $connection): void
19 |     {
20 |         foreach ($this->schemaConfigurator as $schemaConfigurator) {
21 |             $schemaConfigurator->configureSchema($schema, $connection);
22 |         }
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Schema/DoctrineMigrationSchemaProvider.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Schema;
 6 | 
 7 | use Doctrine\DBAL\Schema\Schema;
 8 | use Doctrine\Migrations\Provider\SchemaProvider;
 9 | 
10 | final class DoctrineMigrationSchemaProvider implements SchemaProvider
11 | {
12 |     public function __construct(
13 |         private readonly DoctrineSchemaProvider $doctrineSchemaProvider,
14 |     ) {
15 |     }
16 | 
17 |     public function createSchema(): Schema
18 |     {
19 |         return $this->doctrineSchemaProvider->schema();
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Schema/DoctrineSchemaConfigurator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Schema;
 6 | 
 7 | use Doctrine\DBAL\Connection;
 8 | use Doctrine\DBAL\Schema\Schema;
 9 | 
10 | interface DoctrineSchemaConfigurator
11 | {
12 |     public function configureSchema(Schema $schema, Connection $connection): void;
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Schema/DoctrineSchemaListener.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Schema;
 6 | 
 7 | use Doctrine\ORM\Tools\Event\GenerateSchemaEventArgs;
 8 | 
 9 | final class DoctrineSchemaListener
10 | {
11 |     public function __construct(
12 |         private readonly DoctrineSchemaConfigurator $schemaConfigurator,
13 |     ) {
14 |     }
15 | 
16 |     public function postGenerateSchema(GenerateSchemaEventArgs $event): void
17 |     {
18 |         $this->schemaConfigurator->configureSchema(
19 |             $event->getSchema(),
20 |             $event->getEntityManager()->getConnection(),
21 |         );
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Schema/DoctrineSchemaProvider.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Schema;
 6 | 
 7 | use Doctrine\DBAL\Schema\Schema;
 8 | 
 9 | interface DoctrineSchemaProvider
10 | {
11 |     public function schema(): Schema;
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Schema/DoctrineSchemaSubscriber.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Schema;
 6 | 
 7 | use Doctrine\Common\EventSubscriber;
 8 | use Doctrine\ORM\Tools\Event\GenerateSchemaEventArgs;
 9 | use Doctrine\ORM\Tools\ToolEvents;
10 | 
11 | use function class_exists;
12 | 
13 | /** @deprecated use DoctrineSchemaListener instead */
14 | final class DoctrineSchemaSubscriber implements EventSubscriber
15 | {
16 |     public function __construct(
17 |         private readonly DoctrineSchemaConfigurator $schemaConfigurator,
18 |     ) {
19 |     }
20 | 
21 |     public function postGenerateSchema(GenerateSchemaEventArgs $event): void
22 |     {
23 |         $this->schemaConfigurator->configureSchema(
24 |             $event->getSchema(),
25 |             $event->getEntityManager()->getConnection(),
26 |         );
27 |     }
28 | 
29 |     /** @return list<string> */
30 |     public function getSubscribedEvents(): array
31 |     {
32 |         $subscribedEvents = [];
33 | 
34 |         if (class_exists(ToolEvents::class)) {
35 |             $subscribedEvents[] = ToolEvents::postGenerateSchema;
36 |         }
37 | 
38 |         return $subscribedEvents;
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Schema/DryRunSchemaDirector.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Schema;
 6 | 
 7 | interface DryRunSchemaDirector extends SchemaDirector
 8 | {
 9 |     /** @return list<string> */
10 |     public function dryRunCreate(): array;
11 | 
12 |     /** @return list<string> */
13 |     public function dryRunUpdate(): array;
14 | 
15 |     /** @return list<string> */
16 |     public function dryRunDrop(): array;
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Schema/SchemaDirector.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Schema;
 6 | 
 7 | interface SchemaDirector
 8 | {
 9 |     public function create(): void;
10 | 
11 |     public function update(): void;
12 | 
13 |     public function drop(): void;
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Serializer/Encoder/DecodeNotPossible.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Serializer\Encoder;
 6 | 
 7 | use Patchlevel\EventSourcing\Serializer\SerializeException;
 8 | use Throwable;
 9 | 
10 | use function sprintf;
11 | 
12 | final class DecodeNotPossible extends SerializeException
13 | {
14 |     public function __construct(
15 |         private string $data,
16 |         Throwable|null $previous = null,
17 |     ) {
18 |         parent::__construct(
19 |             sprintf(
20 |                 'deserialization of "%s" data is not possible',
21 |                 $data,
22 |             ),
23 |             0,
24 |             $previous,
25 |         );
26 |     }
27 | 
28 |     public function data(): string
29 |     {
30 |         return $this->data;
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Serializer/Encoder/EncodeNotPossible.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Serializer\Encoder;
 6 | 
 7 | use Patchlevel\EventSourcing\Serializer\SerializeException;
 8 | use Throwable;
 9 | 
10 | final class EncodeNotPossible extends SerializeException
11 | {
12 |     /** @param array<string, mixed> $data */
13 |     public function __construct(
14 |         private array $data,
15 |         Throwable|null $previous = null,
16 |     ) {
17 |         parent::__construct(
18 |             'serialization is not possible',
19 |             0,
20 |             $previous,
21 |         );
22 |     }
23 | 
24 |     /** @return array<string, mixed> */
25 |     public function data(): array
26 |     {
27 |         return $this->data;
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Serializer/Encoder/Encoder.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Serializer\Encoder;
 6 | 
 7 | interface Encoder
 8 | {
 9 |     public const OPTION_PRETTY_PRINT = 'pretty_print';
10 | 
11 |     /**
12 |      * @param array<string, mixed> $data
13 |      * @param array<string, mixed> $options
14 |      *
15 |      * @throws EncodeNotPossible
16 |      */
17 |     public function encode(array $data, array $options = []): string;
18 | 
19 |     /**
20 |      * @param array<string, mixed> $options
21 |      *
22 |      * @return array<string, mixed>
23 |      *
24 |      * @throws DecodeNotPossible
25 |      */
26 |     public function decode(string $data, array $options = []): array;
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Serializer/Encoder/JsonEncoder.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Serializer\Encoder;
 6 | 
 7 | use JsonException;
 8 | 
 9 | use function array_key_exists;
10 | use function json_decode;
11 | use function json_encode;
12 | 
13 | use const JSON_PRETTY_PRINT;
14 | use const JSON_THROW_ON_ERROR;
15 | 
16 | final class JsonEncoder implements Encoder
17 | {
18 |     /**
19 |      * @param array<string, mixed> $data
20 |      * @param array<string, mixed> $options
21 |      */
22 |     public function encode(array $data, array $options = []): string
23 |     {
24 |         $flags = JSON_THROW_ON_ERROR;
25 | 
26 |         if (array_key_exists(self::OPTION_PRETTY_PRINT, $options) && $options[self::OPTION_PRETTY_PRINT] === true) {
27 |             $flags |= JSON_PRETTY_PRINT;
28 |         }
29 | 
30 |         try {
31 |             return json_encode($data, $flags);
32 |         } catch (JsonException $e) {
33 |             throw new EncodeNotPossible($data, $e);
34 |         }
35 |     }
36 | 
37 |     /**
38 |      * @param array<string, mixed> $options
39 |      *
40 |      * @return array<string, mixed>
41 |      */
42 |     public function decode(string $data, array $options = []): array
43 |     {
44 |         try {
45 |             /** @var array<string, mixed> $result */
46 |             $result = json_decode($data, true, 512, JSON_THROW_ON_ERROR);
47 | 
48 |             return $result;
49 |         } catch (JsonException $e) {
50 |             throw new DecodeNotPossible($data, $e);
51 |         }
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/src/Serializer/EventSerializer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Serializer;
 6 | 
 7 | interface EventSerializer
 8 | {
 9 |     /** @param array<string, mixed> $options */
10 |     public function serialize(object $event, array $options = []): SerializedEvent;
11 | 
12 |     /** @param array<string, mixed> $options */
13 |     public function deserialize(SerializedEvent $data, array $options = []): object;
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Serializer/SerializeException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Serializer;
 6 | 
 7 | use RuntimeException;
 8 | 
 9 | abstract class SerializeException extends RuntimeException
10 | {
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Serializer/SerializedEvent.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Serializer;
 6 | 
 7 | final class SerializedEvent
 8 | {
 9 |     public function __construct(
10 |         public readonly string $name,
11 |         public readonly string $payload,
12 |     ) {
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Serializer/Upcast/Upcast.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Serializer\Upcast;
 6 | 
 7 | /** @psalm-immutable */
 8 | final class Upcast
 9 | {
10 |     /** @param array<string, mixed> $payload */
11 |     public function __construct(
12 |         public readonly string $eventName,
13 |         public readonly array $payload,
14 |     ) {
15 |     }
16 | 
17 |     public function replaceEventName(string $eventName): self
18 |     {
19 |         return new self($eventName, $this->payload);
20 |     }
21 | 
22 |     /** @param array<string, mixed> $payload */
23 |     public function replacePayload(array $payload): self
24 |     {
25 |         return new self($this->eventName, $payload);
26 |     }
27 | 
28 |     public function replacePayloadByKey(string $key, mixed $data): self
29 |     {
30 |         $payload = $this->payload;
31 |         $payload[$key] = $data;
32 | 
33 |         return new self($this->eventName, $payload);
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/Serializer/Upcast/Upcaster.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Serializer\Upcast;
 6 | 
 7 | interface Upcaster
 8 | {
 9 |     public function __invoke(Upcast $upcast): Upcast;
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Serializer/Upcast/UpcasterChain.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Serializer\Upcast;
 6 | 
 7 | final class UpcasterChain implements Upcaster
 8 | {
 9 |     /** @param iterable<Upcaster> $upcaster */
10 |     public function __construct(
11 |         private readonly iterable $upcaster,
12 |     ) {
13 |     }
14 | 
15 |     public function __invoke(Upcast $upcast): Upcast
16 |     {
17 |         foreach ($this->upcaster as $upcaster) {
18 |             $upcast = $upcaster($upcast);
19 |         }
20 | 
21 |         return $upcast;
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Snapshot/Adapter/InMemorySnapshotAdapter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Snapshot\Adapter;
 6 | 
 7 | use function array_key_exists;
 8 | 
 9 | final class InMemorySnapshotAdapter implements SnapshotAdapter
10 | {
11 |     /** @var array<string, array<string, mixed>> */
12 |     private array $snapshots = [];
13 | 
14 |     /** @param array<string, mixed> $data */
15 |     public function save(string $key, array $data): void
16 |     {
17 |         $this->snapshots[$key] = $data;
18 |     }
19 | 
20 |     /** @return array<string, mixed> */
21 |     public function load(string $key): array
22 |     {
23 |         if (!array_key_exists($key, $this->snapshots)) {
24 |             throw new SnapshotNotFound($key);
25 |         }
26 | 
27 |         return $this->snapshots[$key];
28 |     }
29 | 
30 |     public function clear(): void
31 |     {
32 |         $this->snapshots = [];
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Snapshot/Adapter/Psr16SnapshotAdapter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Snapshot\Adapter;
 6 | 
 7 | use Psr\SimpleCache\CacheInterface;
 8 | 
 9 | final class Psr16SnapshotAdapter implements SnapshotAdapter
10 | {
11 |     public function __construct(
12 |         private readonly CacheInterface $cache,
13 |     ) {
14 |     }
15 | 
16 |     /** @param array<string, mixed> $data */
17 |     public function save(string $key, array $data): void
18 |     {
19 |         $this->cache->set($key, $data);
20 |     }
21 | 
22 |     /** @return array<string, mixed> */
23 |     public function load(string $key): array
24 |     {
25 |         /** @var ?array<string, mixed> $data */
26 |         $data = $this->cache->get($key);
27 | 
28 |         if ($data === null) {
29 |             throw new SnapshotNotFound($key);
30 |         }
31 | 
32 |         return $data;
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Snapshot/Adapter/Psr6SnapshotAdapter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Snapshot\Adapter;
 6 | 
 7 | use Psr\Cache\CacheItemPoolInterface;
 8 | 
 9 | final class Psr6SnapshotAdapter implements SnapshotAdapter
10 | {
11 |     public function __construct(
12 |         private readonly CacheItemPoolInterface $cache,
13 |     ) {
14 |     }
15 | 
16 |     /** @param array<string, mixed> $data */
17 |     public function save(string $key, array $data): void
18 |     {
19 |         $item = $this->cache->getItem($key);
20 |         $item->set($data);
21 |         $this->cache->save($item);
22 |     }
23 | 
24 |     /**
25 |      * @return array<string, mixed>
26 |      *
27 |      * @throws SnapshotNotFound
28 |      */
29 |     public function load(string $key): array
30 |     {
31 |         $item = $this->cache->getItem($key);
32 | 
33 |         if (!$item->isHit()) {
34 |             throw new SnapshotNotFound($key);
35 |         }
36 | 
37 |         /** @var array<string, mixed> $data */
38 |         $data = $item->get();
39 | 
40 |         return $data;
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/src/Snapshot/Adapter/SnapshotAdapter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Snapshot\Adapter;
 6 | 
 7 | interface SnapshotAdapter
 8 | {
 9 |     /** @param array<string, mixed> $data */
10 |     public function save(string $key, array $data): void;
11 | 
12 |     /**
13 |      * @return array<string, mixed>
14 |      *
15 |      * @throws SnapshotNotFound
16 |      */
17 |     public function load(string $key): array;
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Snapshot/Adapter/SnapshotNotFound.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Snapshot\Adapter;
 6 | 
 7 | use Patchlevel\EventSourcing\Snapshot\SnapshotException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class SnapshotNotFound extends SnapshotException
12 | {
13 |     public function __construct(string $key)
14 |     {
15 |         parent::__construct(
16 |             sprintf(
17 |                 'snapshot with the key "%s" not found',
18 |                 $key,
19 |             ),
20 |         );
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Snapshot/AdapterNotFound.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Snapshot;
 6 | 
 7 | use function sprintf;
 8 | 
 9 | final class AdapterNotFound extends SnapshotException
10 | {
11 |     public function __construct(string $adapterName)
12 |     {
13 |         parent::__construct(
14 |             sprintf(
15 |                 'adapter with the name "%s" not found',
16 |                 $adapterName,
17 |             ),
18 |         );
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Snapshot/AdapterRepository.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Snapshot;
 6 | 
 7 | use Patchlevel\EventSourcing\Snapshot\Adapter\SnapshotAdapter;
 8 | 
 9 | interface AdapterRepository
10 | {
11 |     public function get(string $name): SnapshotAdapter;
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Snapshot/ArrayAdapterRepository.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Snapshot;
 6 | 
 7 | use Patchlevel\EventSourcing\Snapshot\Adapter\SnapshotAdapter;
 8 | 
 9 | use function array_key_exists;
10 | 
11 | final class ArrayAdapterRepository implements AdapterRepository
12 | {
13 |     /** @param array<string, SnapshotAdapter> $snapshotAdapters */
14 |     public function __construct(
15 |         private readonly array $snapshotAdapters,
16 |     ) {
17 |     }
18 | 
19 |     public function get(string $name): SnapshotAdapter
20 |     {
21 |         if (!array_key_exists($name, $this->snapshotAdapters)) {
22 |             throw new AdapterNotFound($name);
23 |         }
24 | 
25 |         return $this->snapshotAdapters[$name];
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Snapshot/Snapshot.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Snapshot;
 6 | 
 7 | use Patchlevel\EventSourcing\Aggregate\AggregateRoot;
 8 | 
 9 | final class Snapshot
10 | {
11 |     /**
12 |      * @param class-string<AggregateRoot> $aggregate
13 |      * @param array<string, mixed>        $payload
14 |      */
15 |     public function __construct(
16 |         private readonly string $aggregate,
17 |         private readonly string $id,
18 |         private readonly int $playhead,
19 |         private readonly array $payload,
20 |     ) {
21 |     }
22 | 
23 |     /** @return class-string<AggregateRoot> */
24 |     public function aggregate(): string
25 |     {
26 |         return $this->aggregate;
27 |     }
28 | 
29 |     public function id(): string
30 |     {
31 |         return $this->id;
32 |     }
33 | 
34 |     public function playhead(): int
35 |     {
36 |         return $this->playhead;
37 |     }
38 | 
39 |     /** @return array<string, mixed> */
40 |     public function payload(): array
41 |     {
42 |         return $this->payload;
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/src/Snapshot/SnapshotException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Snapshot;
 6 | 
 7 | use RuntimeException;
 8 | 
 9 | abstract class SnapshotException extends RuntimeException
10 | {
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Snapshot/SnapshotNotConfigured.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Snapshot;
 6 | 
 7 | use Patchlevel\EventSourcing\Aggregate\AggregateRoot;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class SnapshotNotConfigured extends SnapshotException
12 | {
13 |     /** @param class-string<AggregateRoot> $aggregateRootClass */
14 |     public function __construct(string $aggregateRootClass)
15 |     {
16 |         parent::__construct(
17 |             sprintf(
18 |                 'Missing snapshot configuration for the aggregate class "%s"',
19 |                 $aggregateRootClass,
20 |             ),
21 |         );
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Snapshot/SnapshotNotFound.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Snapshot;
 6 | 
 7 | use Patchlevel\EventSourcing\Aggregate\AggregateRoot;
 8 | use Patchlevel\EventSourcing\Aggregate\AggregateRootId;
 9 | use Throwable;
10 | 
11 | use function sprintf;
12 | 
13 | final class SnapshotNotFound extends SnapshotException
14 | {
15 |     /** @param class-string<AggregateRoot> $aggregateRootClass */
16 |     public function __construct(string $aggregateRootClass, AggregateRootId $rootId, Throwable|null $previous = null)
17 |     {
18 |         parent::__construct(
19 |             sprintf(
20 |                 'snapshot for aggregate "%s" with the id "%s" not found',
21 |                 $aggregateRootClass,
22 |                 $rootId->toString(),
23 |             ),
24 |             0,
25 |             $previous,
26 |         );
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Snapshot/SnapshotStore.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Snapshot;
 6 | 
 7 | use Patchlevel\EventSourcing\Aggregate\AggregateRoot;
 8 | use Patchlevel\EventSourcing\Aggregate\AggregateRootId;
 9 | use Patchlevel\EventSourcing\Snapshot\Adapter\SnapshotNotFound;
10 | 
11 | interface SnapshotStore
12 | {
13 |     /**
14 |      * @throws SnapshotNotConfigured
15 |      * @throws AdapterNotFound
16 |      */
17 |     public function save(AggregateRoot $aggregateRoot): void;
18 | 
19 |     /**
20 |      * @param class-string<T> $aggregateClass
21 |      *
22 |      * @return T
23 |      *
24 |      * @throws SnapshotNotFound
25 |      * @throws SnapshotVersionInvalid
26 |      * @throws SnapshotNotConfigured
27 |      * @throws AdapterNotFound
28 |      *
29 |      * @template T of AggregateRoot
30 |      */
31 |     public function load(string $aggregateClass, AggregateRootId $id): AggregateRoot;
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Snapshot/SnapshotVersionInvalid.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Snapshot;
 6 | 
 7 | use function sprintf;
 8 | 
 9 | final class SnapshotVersionInvalid extends SnapshotException
10 | {
11 |     public function __construct(string $key)
12 |     {
13 |         parent::__construct(
14 |             sprintf(
15 |                 'snapshot version with the key "%s" is invalid',
16 |                 $key,
17 |             ),
18 |         );
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Store/ArchivedHeader.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Store;
 6 | 
 7 | /** @psalm-immutable */
 8 | final class ArchivedHeader
 9 | {
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Store/Criteria/AggregateIdCriterion.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Store\Criteria;
 6 | 
 7 | final class AggregateIdCriterion
 8 | {
 9 |     public function __construct(
10 |         public readonly string $aggregateId,
11 |     ) {
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Store/Criteria/AggregateNameCriterion.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Store\Criteria;
 6 | 
 7 | final class AggregateNameCriterion
 8 | {
 9 |     public function __construct(
10 |         public readonly string $aggregateName,
11 |     ) {
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Store/Criteria/ArchivedCriterion.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Store\Criteria;
 6 | 
 7 | final class ArchivedCriterion
 8 | {
 9 |     public function __construct(
10 |         public readonly bool $archived,
11 |     ) {
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Store/Criteria/Criteria.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Store\Criteria;
 6 | 
 7 | use function array_key_exists;
 8 | use function array_values;
 9 | 
10 | final class Criteria
11 | {
12 |     /** @var array<class-string, object> */
13 |     private readonly array $criteria;
14 | 
15 |     public function __construct(object ...$criteria)
16 |     {
17 |         $result = [];
18 | 
19 |         foreach ($criteria as $criterion) {
20 |             $result[$criterion::class] = $criterion;
21 |         }
22 | 
23 |         $this->criteria = $result;
24 |     }
25 | 
26 |     /**
27 |      * @param class-string<T> $criteriaClass
28 |      *
29 |      * @return T
30 |      *
31 |      * @template T of object
32 |      */
33 |     public function get(string $criteriaClass): object
34 |     {
35 |         if (!array_key_exists($criteriaClass, $this->criteria)) {
36 |             throw new CriterionNotFound($criteriaClass);
37 |         }
38 | 
39 |         return $this->criteria[$criteriaClass];
40 |     }
41 | 
42 |     public function has(string $criteriaClass): bool
43 |     {
44 |         return array_key_exists($criteriaClass, $this->criteria);
45 |     }
46 | 
47 |     /** @return list<object> */
48 |     public function all(): array
49 |     {
50 |         return array_values($this->criteria);
51 |     }
52 | 
53 |     public function add(object $criteria): self
54 |     {
55 |         return new self(
56 |             ...$this->all(),
57 |             ...[$criteria],
58 |         );
59 |     }
60 | 
61 |     public function remove(string $criteriaClass): self
62 |     {
63 |         $criteria = $this->criteria;
64 |         unset($criteria[$criteriaClass]);
65 | 
66 |         return new self(...$criteria);
67 |     }
68 | }
69 | 


--------------------------------------------------------------------------------
/src/Store/Criteria/CriterionNotFound.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Store\Criteria;
 6 | 
 7 | use RuntimeException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class CriterionNotFound extends RuntimeException
12 | {
13 |     /** @param class-string $criterionClass */
14 |     public function __construct(string $criterionClass)
15 |     {
16 |         parent::__construct(sprintf('criterion %s not found', $criterionClass));
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Store/Criteria/EventIdCriterion.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Store\Criteria;
 6 | 
 7 | final class EventIdCriterion
 8 | {
 9 |     public function __construct(
10 |         public readonly string $eventId,
11 |     ) {
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Store/Criteria/EventsCriterion.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Store\Criteria;
 6 | 
 7 | final class EventsCriterion
 8 | {
 9 |     public function __construct(
10 |         /** @var list<string> */
11 |         public readonly array $events,
12 |     ) {
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Store/Criteria/FromIndexCriterion.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Store\Criteria;
 6 | 
 7 | final class FromIndexCriterion
 8 | {
 9 |     public function __construct(
10 |         public readonly int $fromIndex,
11 |     ) {
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Store/Criteria/FromPlayheadCriterion.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Store\Criteria;
 6 | 
 7 | final class FromPlayheadCriterion
 8 | {
 9 |     public function __construct(
10 |         public readonly int $fromPlayhead,
11 |     ) {
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Store/Criteria/StreamCriterion.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Store\Criteria;
 6 | 
 7 | final class StreamCriterion
 8 | {
 9 |     /** @var list<string> */
10 |     public readonly array $streamName;
11 | 
12 |     public function __construct(
13 |         string ...$streamName,
14 |     ) {
15 |         $this->streamName = $streamName;
16 |     }
17 | 
18 |     public static function startWith(string $streamName): self
19 |     {
20 |         return new self($streamName . '*');
21 |     }
22 | 
23 |     public function all(): bool
24 |     {
25 |         foreach ($this->streamName as $name) {
26 |             if ($name === '*') {
27 |                 return true;
28 |             }
29 |         }
30 | 
31 |         return false;
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/Store/Criteria/ToIndexCriterion.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Store\Criteria;
 6 | 
 7 | final class ToIndexCriterion
 8 | {
 9 |     public function __construct(
10 |         public readonly int $toIndex,
11 |     ) {
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Store/Criteria/ToPlayheadCriterion.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Store\Criteria;
 6 | 
 7 | final class ToPlayheadCriterion
 8 | {
 9 |     public function __construct(
10 |         public readonly int $toPlayhead,
11 |     ) {
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Store/Header/EventIdHeader.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Store\Header;
 6 | 
 7 | /** @psalm-immutable */
 8 | final class EventIdHeader
 9 | {
10 |     public function __construct(
11 |         public readonly string $eventId,
12 |     ) {
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Store/Header/IndexHeader.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Store\Header;
 6 | 
 7 | /**
 8 |  * @psalm-immutable
 9 |  * @experimental
10 |  */
11 | final class IndexHeader
12 | {
13 |     /** @param positive-int $index */
14 |     public function __construct(
15 |         public readonly int $index,
16 |     ) {
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Store/Header/PlayheadHeader.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Store\Header;
 6 | 
 7 | /** @psalm-immutable */
 8 | final class PlayheadHeader
 9 | {
10 |     /** @param positive-int $playhead */
11 |     public function __construct(
12 |         public readonly int $playhead,
13 |     ) {
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Store/Header/RecordedOnHeader.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Store\Header;
 6 | 
 7 | use DateTimeImmutable;
 8 | 
 9 | /** @psalm-immutable */
10 | final class RecordedOnHeader
11 | {
12 |     public function __construct(
13 |         public readonly DateTimeImmutable $recordedOn,
14 |     ) {
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Store/Header/StreamNameHeader.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Store\Header;
 6 | 
 7 | /** @psalm-immutable */
 8 | final class StreamNameHeader
 9 | {
10 |     public function __construct(
11 |         public readonly string $streamName,
12 |     ) {
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Store/InvalidStreamName.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Store;
 6 | 
 7 | use function sprintf;
 8 | 
 9 | final class InvalidStreamName extends StoreException
10 | {
11 |     public function __construct(string $streamName)
12 |     {
13 |         parent::__construct(sprintf('Invalid stream name "%s"', $streamName));
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Store/InvalidType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Store;
 6 | 
 7 | use function sprintf;
 8 | 
 9 | final class InvalidType extends StoreException
10 | {
11 |     public function __construct(string $field, string $type)
12 |     {
13 |         parent::__construct(sprintf('"%s" should be a "%s" type', $field, $type));
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Store/LockingNotImplemented.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Store;
 6 | 
 7 | use function sprintf;
 8 | 
 9 | final class LockingNotImplemented extends StoreException
10 | {
11 |     /** @param class-string $platform */
12 |     public function __construct(string $platform)
13 |     {
14 |         parent::__construct(
15 |             sprintf(
16 |                 'Locking is not implemented on platform %s. Disable locking in the store options.',
17 |                 $platform,
18 |             ),
19 |         );
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Store/MissingDataForStorage.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Store;
 6 | 
 7 | use Throwable;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class MissingDataForStorage extends StoreException
12 | {
13 |     public function __construct(string $information, Throwable|null $previous = null)
14 |     {
15 |         parent::__construct(
16 |             sprintf('Cannot save because the following information is missing: "%s"', $information),
17 |             0,
18 |             $previous,
19 |         );
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Store/ReadOnlyStore.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Store;
 6 | 
 7 | use Closure;
 8 | use InvalidArgumentException;
 9 | use Patchlevel\EventSourcing\Message\Message;
10 | use Patchlevel\EventSourcing\Store\Criteria\Criteria;
11 | use Psr\Log\LoggerInterface;
12 | 
13 | final class ReadOnlyStore implements Store
14 | {
15 |     public function __construct(
16 |         private readonly Store $store,
17 |         private readonly LoggerInterface|null $logger = null,
18 |     ) {
19 |         if ($this->store instanceof StreamStore) {
20 |             throw new InvalidArgumentException('store must not be a StreamStore. use StreamReadOnlyStore instead');
21 |         }
22 |     }
23 | 
24 |     public function load(
25 |         Criteria|null $criteria = null,
26 |         int|null $limit = null,
27 |         int|null $offset = null,
28 |         bool $backwards = false,
29 |     ): Stream {
30 |         return $this->store->load($criteria, $limit, $offset, $backwards);
31 |     }
32 | 
33 |     public function count(Criteria|null $criteria = null): int
34 |     {
35 |         return $this->store->count($criteria);
36 |     }
37 | 
38 |     public function save(Message ...$messages): void
39 |     {
40 |         foreach ($messages as $message) {
41 |             $this->logger?->info('tried to save message in read only store', ['message' => $message]);
42 |         }
43 | 
44 |         throw new StoreIsReadOnly();
45 |     }
46 | 
47 |     public function transactional(Closure $function): void
48 |     {
49 |         $this->store->transactional($function);
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/src/Store/Store.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Store;
 6 | 
 7 | use Closure;
 8 | use Patchlevel\EventSourcing\Message\Message;
 9 | use Patchlevel\EventSourcing\Store\Criteria\Criteria;
10 | 
11 | interface Store
12 | {
13 |     public function load(
14 |         Criteria|null $criteria = null,
15 |         int|null $limit = null,
16 |         int|null $offset = null,
17 |         bool $backwards = false,
18 |     ): Stream;
19 | 
20 |     public function count(Criteria|null $criteria = null): int;
21 | 
22 |     /**
23 |      * @throws MissingDataForStorage
24 |      * @throws UniqueConstraintViolation
25 |      */
26 |     public function save(Message ...$messages): void;
27 | 
28 |     /**
29 |      * @param Closure():ClosureReturn $function
30 |      *
31 |      * @template ClosureReturn
32 |      */
33 |     public function transactional(Closure $function): void;
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Store/StoreException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Store;
 6 | 
 7 | use RuntimeException;
 8 | 
 9 | abstract class StoreException extends RuntimeException
10 | {
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Store/StoreIsReadOnly.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Store;
 6 | 
 7 | final class StoreIsReadOnly extends StoreException
 8 | {
 9 |     public function __construct()
10 |     {
11 |         parent::__construct('Store is in read only mode');
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Store/Stream.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Store;
 6 | 
 7 | use Patchlevel\EventSourcing\Message\Message;
 8 | use Traversable;
 9 | 
10 | /** @extends Traversable<Message> */
11 | interface Stream extends Traversable
12 | {
13 |     public function close(): void;
14 | 
15 |     /** @throws StreamClosed */
16 |     public function next(): void;
17 | 
18 |     /** @throws StreamClosed */
19 |     public function current(): Message|null;
20 | 
21 |     /** @throws StreamClosed */
22 |     public function end(): bool;
23 | 
24 |     /**
25 |      * @return positive-int|0|null
26 |      *
27 |      * @throws StreamClosed
28 |      */
29 |     public function position(): int|null;
30 | 
31 |     /**
32 |      * @return positive-int|null
33 |      *
34 |      * @throws StreamClosed
35 |      */
36 |     public function index(): int|null;
37 | }
38 | 


--------------------------------------------------------------------------------
/src/Store/StreamClosed.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Store;
 6 | 
 7 | use RuntimeException;
 8 | 
 9 | final class StreamClosed extends RuntimeException
10 | {
11 |     public function __construct()
12 |     {
13 |         parent::__construct('Stream is already closed.');
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Store/StreamStartHeader.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Store;
 6 | 
 7 | /** @psalm-immutable */
 8 | final class StreamStartHeader
 9 | {
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Store/StreamStore.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Store;
 6 | 
 7 | use Patchlevel\EventSourcing\Store\Criteria\Criteria;
 8 | 
 9 | interface StreamStore extends Store
10 | {
11 |     /** @return list<string> */
12 |     public function streams(): array;
13 | 
14 |     public function remove(Criteria|null $criteria = null): void;
15 | 
16 |     public function archive(Criteria|null $criteria = null): void;
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Store/SubscriptionStore.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Store;
 6 | 
 7 | interface SubscriptionStore
 8 | {
 9 |     public function supportSubscription(): bool;
10 | 
11 |     public function setupSubscription(): void;
12 | 
13 |     public function wait(int $timeoutMilliseconds): void;
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Store/UniqueConstraintViolation.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Store;
 6 | 
 7 | use Throwable;
 8 | 
 9 | final class UniqueConstraintViolation extends StoreException
10 | {
11 |     public function __construct(Throwable|null $previous = null)
12 |     {
13 |         parent::__construct('unique constraint violation', 0, $previous);
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Store/UnsupportedCriterion.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Store;
 6 | 
 7 | use RuntimeException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class UnsupportedCriterion extends RuntimeException
12 | {
13 |     /** @param class-string $criterionClass */
14 |     public function __construct(string $criterionClass)
15 |     {
16 |         parent::__construct(sprintf('criterion %s not supported', $criterionClass));
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Store/WrongQueryResult.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Store;
 6 | 
 7 | final class WrongQueryResult extends StoreException
 8 | {
 9 |     public function __construct()
10 |     {
11 |         parent::__construct('the type of the query result is wrong');
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Subscription/Engine/AlreadyProcessing.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Subscription\Engine;
 6 | 
 7 | use RuntimeException;
 8 | 
 9 | final class AlreadyProcessing extends RuntimeException
10 | {
11 |     public function __construct()
12 |     {
13 |         parent::__construct('Subscription engine is already processing');
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Subscription/Engine/Error.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Subscription\Engine;
 6 | 
 7 | use Throwable;
 8 | 
 9 | final class Error
10 | {
11 |     public function __construct(
12 |         public readonly string $subscriptionId,
13 |         public readonly string $message,
14 |         public readonly Throwable $throwable,
15 |     ) {
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Subscription/Engine/ErrorDetected.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Subscription\Engine;
 6 | 
 7 | use RuntimeException;
 8 | 
 9 | use function array_map;
10 | use function implode;
11 | use function sprintf;
12 | 
13 | final class ErrorDetected extends RuntimeException
14 | {
15 |     /** @param list<Error> $errors */
16 |     public function __construct(
17 |         public readonly array $errors,
18 |     ) {
19 |         $sentences = array_map(
20 |             static fn (Error $error) => sprintf(
21 |                 'Subscription %s: %s',
22 |                 $error->subscriptionId,
23 |                 $error->message,
24 |             ),
25 |             $errors,
26 |         );
27 | 
28 |         parent::__construct("Error in subscription engine detected.\n" . implode("\n", $sentences));
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Subscription/Engine/MessageLoader.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Subscription\Engine;
 6 | 
 7 | use Patchlevel\EventSourcing\Store\Stream;
 8 | use Patchlevel\EventSourcing\Subscription\Subscription;
 9 | 
10 | interface MessageLoader
11 | {
12 |     /** @param list<Subscription> $subscriptions */
13 |     public function load(int $startIndex, array $subscriptions): Stream;
14 | 
15 |     public function lastIndex(): int;
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Subscription/Engine/ProcessedResult.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Subscription\Engine;
 6 | 
 7 | final class ProcessedResult
 8 | {
 9 |     /** @param list<Error> $errors */
10 |     public function __construct(
11 |         public readonly int $processedMessages,
12 |         public readonly bool $finished = false,
13 |         public readonly array $errors = [],
14 |     ) {
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Subscription/Engine/Result.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Subscription\Engine;
 6 | 
 7 | final class Result
 8 | {
 9 |     /** @param list<Error> $errors */
10 |     public function __construct(
11 |         public readonly array $errors = [],
12 |     ) {
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Subscription/Engine/StoreMessageLoader.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Subscription\Engine;
 6 | 
 7 | use Patchlevel\EventSourcing\Store\Criteria\Criteria;
 8 | use Patchlevel\EventSourcing\Store\Criteria\FromIndexCriterion;
 9 | use Patchlevel\EventSourcing\Store\Store;
10 | use Patchlevel\EventSourcing\Store\Stream;
11 | use Patchlevel\EventSourcing\Subscription\Subscription;
12 | 
13 | final class StoreMessageLoader implements MessageLoader
14 | {
15 |     public function __construct(
16 |         private readonly Store $store,
17 |     ) {
18 |     }
19 | 
20 |     /** @param list<Subscription> $subscriptions */
21 |     public function load(int $startIndex, array $subscriptions): Stream
22 |     {
23 |         return $this->store->load(new Criteria(new FromIndexCriterion($startIndex)));
24 |     }
25 | 
26 |     public function lastIndex(): int
27 |     {
28 |         $stream = $this->store->load(null, 1, null, true);
29 | 
30 |         return $stream->index() ?: 0;
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Subscription/Engine/SubscriberNotFound.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Subscription\Engine;
 6 | 
 7 | use RuntimeException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class SubscriberNotFound extends RuntimeException
12 | {
13 |     public static function forSubscriptionId(string $subscriptionId): self
14 |     {
15 |         return new self(
16 |             sprintf(
17 |                 'Subscriber with the subscription id "%s" not found.',
18 |                 $subscriptionId,
19 |             ),
20 |         );
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Subscription/Engine/SubscriptionEngine.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Subscription\Engine;
 6 | 
 7 | use Patchlevel\EventSourcing\Subscription\Subscription;
 8 | 
 9 | interface SubscriptionEngine
10 | {
11 |     public function setup(SubscriptionEngineCriteria|null $criteria = null, bool $skipBooting = false): Result;
12 | 
13 |     /**
14 |      * @param positive-int|null $limit
15 |      *
16 |      * @throws SubscriberNotFound
17 |      * @throws AlreadyProcessing
18 |      */
19 |     public function boot(
20 |         SubscriptionEngineCriteria|null $criteria = null,
21 |         int|null $limit = null,
22 |     ): ProcessedResult;
23 | 
24 |     /**
25 |      * @param positive-int|null $limit
26 |      *
27 |      * @throws SubscriberNotFound
28 |      * @throws AlreadyProcessing
29 |      */
30 |     public function run(
31 |         SubscriptionEngineCriteria|null $criteria = null,
32 |         int|null $limit = null,
33 |     ): ProcessedResult;
34 | 
35 |     public function teardown(SubscriptionEngineCriteria|null $criteria = null): Result;
36 | 
37 |     public function remove(SubscriptionEngineCriteria|null $criteria = null): Result;
38 | 
39 |     public function reactivate(SubscriptionEngineCriteria|null $criteria = null): Result;
40 | 
41 |     public function pause(SubscriptionEngineCriteria|null $criteria = null): Result;
42 | 
43 |     /** @return list<Subscription> */
44 |     public function subscriptions(SubscriptionEngineCriteria|null $criteria = null): array;
45 | }
46 | 


--------------------------------------------------------------------------------
/src/Subscription/Engine/SubscriptionEngineCriteria.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Subscription\Engine;
 6 | 
 7 | /** @psalm-immutable */
 8 | final class SubscriptionEngineCriteria
 9 | {
10 |     /**
11 |      * @param list<string>|null $ids
12 |      * @param list<string>|null $groups
13 |      */
14 |     public function __construct(
15 |         public readonly array|null $ids = null,
16 |         public readonly array|null $groups = null,
17 |     ) {
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Subscription/Engine/UnexpectedError.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Subscription\Engine;
 6 | 
 7 | use RuntimeException;
 8 | 
 9 | final class UnexpectedError extends RuntimeException
10 | {
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Subscription/Lookup/MessageNotFound.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Subscription\Lookup;
 6 | 
 7 | use RuntimeException;
 8 | 
 9 | final class MessageNotFound extends RuntimeException
10 | {
11 |     public function __construct()
12 |     {
13 |         parent::__construct('Message not found');
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Subscription/NoErrorToRetry.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Subscription;
 6 | 
 7 | use RuntimeException;
 8 | 
 9 | final class NoErrorToRetry extends RuntimeException
10 | {
11 |     public function __construct()
12 |     {
13 |         parent::__construct('No error to retry.');
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Subscription/Repository/RunSubscriptionEngineRepositoryManager.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Subscription\Repository;
 6 | 
 7 | use Patchlevel\EventSourcing\Aggregate\AggregateRoot;
 8 | use Patchlevel\EventSourcing\Repository\Repository;
 9 | use Patchlevel\EventSourcing\Repository\RepositoryManager;
10 | use Patchlevel\EventSourcing\Subscription\Engine\SubscriptionEngine;
11 | 
12 | final class RunSubscriptionEngineRepositoryManager implements RepositoryManager
13 | {
14 |     /**
15 |      * @param list<string>|null $ids
16 |      * @param list<string>|null $groups
17 |      * @param positive-int|null $limit
18 |      */
19 |     public function __construct(
20 |         private readonly RepositoryManager $repositoryManager,
21 |         private readonly SubscriptionEngine $engine,
22 |         private readonly array|null $ids = null,
23 |         private readonly array|null $groups = null,
24 |         private readonly int|null $limit = null,
25 |     ) {
26 |     }
27 | 
28 |     /**
29 |      * @param class-string<T> $aggregateClass
30 |      *
31 |      * @return Repository<T>
32 |      *
33 |      * @template T of AggregateRoot
34 |      */
35 |     public function get(string $aggregateClass): Repository
36 |     {
37 |         return new RunSubscriptionEngineRepository(
38 |             $this->repositoryManager->get($aggregateClass),
39 |             $this->engine,
40 |             $this->ids,
41 |             $this->groups,
42 |             $this->limit,
43 |         );
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/Subscription/RetryStrategy/ConditionalRetryStrategy.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Subscription\RetryStrategy;
 6 | 
 7 | use Patchlevel\EventSourcing\Subscription\Subscription;
 8 | 
 9 | interface ConditionalRetryStrategy extends RetryStrategy
10 | {
11 |     public function canRetry(Subscription $subscription): bool;
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Subscription/RetryStrategy/NoRetryStrategy.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Subscription\RetryStrategy;
 6 | 
 7 | use Patchlevel\EventSourcing\Subscription\Subscription;
 8 | 
 9 | final class NoRetryStrategy implements ConditionalRetryStrategy
10 | {
11 |     public function shouldRetry(Subscription $subscription): bool
12 |     {
13 |         return false;
14 |     }
15 | 
16 |     public function canRetry(Subscription $subscription): bool
17 |     {
18 |         return false;
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Subscription/RetryStrategy/RetryStrategy.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Subscription\RetryStrategy;
 6 | 
 7 | use Patchlevel\EventSourcing\Subscription\Subscription;
 8 | 
 9 | interface RetryStrategy
10 | {
11 |     public function shouldRetry(Subscription $subscription): bool;
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Subscription/RetryStrategy/RetryStrategyNotFound.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Subscription\RetryStrategy;
 6 | 
 7 | use RuntimeException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class RetryStrategyNotFound extends RuntimeException
12 | {
13 |     public function __construct(string $name)
14 |     {
15 |         parent::__construct(sprintf('Retry strategy with name "%s" not found', $name));
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Subscription/RetryStrategy/RetryStrategyRepository.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Subscription\RetryStrategy;
 6 | 
 7 | final class RetryStrategyRepository
 8 | {
 9 |     public const DEFAULT_STRATEGY_NAME = 'default';
10 | 
11 |     /** @param array<string, RetryStrategy> $strategies */
12 |     public function __construct(
13 |         private readonly array $strategies,
14 |         private readonly string $defaultStrategy = self::DEFAULT_STRATEGY_NAME,
15 |     ) {
16 |     }
17 | 
18 |     public function get(string $name): RetryStrategy
19 |     {
20 |         if (!isset($this->strategies[$name])) {
21 |             throw new RetryStrategyNotFound($name);
22 |         }
23 | 
24 |         return $this->strategies[$name];
25 |     }
26 | 
27 |     public function getDefaultRetryStrategy(): RetryStrategy
28 |     {
29 |         return $this->get($this->defaultStrategy);
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/Subscription/RetryStrategy/UnexpectedError.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Subscription\RetryStrategy;
 6 | 
 7 | use RuntimeException;
 8 | 
 9 | final class UnexpectedError extends RuntimeException
10 | {
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Subscription/RunMode.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Subscription;
 6 | 
 7 | enum RunMode: string
 8 | {
 9 |     case FromBeginning = 'from_beginning';
10 |     case FromNow = 'from_now';
11 |     case Once = 'once';
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Subscription/Status.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Subscription;
 6 | 
 7 | enum Status: string
 8 | {
 9 |     case New = 'new';
10 |     case Booting = 'booting';
11 |     case Active = 'active';
12 |     case Paused = 'paused';
13 |     case Finished = 'finished';
14 |     case Detached = 'detached';
15 |     case Error = 'error';
16 |     case Failed = 'failed';
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Subscription/Store/LockableSubscriptionStore.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Subscription\Store;
 6 | 
 7 | use Closure;
 8 | 
 9 | interface LockableSubscriptionStore extends SubscriptionStore
10 | {
11 |     /**
12 |      * @param Closure():T $closure
13 |      *
14 |      * @return T
15 |      *
16 |      * @throws TransactionCommitNotPossible
17 |      *
18 |      * @template T
19 |      */
20 |     public function inLock(Closure $closure): mixed;
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Subscription/Store/SubscriptionAlreadyExists.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Subscription\Store;
 6 | 
 7 | use RuntimeException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class SubscriptionAlreadyExists extends RuntimeException
12 | {
13 |     public function __construct(string $id)
14 |     {
15 |         parent::__construct(sprintf('Subscription "%s" already exists.', $id));
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Subscription/Store/SubscriptionCriteria.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Subscription\Store;
 6 | 
 7 | use Patchlevel\EventSourcing\Subscription\Status;
 8 | 
 9 | /** @psalm-immutable */
10 | final class SubscriptionCriteria
11 | {
12 |     /**
13 |      * @param list<string>|null $ids
14 |      * @param list<string>|null $groups
15 |      * @param list<Status>|null $status
16 |      */
17 |     public function __construct(
18 |         public readonly array|null $ids = null,
19 |         public readonly array|null $groups = null,
20 |         public readonly array|null $status = null,
21 |     ) {
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Subscription/Store/SubscriptionNotFound.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Subscription\Store;
 6 | 
 7 | use RuntimeException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class SubscriptionNotFound extends RuntimeException
12 | {
13 |     public function __construct(string $subscriptionId)
14 |     {
15 |         parent::__construct(sprintf('Subscription with the id "%s" not found.', $subscriptionId));
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Subscription/Store/SubscriptionStore.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Subscription\Store;
 6 | 
 7 | use Patchlevel\EventSourcing\Subscription\Subscription;
 8 | 
 9 | interface SubscriptionStore
10 | {
11 |     /** @throws SubscriptionNotFound */
12 |     public function get(string $subscriptionId): Subscription;
13 | 
14 |     /** @return list<Subscription> */
15 |     public function find(SubscriptionCriteria|null $criteria = null): array;
16 | 
17 |     /** @throws SubscriptionAlreadyExists */
18 |     public function add(Subscription $subscription): void;
19 | 
20 |     /** @throws SubscriptionNotFound */
21 |     public function update(Subscription $subscription): void;
22 | 
23 |     /** @throws SubscriptionNotFound */
24 |     public function remove(Subscription $subscription): void;
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Subscription/Store/TransactionCommitNotPossible.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Subscription\Store;
 6 | 
 7 | use RuntimeException;
 8 | use Throwable;
 9 | 
10 | final class TransactionCommitNotPossible extends RuntimeException
11 | {
12 |     public function __construct(Throwable $previous)
13 |     {
14 |         parent::__construct(
15 |             'Committing a transaction is not possible. Maybe your platform does not support transactional DDL.',
16 |             0,
17 |             $previous,
18 |         );
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Subscription/Subscriber/ArgumentResolver/AggregateIdArgumentResolver.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Subscription\Subscriber\ArgumentResolver;
 6 | 
 7 | use Patchlevel\EventSourcing\Aggregate\AggregateHeader;
 8 | use Patchlevel\EventSourcing\Aggregate\AggregateRootId;
 9 | use Patchlevel\EventSourcing\Message\Message;
10 | use Patchlevel\EventSourcing\Metadata\Subscriber\ArgumentMetadata;
11 | 
12 | use function class_exists;
13 | use function is_a;
14 | 
15 | /** @deprecated add aggregate id in your events, automatically resolving in stream store is not possible. */
16 | final class AggregateIdArgumentResolver implements ArgumentResolver
17 | {
18 |     public function resolve(ArgumentMetadata $argument, Message $message): AggregateRootId
19 |     {
20 |         /** @var class-string<AggregateRootId> $class */
21 |         $class = $argument->type;
22 |         $id = $message->header(AggregateHeader::class)->aggregateId;
23 | 
24 |         return $class::fromString($id);
25 |     }
26 | 
27 |     public function support(ArgumentMetadata $argument, string $eventClass): bool
28 |     {
29 |         return class_exists($argument->type) && is_a($argument->type, AggregateRootId::class, true);
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/Subscription/Subscriber/ArgumentResolver/ArgumentResolver.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Subscription\Subscriber\ArgumentResolver;
 6 | 
 7 | use Patchlevel\EventSourcing\Message\Message;
 8 | use Patchlevel\EventSourcing\Metadata\Subscriber\ArgumentMetadata;
 9 | 
10 | interface ArgumentResolver
11 | {
12 |     public function resolve(ArgumentMetadata $argument, Message $message): mixed;
13 | 
14 |     public function support(ArgumentMetadata $argument, string $eventClass): bool;
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Subscription/Subscriber/ArgumentResolver/EventArgumentResolver.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Subscription\Subscriber\ArgumentResolver;
 6 | 
 7 | use Patchlevel\EventSourcing\Message\Message;
 8 | use Patchlevel\EventSourcing\Metadata\Subscriber\ArgumentMetadata;
 9 | 
10 | use function class_exists;
11 | use function is_a;
12 | 
13 | final class EventArgumentResolver implements ArgumentResolver
14 | {
15 |     public function resolve(ArgumentMetadata $argument, Message $message): object
16 |     {
17 |         return $message->event();
18 |     }
19 | 
20 |     public function support(ArgumentMetadata $argument, string $eventClass): bool
21 |     {
22 |         return class_exists($argument->type) && is_a($eventClass, $argument->type, true);
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Subscription/Subscriber/ArgumentResolver/LookupResolver.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Subscription\Subscriber\ArgumentResolver;
 6 | 
 7 | use Patchlevel\EventSourcing\Message\Message;
 8 | use Patchlevel\EventSourcing\Metadata\Event\EventRegistry;
 9 | use Patchlevel\EventSourcing\Metadata\Subscriber\ArgumentMetadata;
10 | use Patchlevel\EventSourcing\Store\Store;
11 | use Patchlevel\EventSourcing\Subscription\Lookup\Lookup;
12 | 
13 | final class LookupResolver implements ArgumentResolver
14 | {
15 |     public function __construct(
16 |         private readonly Store $store,
17 |         private readonly EventRegistry|null $eventRegistry = null,
18 |     ) {
19 |     }
20 | 
21 |     public function resolve(ArgumentMetadata $argument, Message $message): Lookup
22 |     {
23 |         return new Lookup(
24 |             $this->store,
25 |             $message,
26 |             $this->eventRegistry,
27 |         );
28 |     }
29 | 
30 |     public function support(ArgumentMetadata $argument, string $eventClass): bool
31 |     {
32 |         return $argument->type === Lookup::class;
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Subscription/Subscriber/ArgumentResolver/MessageArgumentResolver.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Subscription\Subscriber\ArgumentResolver;
 6 | 
 7 | use Patchlevel\EventSourcing\Message\Message;
 8 | use Patchlevel\EventSourcing\Metadata\Subscriber\ArgumentMetadata;
 9 | 
10 | final class MessageArgumentResolver implements ArgumentResolver
11 | {
12 |     public function resolve(ArgumentMetadata $argument, Message $message): Message
13 |     {
14 |         return $message;
15 |     }
16 | 
17 |     public function support(ArgumentMetadata $argument, string $eventClass): bool
18 |     {
19 |         return $argument->type === Message::class;
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Subscription/Subscriber/ArgumentResolver/RecordedOnArgumentResolver.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Subscription\Subscriber\ArgumentResolver;
 6 | 
 7 | use DateTimeImmutable;
 8 | use Patchlevel\EventSourcing\Aggregate\AggregateHeader;
 9 | use Patchlevel\EventSourcing\Message\Message;
10 | use Patchlevel\EventSourcing\Metadata\Subscriber\ArgumentMetadata;
11 | 
12 | final class RecordedOnArgumentResolver implements ArgumentResolver
13 | {
14 |     public function resolve(ArgumentMetadata $argument, Message $message): DateTimeImmutable
15 |     {
16 |         return $message->header(AggregateHeader::class)->recordedOn;
17 |     }
18 | 
19 |     public function support(ArgumentMetadata $argument, string $eventClass): bool
20 |     {
21 |         return $argument->type === DateTimeImmutable::class;
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Subscription/Subscriber/BatchableSubscriber.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Subscription\Subscriber;
 6 | 
 7 | interface BatchableSubscriber
 8 | {
 9 |     public function beginBatch(): void;
10 | 
11 |     public function commitBatch(): void;
12 | 
13 |     public function rollbackBatch(): void;
14 | 
15 |     public function forceCommit(): bool;
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Subscription/Subscriber/DuplicateSubscriberId.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Subscription\Subscriber;
 6 | 
 7 | use RuntimeException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class DuplicateSubscriberId extends RuntimeException
12 | {
13 |     public function __construct(string $subscriberId)
14 |     {
15 |         parent::__construct(sprintf('Duplicate subscriber id "%s".', $subscriberId));
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Subscription/Subscriber/NoSuitableResolver.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Subscription\Subscriber;
 6 | 
 7 | use RuntimeException;
 8 | 
 9 | use function sprintf;
10 | 
11 | final class NoSuitableResolver extends RuntimeException
12 | {
13 |     public function __construct(string $class, string $methodName, string $argumentName)
14 |     {
15 |         parent::__construct(
16 |             sprintf(
17 |                 'No suitable resolver found for argument "%s" in method "%s" of class "%s"',
18 |                 $argumentName,
19 |                 $methodName,
20 |                 $class,
21 |             ),
22 |         );
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Subscription/Subscriber/RealSubscriberAccessor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Subscription\Subscriber;
 6 | 
 7 | /** @deprecated will be removed, use MetadataSubscriberAccessor directly */
 8 | interface RealSubscriberAccessor
 9 | {
10 |     public function realSubscriber(): object;
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Subscription/Subscriber/SubscriberAccessor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Subscription\Subscriber;
 6 | 
 7 | use Closure;
 8 | use Patchlevel\EventSourcing\Message\Message;
 9 | use Patchlevel\EventSourcing\Subscription\RunMode;
10 | 
11 | /** @deprecated will be removed, use MetadataSubscriberAccessor directly */
12 | interface SubscriberAccessor
13 | {
14 |     public function id(): string;
15 | 
16 |     public function group(): string;
17 | 
18 |     public function runMode(): RunMode;
19 | 
20 |     public function setupMethod(): Closure|null;
21 | 
22 |     public function teardownMethod(): Closure|null;
23 | 
24 |     /**
25 |      * @param class-string $eventClass
26 |      *
27 |      * @return list<Closure(Message):void>
28 |      */
29 |     public function subscribeMethods(string $eventClass): array;
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Subscription/Subscriber/SubscriberAccessorRepository.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Subscription\Subscriber;
 6 | 
 7 | interface SubscriberAccessorRepository
 8 | {
 9 |     /** @return iterable<SubscriberAccessor> */
10 |     public function all(): iterable;
11 | 
12 |     public function get(string $id): SubscriberAccessor|null;
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Subscription/Subscriber/SubscriberHelper.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Subscription\Subscriber;
 6 | 
 7 | use Patchlevel\EventSourcing\Metadata\Subscriber\AttributeSubscriberMetadataFactory;
 8 | use Patchlevel\EventSourcing\Metadata\Subscriber\SubscriberMetadata;
 9 | use Patchlevel\EventSourcing\Metadata\Subscriber\SubscriberMetadataFactory;
10 | 
11 | final class SubscriberHelper
12 | {
13 |     public function __construct(
14 |         private readonly SubscriberMetadataFactory $metadataFactory = new AttributeSubscriberMetadataFactory(),
15 |     ) {
16 |     }
17 | 
18 |     public function subscriberId(object $subscriber): string
19 |     {
20 |         return $this->metadata($subscriber)->id;
21 |     }
22 | 
23 |     private function metadata(object $subscriber): SubscriberMetadata
24 |     {
25 |         return $this->metadataFactory->metadata($subscriber::class);
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Subscription/Subscriber/SubscriberUtil.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Subscription\Subscriber;
 6 | 
 7 | use Patchlevel\EventSourcing\Metadata\Subscriber\AttributeSubscriberMetadataFactory;
 8 | use Patchlevel\EventSourcing\Metadata\Subscriber\SubscriberMetadataFactory;
 9 | 
10 | trait SubscriberUtil
11 | {
12 |     private static SubscriberMetadataFactory|null $metadataFactory = null;
13 | 
14 |     public static function setMetadataFactory(SubscriberMetadataFactory $metadataFactory): void
15 |     {
16 |         self::$metadataFactory = $metadataFactory;
17 |     }
18 | 
19 |     private static function metadataFactory(): SubscriberMetadataFactory
20 |     {
21 |         if (self::$metadataFactory === null) {
22 |             self::$metadataFactory = new AttributeSubscriberMetadataFactory();
23 |         }
24 | 
25 |         return self::$metadataFactory;
26 |     }
27 | 
28 |     private function subscriberHelper(): SubscriberHelper
29 |     {
30 |         return new SubscriberHelper(self::metadataFactory());
31 |     }
32 | 
33 |     private function subscriberId(): string
34 |     {
35 |         return $this->subscriberHelper()->subscriberId($this);
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/Subscription/SubscriptionError.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Subscription;
 6 | 
 7 | use Throwable;
 8 | 
 9 | /**
10 |  * @psalm-type Trace = array{file?: string, line?: int, function?: string, class?: string, type?: string, args?: array<array-key, mixed>}
11 |  * @psalm-type Context = array{namespace: string, short_name: string, class: class-string, message: string, code: int|string, file: string, line: int, trace: list<Trace>}
12 |  */
13 | final class SubscriptionError
14 | {
15 |     /** @param list<Context>|null $errorContext */
16 |     public function __construct(
17 |         public readonly string $errorMessage,
18 |         public readonly Status $previousStatus,
19 |         public readonly array|null $errorContext = null,
20 |     ) {
21 |     }
22 | 
23 |     public static function fromThrowable(Status $status, Throwable $error): self
24 |     {
25 |         return new self($error->getMessage(), $status, ThrowableToErrorContextTransformer::transform($error));
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Test/IncrementalRamseyUuidFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Patchlevel\EventSourcing\Test;
 6 | 
 7 | use DateTimeInterface;
 8 | use Ramsey\Uuid\Uuid;
 9 | use Ramsey\Uuid\UuidFactory;
10 | use Ramsey\Uuid\UuidInterface;
11 | 
12 | use function sprintf;
13 | use function str_pad;
14 | 
15 | use const STR_PAD_LEFT;
16 | 
17 | final class IncrementalRamseyUuidFactory extends UuidFactory
18 | {
19 |     private int $counter = 0;
20 | 
21 |     public function uuid7(DateTimeInterface|null $dateTime = null): UuidInterface
22 |     {
23 |         $number = ++$this->counter;
24 | 
25 |         $string = sprintf(
26 |             '10000000-7000-0000-0000-%s',
27 |             str_pad((string)$number, 12, '0', STR_PAD_LEFT),
28 |         );
29 | 
30 |         return Uuid::fromString($string);
31 |     }
32 | 
33 |     public function reset(): void
34 |     {
35 |         $this->counter = 0;
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------