Patchlevel Event Sourcing

https://github.com/patchlevel/event-sourcing
Admin
A lightweight but also all-inclusive event sourcing library with a focus on developer experience.
Tokens:174,642
Snippets:1,308
Trust Score:7.5
License:MIT
Update:3 weeks ago
Show doc for...
Tokens:
Raw
### Subscription lifecycle workflow

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/cli.md

Boots subscriptions with setup, then starts the run command, and tears down after the old application is gone.

```bash
bin/console event-sourcing:subscription:boot --setup
# start bin/console event-sourcing:subscription:run
# wait until the old application is gone
bin/console event-sourcing:subscription:teardown
```

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

### setup(SubscriptionEngineCriteria $criteria): void

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/subscription.md

Sets up new subscriptions. The engine attempts to call the 'setup' method on the subscription if available. After setup, the subscription is set to booting or active. An optional boolean parameter 'skipBooting' can be passed to skip the booting step.

```APIDOC
## setup(SubscriptionEngineCriteria $criteria): void

### Description
Sets up new subscriptions. The engine attempts to call the 'setup' method on the subscription if available. After setup, the subscription is set to booting or active. An optional boolean parameter 'skipBooting' can be passed to skip the booting step.

### Method
setup

### Endpoint
SubscriptionEngine::setup

### Parameters
#### Parameters
- **$criteria** (SubscriptionEngineCriteria) - Required - Criteria to filter subscriptions.
- **$skipBooting** (bool) - Optional - If true, skips the booting step.

### Request Example
```php
$subscriptionEngine->setup(new SubscriptionEngineCriteria());
```

### Response
#### Success Response
No return value.

```

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

### Setup subscriptions with SubscriptionEngine::setup

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/subscription.md

Calls the setup method on the SubscriptionEngine to set up new subscriptions. The engine attempts to call the 'setup' method on the subscription if available. After setup, the subscription is set to booting or active. The booting step can be skipped with the second boolean parameter 'skipBooting'.

```php
use Patchlevel\EventSourcing\Subscription\Engine\SubscriptionEngine;
use Patchlevel\EventSourcing\Subscription\Engine\SubscriptionEngineCriteria;

/** @var SubscriptionEngine $subscriptionEngine */
$subscriptionEngine->setup(new SubscriptionEngineCriteria());
```

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

### Set up subscriptions

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/cli.md

Sets up all new subscriptions. The subscription engine calls the setup method of the subscriber, if available, for example to create the table of a projection. Afterwards the subscription is booting or, depending on the run mode, already active. With --skip-booting, subscriptions skip the booting status and become active right away.

```bash
bin/console event-sourcing:subscription:setup
```

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

### Boot subscriptions with setup

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/cli.md

First sets up new subscriptions, then boots them, so both steps can be done in one call.

```bash
bin/console event-sourcing:subscription:boot --setup
```

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

### Setup method with #[Setup] attribute

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/subscription.md

Defines a setup method that runs when the subscription is created, typically used by projectors to create necessary database structures. The method name is arbitrary. Note: PostgreSQL, MySQL, and MariaDB do not support transactions for DDL statements, so a different database connection may be required.

```php
use Doctrine\DBAL\Connection;
use Patchlevel\EventSourcing\Attribute\Projector;
use Patchlevel\EventSourcing\Attribute\Setup;

#[Projector(self::TABLE)]
final class ProfileProjector
{
    private const TABLE = 'profile_v1';

    private Connection $connection;

    #[Setup]
    public function create(): void
    {
        $this->connection->executeStatement(
            sprintf('CREATE TABLE IF NOT EXISTS %s (id VARCHAR PRIMARY KEY, name VARCHAR NOT NULL);', self::TABLE),
        );
    }
}
```

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

### Install with Composer

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/introduction.md

Use this command to install the patchlevel/event-sourcing package via Composer.

```bash
composer require patchlevel/event-sourcing
```

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

### Setup SyncQueryBus with HandlerProvider

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/query-bus.md

Instantiates the SyncQueryBus with a HandlerProvider and dispatches a query. The dispatch returns the result from the handler.

```php
use Patchlevel\EventSourcing\QueryBus\HandlerProvider;
use Patchlevel\EventSourcing\QueryBus\SyncQueryBus;

/** @var HandlerProvider $handlerProvider */
$queryBus = new SyncQueryBus($handlerProvider);

$result = $queryBus->dispatch(new QueryProfile($profileId));
```

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

### Setup SyncCommandBus with HandlerProvider

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/command-bus.md

Creates a SyncCommandBus instance with a HandlerProvider and dispatches commands synchronously.

```php
use Patchlevel\EventSourcing\CommandBus\HandlerProvider;
use Patchlevel\EventSourcing\CommandBus\SyncCommandBus;

/** @var HandlerProvider $handlerProvider */
$commandBus = new SyncCommandBus($handlerProvider);

$commandBus->dispatch(new CreateProfile($profileId, 'name'));
$commandBus->dispatch(new ChangeProfileName($profileId, 'new name'));
```

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

### Get subscription statuses with SubscriptionEngine::subscriptions

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/subscription.md

Calls the subscriptions method on the SubscriptionEngine to get the current status of all subscriptions. The example iterates over the returned subscriptions and echoes the status value.

```php
use Patchlevel\EventSourcing\Subscription\Engine\SubscriptionEngine;
use Patchlevel\EventSourcing\Subscription\Engine\SubscriptionEngineCriteria;

/** @var SubscriptionEngine $subscriptionEngine */
$subscriptions = $subscriptionEngine->subscriptions(new SubscriptionEngineCriteria());

foreach ($subscriptions as $subscription) {
    echo $subscription->status()->value;
}
```

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

### React to any event with any

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/message.md

Defines a callback that is invoked for any event. The example appends the message to the state array.

```php
use Patchlevel\EventSourcing\Message\Message;
use Patchlevel\EventSourcing\Message\Reducer;

$state = (new Reducer())
    ->any(
        static function (Message $message, array $state): array {
            return [...$state, $message];
        },
    )
    ->reduce($messages);
```

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

### Lookup Resolver example in a projector

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/subscription.md

Use the Lookup service to query previous events for building projections. It only has access to messages before the current message.

```php
use Patchlevel\EventSourcing\Attribute\Projector;
use Patchlevel\EventSourcing\Attribute\Subscribe;
use Patchlevel\EventSourcing\Message\Message;
use Patchlevel\EventSourcing\Message\Reducer;
use Patchlevel\EventSourcing\Subscription\Lookup\Lookup;

#[Projector('public_profile')]
final class PublicProfileProjection
{
    // ... constructor

    #[Subscribe(Published::class)]
    public function onPublished(Lookup $lookup): void
    {
        $messages = $lookup
            ->currentAggregate() // or ->currentStream() for StreamStore
            ->events(
                ProfileCreated::class,
                ProfileNameChanged::class,
            )->fetchAll();

        $state = (new Reducer())
            ->initState([
                'id' => null,
                'name' => null,
            ])
            ->match([
                ProfileCreated::class => static function (Message $message): array {
                    return [
                        'id' => $message->event()->id->toString(),
                        'name' => $message->event()->name,
                    ];
                },
                ProfileNameChanged::class => static function (Message $message, array $prevState): array {
                    return array_merge($prevState, [
                        'name' => $message->event()->name,
                    ]);
                },
            ])
            ->reduce($messages);

        $this->connection->insert('public_profile', $state);
    }

    // ... setup, teardown, ...
}
```

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

### PipelineProcessor example using Processor and Subscribe attributes

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/UPGRADE-3.0.md

Replaces the removed Pipeline with a Processor that uses a Translator to transform messages and saves them to the Store.

```php
use Patchlevel\EventSourcing\Attribute\Processor;
use Patchlevel\EventSourcing\Attribute\Subscribe;
use Patchlevel\EventSourcing\EventBus\Message;
use Patchlevel\EventSourcing\Message\Translator\Translator;
use Patchlevel\EventSourcing\Store\Store;

#[Processor('pipeline')]
class PipelineProcessor
{
    public function __construct(
        private readonly Store $store, // new eventstore
        private readonly Translator $translator,
    ) {
    }

    #[Subscribe('*')]
    public function publish(Message $message): void
    {
        $messages = ($this->translator)($message);

        $this->store->save(...$messages);
    }
}
```

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

### Run subscriber from beginning with RunMode::FromBeginning

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/subscription.md

Starts from the beginning of the event stream and processes all events. Useful for building projections from scratch. Consider using the Projector attribute for projections.

```php
use Patchlevel\EventSourcing\Attribute\Subscriber;
use Patchlevel\EventSourcing\Subscription\RunMode;

#[Subscriber('welcome_email', RunMode::FromBeginning)]
final class WelcomeEmailSubscriber
{
   // ...
}
```

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

### Set up database schema with DoctrineSchemaDirector

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/getting-started.md

Creates the database schema for the event store and subscription store using ChainDoctrineSchemaConfigurator. The setup method with skipBooting: true is called on the subscription engine. Predefined CLI commands are available as an alternative.

```php
use Doctrine\DBAL\Connection;
use Patchlevel\EventSourcing\Schema\ChainDoctrineSchemaConfigurator;
use Patchlevel\EventSourcing\Schema\DoctrineSchemaDirector;
use Patchlevel\EventSourcing\Store\Store;
use Patchlevel\EventSourcing\Subscription\Engine\SubscriptionEngine;
use Patchlevel\EventSourcing\Subscription\Store\SubscriptionStore;

/**
 * @var Connection $connection
 * @var Store $eventStore
 * @var SubscriptionStore $subscriptionStore
 */
$schemaDirector = new DoctrineSchemaDirector(
    $connection,
    new ChainDoctrineSchemaConfigurator([
        $eventStore,
        $subscriptionStore,
    ]),
);

$schemaDirector->create();

/** @var SubscriptionEngine $engine */
$engine->setup(skipBooting: true);
```

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

### Test subscriber with SubscriberUtilities

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/testing.md

Initializes SubscriberUtilities with a subscriber instance, then calls executeSetup, executeRun, and executeTeardown to trigger the corresponding attribute-defined methods. The example asserts the subscriber's count after the run.

```php
use Patchlevel\EventSourcing\PhpUnit\Test\SubscriberUtilities;
use PHPUnit\Framework\TestCase;

final class ProfileSubscriberTest extends TestCase
{
    public function testProfileCreated(): void
    {
        $subscriber = new ProfileSubscriber(/* inject deps or mock tests as needed */);

        $util = new SubscriberUtilities($subscriber);
        $util->executeSetup();
        $util->executeRun(
            new ProfileCreated(
                ProfileId::fromString('1'),
                Email::fromString('hq@patchlevel.de'),
            ),
        );
        $util->executeTeardown();

        self::assertSame(3, $subscriber->count);
    }
}
```

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

### OutboxProcessor example using Processor and Subscribe attributes

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/UPGRADE-3.0.md

Replicates the outbox table behavior using a Processor with a Subscribe('*') method that dispatches messages to the EventBus.

```php
use Patchlevel\EventSourcing\Attribute\Processor;
use Patchlevel\EventSourcing\Attribute\Subscribe;
use Patchlevel\EventSourcing\EventBus\Message;

#[Processor('outbox')]
class OutboxProcessor
{
    public function __construct(
        private readonly EventBus $eventBus,
    ) {
    }

    #[Subscribe('*')]
    public function publish(Message $message): void
    {
        $this->eventBus->dispatch($message);
    }
}
```

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

### Before: Snapshot attribute with private properties and getter methods

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/UPGRADE-3.0.md

Shows the old style of defining an attribute with private properties and getter methods. This is the 'Before' example for the attribute changes.

```php
#[Attribute(Attribute::TARGET_CLASS)]
final class Snapshot
{
    public function __construct(
        private string $name,
        private int|null $batch = null,
        private string|null $version = null,
    ) {
    }

    public function name(): string
    {
        return $this->name;
    }

    public function batch(): int|null
    {
        return $this->batch;
    }

    public function version(): string|null
    {
        return $this->version;
    }
}
```

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

### Define HotelProjector with event subscriptions and setup/teardown

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/getting-started.md

Use this PHP class to create a projection that tracks hotels and guest counts. It subscribes to HotelCreated, GuestIsCheckedIn, and GuestIsCheckedOut events, and uses #[Setup] and #[Teardown] attributes to manage the table lifecycle. Requires a Doctrine DBAL Connection.

```php
use Doctrine\DBAL\Connection;
use Patchlevel\EventSourcing\Attribute\Projector;
use Patchlevel\EventSourcing\Attribute\Setup;
use Patchlevel\EventSourcing\Attribute\Subscribe;
use Patchlevel\EventSourcing\Attribute\Teardown;

#[Projector(self::TABLE)]
final class HotelProjector
{
    // use a const for easier access in the projector & to keep projector id and table name in sync
    private const TABLE = 'hotel';

    public function __construct(
        private readonly Connection $db,
    ) {
    }

    /** @return list<array{id: string, name: string, guests: int}> */
    public function getHotels(): array
    {
        return $this->db->fetchAllAssociative(sprintf('SELECT id, name, guests FROM %s;', self::TABLE));
    }

    #[Subscribe(HotelCreated::class)]
    public function handleHotelCreated(HotelCreated $event): void
    {
        $this->db->insert(
            self::TABLE,
            [
                'id' => $event->hotelId->toString(),
                'name' => $event->hotelName,
                'guests' => 0,
            ],
        );
    }

    #[Subscribe(GuestIsCheckedIn::class)]
    public function handleGuestIsCheckedIn(GuestIsCheckedIn $event): void
    {
        $this->db->executeStatement(
            sprintf('UPDATE %s SET guests = guests + 1 WHERE id = ?;', self::TABLE),
            [$event->hotelId->toString()],
        );
    }

    #[Subscribe(GuestIsCheckedOut::class)]
    public function handleGuestIsCheckedOut(GuestIsCheckedOut $event): void
    {
        $this->db->executeStatement(
            sprintf('UPDATE %s SET guests = guests - 1 WHERE id = ?;', self::TABLE),
            [$event->hotelId->toString()],
        );
    }

    #[Setup]
    public function create(): void
    {
        $this->db->executeStatement(sprintf('CREATE TABLE IF NOT EXISTS %s (id VARCHAR PRIMARY KEY, name VARCHAR, guests INTEGER);', self::TABLE));
    }

    #[Teardown]
    public function drop(): void
    {
        $this->db->executeStatement(sprintf('DROP TABLE IF EXISTS %s;', self::TABLE));
    }
}
```

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

### Initialize Reducer state with initState

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/message.md

Sets the initial state for the reduction. The example initializes state to ['count' => 0] and then reduces messages, resulting in state ['count' => 0].

```php
use Patchlevel\EventSourcing\Message\Reducer;

$state = (new Reducer())
    ->initState(['count' => 0])
    ->reduce($messages); // state is ['count' => 0]
```

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

### Specify normalizer via attribute

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/normalizer.md

Equivalent to the previous example, but explicitly specifies the DateTimeImmutableNormalizer using the attribute. Useful when the type hint is not enough or to be explicit.

```php
use Patchlevel\Hydrator\Normalizer\DateTimeImmutableNormalizer;

final class DTO
{
    #[DateTimeImmutableNormalizer]
    public DateTimeImmutable $date;
}
```

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

### Command bus with extra parameters passed to when()

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/testing.md

If additional parameters are required beyond the command, provide them as extra arguments to when(). These are passed directly to the event handler. In this example, a string is passed and included in the resulting event.

```php
use Patchlevel\EventSourcing\PhpUnit\Test\AggregateRootTestCase;

final class ProfileTest extends AggregateRootTestCase
{
    // protected function aggregateClass(): string;

    public function testBehaviour(): void
    {
        $this
            ->given(
                new ProfileCreated(
                    ProfileId::fromString('1'),
                    Email::fromString('hq@patchlevel.de'),
                ),
            )
            ->when(
                new VisitProfile(ProfileId::fromString('2')),
                'Extra Parameter / Dependency',
            )
            ->then(
                new ProfileVisited(ProfileId::fromString('2'), 'Extra Parameter / Dependency'),
                static fn (Profile $profile) => self::assertSame(1, $profile->visited()),
            );
    }
}
```

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

### Use IncrementalRamseyUuidFactory for deterministic UUIDs in PHPUnit tests

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/testing.md

Set the IncrementalRamseyUuidFactory in setUp to generate deterministic UUIDs. The factory is only for testing purposes and supports only UUID version 7. The example shows generated IDs like 10000000-7000-0000-0000-000000000001.

```php
use Patchlevel\EventSourcing\Test\IncrementalRamseyUuidFactory;
use PHPUnit\Framework\TestCase;
use Ramsey\Uuid\Uuid;

final class ProfileTest extends TestCase
{
    public function setUp(): void
    {
        Uuid::setFactory(new IncrementalRamseyUuidFactory());
    }

    public function testCreateProfile(): void
    {
        $id1 = ProfileId::generate(); // 10000000-7000-0000-0000-000000000001
        $id2 = ProfileId::generate(); // 10000000-7000-0000-0000-000000000002
    }
}
```

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

### Using SystemClock to get current datetime

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/clock.md

Creates a SystemClock instance and calls now() to get the current DateTimeImmutable. Each call returns a new instance, so comparisons with == and === both return false.

```php
use Patchlevel\EventSourcing\Clock\SystemClock;

$clock = new SystemClock();
$date = $clock->now(); // get the actual datetime
$date2 = $clock->now();

// $date == $date2 => false
// $date === $date2 => false
```

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

### boot(SubscriptionEngineCriteria $criteria): void

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/subscription.md

Boots the subscriptions. All booting subscriptions will catch up to the current event stream. After the boot process, the subscription is set to active or finished.

```APIDOC
## boot(SubscriptionEngineCriteria $criteria): void

### Description
Boots the subscriptions. All booting subscriptions will catch up to the current event stream. After the boot process, the subscription is set to active or finished.

### Method
boot

### Endpoint
SubscriptionEngine::boot

### Parameters
#### Parameters
- **$criteria** (SubscriptionEngineCriteria) - Required - Criteria to filter subscriptions.

### Request Example
```php
$subscriptionEngine->boot(new SubscriptionEngineCriteria());
```

### Response
#### Success Response
No return value.

```

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

### Register and Run StoreMigrateCommand (event-sourcing:store:migrate)

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/cli.md

Registers the StoreMigrateCommand and shows how to run it with a custom buffer size. The third constructor argument is a list of translators applied to every message before writing to the new store; AggregateToStreamHeaderTranslator is needed for migrating to StreamDoctrineDbalStore. The command writes into the target store without cleaning it first, so ensure the target store is empty and backed up, and that its schema exists before running.

```php
use Patchlevel\EventSourcing\Console\Command\StoreMigrateCommand;
use Patchlevel\EventSourcing\Message\Translator\AggregateToStreamHeaderTranslator;
use Patchlevel\EventSourcing\Store\Store;
use Symfony\Component\Console\Application;

/**
 * @var Application $cli
 * @var Store $oldStore
 * @var Store $newStore
 */
$cli->add(
    new StoreMigrateCommand(
        $oldStore,
        $newStore,
        [new AggregateToStreamHeaderTranslator()],
    ),
);
```

```bash
bin/console event-sourcing:store:migrate --buffer=5000
```

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

### Boot subscriptions with SubscriptionEngine::boot

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/subscription.md

Calls the boot method on the SubscriptionEngine. All booting subscriptions will catch up to the current event stream. After booting, the subscription is set to active or finished.

```php
use Patchlevel\EventSourcing\Subscription\Engine\SubscriptionEngine;
use Patchlevel\EventSourcing\Subscription\Engine\SubscriptionEngineCriteria;

/** @var SubscriptionEngine $subscriptionEngine */
$subscriptionEngine->boot(new SubscriptionEngineCriteria());
```

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

### Recorded On Resolver example

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/subscription.md

The recorded on resolver resolves the recorded on date by looking for a parameter with type DateTimeImmutable.

```php
use Patchlevel\EventSourcing\Attribute\Subscribe;
use Patchlevel\EventSourcing\Attribute\Subscriber;
use Patchlevel\EventSourcing\Subscription\RunMode;

#[Subscriber('do_stuff', RunMode::Once)]
final class DoStuffSubscriber
{
    #[Subscribe(ProfileCreated::class)]
    public function onProfileCreated(DateTimeImmutable $recordedOn): void
    {
        // do something
    }
}
```

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

### Create schema

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/cli.md

Creates all tables required by the library. Use once when setting up a new database.

```bash
bin/console event-sourcing:schema:create
```

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

### Event Resolver example

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/subscription.md

The event resolver resolves the event object by looking for a parameter with the type of the event.

```php
use Patchlevel\EventSourcing\Attribute\Subscribe;
use Patchlevel\EventSourcing\Attribute\Subscriber;
use Patchlevel\EventSourcing\Subscription\RunMode;

#[Subscriber('do_stuff', RunMode::Once)]
final class DoStuffSubscriber
{
    #[Subscribe(ProfileCreated::class)]
    public function onProfileCreated(ProfileCreated $profileCreated): void
    {
        // do something
    }
}
```

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

### Message Resolver example

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/subscription.md

The message resolver resolves the Message object by looking for a parameter with type Message.

```php
use Patchlevel\EventSourcing\Attribute\Subscribe;
use Patchlevel\EventSourcing\Attribute\Subscriber;
use Patchlevel\EventSourcing\Message\Message;
use Patchlevel\EventSourcing\Subscription\RunMode;

#[Subscriber('do_stuff', RunMode::Once)]
final class DoStuffSubscriber
{
    #[Subscribe(ProfileCreated::class)]
    public function onProfileCreated(Message $message): void
    {
        // do something
    }
}
```

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

### reactivate(SubscriptionEngineCriteria $criteria): void

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/subscription.md

Reactivates a subscription that had an error or is outdated. As a result, the subscription gets in the last status again.

```APIDOC
## reactivate(SubscriptionEngineCriteria $criteria): void

### Description
Reactivates a subscription that had an error or is outdated. As a result, the subscription gets in the last status again.

### Method
reactivate

### Endpoint
SubscriptionEngine::reactivate

### Parameters
#### Parameters
- **$criteria** (SubscriptionEngineCriteria) - Required - Criteria to filter subscriptions.

### Request Example
```php
$subscriptionEngine->reactivate(new SubscriptionEngineCriteria());
```

### Response
#### Success Response
No return value.

```

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

### DoctrineSubscriptionStore instantiation

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/subscription.md

Creates a DoctrineSubscriptionStore to store subscription statuses. Requires a DBAL Connection.

```php
use Doctrine\DBAL\Connection;
use Patchlevel\EventSourcing\Subscription\Store\DoctrineSubscriptionStore;

/** @var Connection $connection */
$subscriptionStore = new DoctrineSubscriptionStore($connection);
```

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

### Reducer::initState

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/message.md

Sets the initial state for the reduction process. The state is used as the starting point when reducing messages.

```APIDOC
## Reducer::initState

### Description
Sets the initial state for the reduction process. The state is used as the starting point when reducing messages.

### Method
initState

### Parameters
- **state** (array) - Required - The initial state array.

### Returns
- **Reducer** - The Reducer instance for chaining.

### Example
```php
$state = (new Reducer())
    ->initState(['count' => 0])
    ->reduce($messages); // state is ['count' => 0]
```
```

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

### Set up Event Sourcing CLI with Symfony Console

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/cli.md

Creates a Symfony Console application and registers all core Event Sourcing commands. Requires a Doctrine DBAL connection, store, and various services. Note that SubscriptionBootCommand and SubscriptionRunCommand accept an optional PSR-14 event dispatcher as the last argument.

```php
use Doctrine\DBAL\Connection;
use Patchlevel\EventSourcing\Console\Command;
use Patchlevel\EventSourcing\Console\DoctrineHelper;
use Patchlevel\EventSourcing\Message\Serializer\HeadersSerializer;
use Patchlevel\EventSourcing\Metadata\AggregateRoot\AggregateRootRegistry;
use Patchlevel\EventSourcing\Metadata\Event\EventRegistry;
use Patchlevel\EventSourcing\Schema\DoctrineSchemaDirector;
use Patchlevel\EventSourcing\Serializer\EventSerializer;
use Patchlevel\EventSourcing\Store\Store;
use Patchlevel\EventSourcing\Subscription\Engine\SubscriptionEngine;
use Patchlevel\EventSourcing\Subscription\Subscriber\SubscriberAccessorRepository;
use Symfony\Component\Console\Application;

$cli = new Application('Event-Sourcing CLI');
$cli->setCatchExceptions(true);

$doctrineHelper = new DoctrineHelper();

/**
 * @var Connection $connection
 * @var Store $store
 */
$schemaDirector = new DoctrineSchemaDirector($connection, $store);

/**
 * @var SubscriptionEngine $subscriptionEngine
 * @var EventSerializer $eventSerializer
 * @var HeadersSerializer $headersSerializer
 * @var AggregateRootRegistry $aggregateRootRegistry
 * @var EventRegistry $eventRegistry
 * @var SubscriberAccessorRepository $subscriberAccessorRepository
 */
$cli->addCommands([
    new Command\DatabaseCreateCommand($connection, $doctrineHelper),
    new Command\DatabaseDropCommand($connection, $doctrineHelper),
    new Command\SchemaCreateCommand($schemaDirector),
    new Command\SchemaDropCommand($schemaDirector),
    new Command\SchemaUpdateCommand($schemaDirector),
    new Command\SubscriptionSetupCommand($subscriptionEngine),
    new Command\SubscriptionBootCommand($subscriptionEngine),
    new Command\SubscriptionRunCommand($subscriptionEngine, $store),
    new Command\SubscriptionStatusCommand($subscriptionEngine),
    new Command\SubscriptionPauseCommand($subscriptionEngine),
    new Command\SubscriptionReactivateCommand($subscriptionEngine),
    new Command\SubscriptionRefreshCommand($subscriptionEngine),
    new Command\SubscriptionTeardownCommand($subscriptionEngine),
    new Command\SubscriptionRemoveCommand($subscriptionEngine),
    new Command\ShowCommand($store, $eventSerializer, $headersSerializer),
    new Command\ShowAggregateCommand($store, $eventSerializer, $headersSerializer, $aggregateRootRegistry),
    new Command\WatchCommand($store, $eventSerializer, $headersSerializer),
    new Command\DebugCommand($aggregateRootRegistry, $eventRegistry, $subscriberAccessorRepository),
]);

$cli->run();
```

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

### Event with normalized property

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/normalizer.md

Example of an event class where the createdAt property is normalized to a payload for storage in the DB and denormalized when loading.

```php
use Patchlevel\EventSourcing\Attribute\Event;
use Patchlevel\Hydrator\Normalizer\DateTimeImmutableNormalizer;

#[Event('hotel.created')]
final class HotelCreated
{
    public function __construct(
        public readonly string $name,
        #[DateTimeImmutableNormalizer]
        public readonly DateTimeImmutable $createdAt,
    ) {
    }
}
```

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

### Build aggregate criteria with CriteriaBuilder

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/store.md

Builds the same aggregate criteria using the CriteriaBuilder fluent interface. Equivalent to the constructor-based Criteria example.

```php
use Patchlevel\EventSourcing\Store\Criteria\CriteriaBuilder;

$criteria = (new CriteriaBuilder())
    ->aggregateName('profile')
    ->aggregateId('e3e3e3e3-3e3e-3e3e-3e3e-3e3e3e3e3e3e')
    ->fromPlayhead(2)
    ->fromIndex(100)
    ->archived(true)
    ->events(['profile.created', 'profile.name_changed'])
    ->build();
```

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

### Configure DefaultSnapshotStore with Psr16SnapshotAdapter

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/snapshots.md

Creates a snapshot store with named adapters for different caches. Each adapter is a Psr16SnapshotAdapter wrapping a PSR-16 cache instance, and the store maps names like 'default' and 'other_cache' to those adapters.

```php
use Patchlevel\EventSourcing\Snapshot\Adapter\Psr16SnapshotAdapter;
use Patchlevel\EventSourcing\Snapshot\DefaultSnapshotStore;

$snapshotStore = new DefaultSnapshotStore([
    'default' => new Psr16SnapshotAdapter($defaultCache),
    'other_cache' => new Psr16SnapshotAdapter($otherCache),
]);
```

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

### Ignore property with Ignore attribute

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/normalizer.md

Use the Ignore attribute to exclude a property from normalization. The example shows ignoring the 'name' property.

```php
use Patchlevel\Hydrator\Attribute\Ignore;

final class DTO
{
    #[Ignore]
    public string $name;
}
```

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

### Configure Event Sourcing Components with Doctrine and Subscription Engine

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/getting-started.md

Sets up the database connections, event store, serializer, repository manager, and subscription engine. Uses Doctrine DBAL and Patchlevel Event Sourcing classes. The RunSubscriptionEngineRepositoryManager triggers the subscription engine when an aggregate is saved.

```php
use Doctrine\DBAL\DriverManager;
use Doctrine\DBAL\Tools\DsnParser;
use Patchlevel\EventSourcing\Metadata\AggregateRoot\AttributeAggregateRootRegistryFactory;
use Patchlevel\EventSourcing\Repository\DefaultRepositoryManager;
use Patchlevel\EventSourcing\Serializer\DefaultEventSerializer;
use Patchlevel\EventSourcing\Store\DoctrineDbalStore;
use Patchlevel\EventSourcing\Subscription\Engine\DefaultSubscriptionEngine;
use Patchlevel\EventSourcing\Subscription\Engine\StoreMessageLoader;
use Patchlevel\EventSourcing\Subscription\Repository\RunSubscriptionEngineRepositoryManager;
use Patchlevel\EventSourcing\Subscription\Store\DoctrineSubscriptionStore;
use Patchlevel\EventSourcing\Subscription\Subscriber\MetadataSubscriberAccessorRepository;

$connection = DriverManager::getConnection(
    (new DsnParser())->parse('pdo-pgsql://user:secret@localhost/app'),
);

$projectionConnection = DriverManager::getConnection(
    (new DsnParser())->parse('pdo-pgsql://user:secret@localhost/projection'),
);

/* your own mailer */
$mailer;

$serializer = DefaultEventSerializer::createFromPaths(['src/Domain/Hotel/Event']);
$aggregateRegistry = (new AttributeAggregateRootRegistryFactory())->create(['src/Domain/Hotel']);

$eventStore = new DoctrineDbalStore(
    $connection,
    $serializer,
);

$hotelProjector = new HotelProjector($projectionConnection);

$subscriberRepository = new MetadataSubscriberAccessorRepository([
    $hotelProjector,
    new SendCheckInEmailProcessor($mailer),
]);

$subscriptionStore = new DoctrineSubscriptionStore($connection);

$engine = new DefaultSubscriptionEngine(
    new StoreMessageLoader($eventStore),
    $subscriptionStore,
    $subscriberRepository,
);

$repositoryManager = new RunSubscriptionEngineRepositoryManager(
    new DefaultRepositoryManager(
        $aggregateRegistry,
        $eventStore,
    ),
    $engine,
);

$hotelRepository = $repositoryManager->get(Hotel::class);
```

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

### Create DefaultSubscriptionEngine

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/subscription.md

Assembles the subscription engine with required services: message loader, subscription store, subscriber accessor repository, optional retry strategy, optional logger, and optional cleaner.

```php
use Doctrine\DBAL\Connection;
use Patchlevel\EventSourcing\Subscription\Cleanup\Dbal\DbalCleanupTaskHandler;
use Patchlevel\EventSourcing\Subscription\Cleanup\DefaultCleaner;
use Patchlevel\EventSourcing\Subscription\Engine\DefaultSubscriptionEngine;
use Patchlevel\EventSourcing\Subscription\Engine\MessageLoader;
use Patchlevel\EventSourcing\Subscription\RetryStrategy\RetryStrategyRepository;
use Patchlevel\EventSourcing\Subscription\Store\DoctrineSubscriptionStore;
use Patchlevel\EventSourcing\Subscription\Subscriber\MetadataSubscriberAccessorRepository;
use Psr\Log\LoggerInterface;

/**
 * @var MessageLoader $messageLoader
 * @var DoctrineSubscriptionStore $subscriptionStore
 * @var MetadataSubscriberAccessorRepository $subscriberAccessorRepository
 * @var RetryStrategyRepository $retryStrategyRepository
 * @var LoggerInterface $logger
 * @var Connection $projectionConnection
 */
$subscriptionEngine = new DefaultSubscriptionEngine(
    $messageLoader,
    $subscriptionStore,
    $subscriberAccessorRepository,
    $retryStrategyRepository, // optional, if not set the default retry strategy is used
    $logger, // optional
    new DefaultCleaner([new DbalCleanupTaskHandler($projectionConnection)]), // optional but required if you want to use the cleanup feature
);
```

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

### Finalize state after reduction

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/message.md

Defines a callback that processes the final state after reduction. The example counts the messages in the state and returns a new state with that count.

```php
use Patchlevel\EventSourcing\Message\Reducer;

$state = (new Reducer())
    ->finalize(
        static function (array $state): array {
            return ['count' => count($state['messages'])];
        },
    )
    ->reduce($messages); // state is ['count' => 2]
```

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

### Auto Initialize aggregate with #[AutoInitialize] attribute

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/aggregate.md

Mark a static method with #[AutoInitialize] to automatically create the aggregate if it is not found in the store. The method must receive the aggregate ID and return an instance of the aggregate. Recording events in the initialize method is optional but recommended.

```php
use Patchlevel\EventSourcing\Aggregate\BasicAggregateRoot;
use Patchlevel\EventSourcing\Aggregate\Uuid;
use Patchlevel\EventSourcing\Attribute\Aggregate;
use Patchlevel\EventSourcing\Attribute\Apply;
use Patchlevel\EventSourcing\Attribute\AutoInitialize;
use Patchlevel\EventSourcing\Attribute\Id;

#[Aggregate('profile')]
final class Profile extends BasicAggregateRoot
{
    #[Id]
    private Uuid $id;

    #[AutoInitialize]
    public static function initialize(Uuid $id): static
    {
        $self = new static();
        $self->recordThat(new ProfileCreated($id));

        return $self;
    }

    #[Apply]
    public function applyProfileCreated(ProfileCreated $event): void
    {
        $this->id = $event->id;
    }
}
```

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

### Instantiate InMemoryStore

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/store.md

Creates an in-memory store for testing purposes. You can pass messages to the constructor to initialize the store with some events.

```php
use Patchlevel\EventSourcing\Store\InMemoryStore;

$store = new InMemoryStore();
```

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

### Create a repository with DefaultRepositoryManager

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/repository.md

Creates a repository for an aggregate using the DefaultRepositoryManager, which requires an AggregateRootRegistry and a Store. The same repository instance is returned for a specific aggregate.

```php
use Patchlevel\EventSourcing\Metadata\AggregateRoot\AggregateRootRegistry;
use Patchlevel\EventSourcing\Repository\DefaultRepositoryManager;
use Patchlevel\EventSourcing\Store\Store;

/**
 * @var AggregateRootRegistry $aggregateRootRegistry
 * @var Store $store
 */
$repositoryManager = new DefaultRepositoryManager(
    $aggregateRootRegistry,
    $store,
);

$repository = $repositoryManager->get(Profile::class);
```

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

### Access message headers

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/message.md

Shows how to retrieve a specific header, check for its existence, and get all headers. The header method returns the header object or throws if not present.

```php
use Patchlevel\EventSourcing\Aggregate\AggregateHeader;
use Patchlevel\EventSourcing\Message\Message;

/** @var Message $message */
$message->header(AggregateHeader::class); // AggregateHeader object
$message->hasHeader(AggregateHeader::class); // true
$message->headers(); // [AggregateHeader object]
```

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

### Create a repository with snapshot store

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/repository.md

Adds a snapshot store to the DefaultRepositoryManager to speed up aggregate loading. Uses Psr16SnapshotAdapter and DefaultSnapshotStore with a 'default' adapter.

```php
use Patchlevel\EventSourcing\Metadata\AggregateRoot\AggregateRootRegistry;
use Patchlevel\EventSourcing\Repository\DefaultRepositoryManager;
use Patchlevel\EventSourcing\Snapshot\Adapter\Psr16SnapshotAdapter;
use Patchlevel\EventSourcing\Snapshot\DefaultSnapshotStore;
use Patchlevel\EventSourcing\Store\Store;

$adapter = new Psr16SnapshotAdapter($cache);
$snapshotStore = new DefaultSnapshotStore(['default' => $adapter]);

/**
 * @var AggregateRootRegistry $aggregateRootRegistry
 * @var Store $store
 */
$repositoryManager = new DefaultRepositoryManager(
    $aggregateRootRegistry,
    $store,
    null,
    $snapshotStore,
);

$repository = $repositoryManager->get(Profile::class);
```

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

### Using a clock to get the current time

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/aggregate.md

Shows how to use a PSR-20 ClockInterface to obtain the current time, allowing the caller to pass a SystemClock or FrozenClock for testing.

```php
use Patchlevel\EventSourcing\Aggregate\BasicAggregateRoot;
use Patchlevel\EventSourcing\Aggregate\Uuid;
use Patchlevel\EventSourcing\Attribute\Aggregate;
use Patchlevel\EventSourcing\Attribute\Id;
use Psr\Clock\ClockInterface;

#[Aggregate('profile')]
final class Profile extends BasicAggregateRoot
{
    #[Id]
    private Uuid $id;
    private Name $name;
    private DateTimeImmutable $registeredAt;

    public static function register(Uuid $id, string $name, ClockInterface $clock): static
    {
        $self = new static();
        $self->recordThat(new ProfileRegistered($id, $name, $clock->now()));

        return $self;
    }

    // ...
}
```

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

### Save an aggregate using a repository

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/aggregate.md

Shows a command handler that creates a Profile aggregate and saves it via a Repository. The repository only stores events, so nothing is persisted until events are added.

```php
use Patchlevel\EventSourcing\Repository\Repository;

final class CreateProfileHandler
{
    public function __construct(
        private readonly Repository $profileRepository,
    ) {
    }

    public function __invoke(CreateProfile $command): void
    {
        $profile = Profile::register($command->id());

        $this->profileRepository->save($profile);
    }
}
```

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

### Customize field name with NormalizedName attribute

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/normalizer.md

Use the NormalizedName attribute to change the field name in the normalized result. The example shows renaming 'name' to 'profile_name'.

```php
use Patchlevel\Hydrator\Attribute\NormalizedName;

final class DTO
{
    #[NormalizedName('profile_name')]
    public string $name;
}
```

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

### Configure Serializer with UpcasterChain

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/upcasting.md

Shows how to instantiate an UpcasterChain with the defined upcasters and pass it to DefaultEventSerializer::createFromPaths. The serializer is created from paths in 'src/Domain'.

```php
use Patchlevel\EventSourcing\Metadata\Event\EventRegistry;
use Patchlevel\EventSourcing\Serializer\DefaultEventSerializer;
use Patchlevel\EventSourcing\Serializer\Upcast\UpcasterChain;

/** @var EventRegistry $eventRegistry */
$upcaster = new UpcasterChain([
    new ProfileCreatedEmailLowerCastUpcaster(),
    new EventNameRenameUpcaster(['old_event_name' => 'new_event_name']),
]);

$serializer = DefaultEventSerializer::createFromPaths(
    ['src/Domain'],
    $upcaster,
);
```

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

### Create Psr16SnapshotAdapter

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/snapshots.md

Creates a snapshot adapter based on the PSR-16 caching standard. Requires a CacheInterface instance.

```php
use Patchlevel\EventSourcing\Snapshot\Adapter\Psr16SnapshotAdapter;
use Psr\SimpleCache\CacheInterface;

/** @var CacheInterface $cache */
$adapter = new Psr16SnapshotAdapter($cache);
```

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

### Custom listener provider implementation

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/event-bus.md

Defines an anonymous class implementing ListenerProvider. The listenersForEvent method returns a list of ListenerDescriptor objects. Use $listenerDescriptor->name() to get the listener name.

```php
use Patchlevel\EventSourcing\EventBus\ListenerDescriptor;
use Patchlevel\EventSourcing\EventBus\ListenerProvider;

$listenerProvider = new class implements ListenerProvider {
    public function listenersForEvent(string $eventClass): iterable
    {
        return [
            new ListenerDescriptor(
                (new WelcomeSubscriber())->onProfileCreated(...),
            ),
        ];
    }
};
```

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

### Create InMemorySnapshotAdapter

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/snapshots.md

Creates an in-memory snapshot adapter intended for test purposes.

```php
use Patchlevel\EventSourcing\Snapshot\Adapter\InMemorySnapshotAdapter;

$adapter = new InMemorySnapshotAdapter();
```

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

### Define multiple event handlers with match

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/message.md

Defines multiple event handlers at once using an associative array mapping event classes to callbacks. The example adds the message to the state array.

```php
use Patchlevel\EventSourcing\Message\Message;
use Patchlevel\EventSourcing\Message\Reducer;

$state = (new Reducer())
    ->match([
        ProfileCreated::class => static function (Message $message, array $state): array {
            return [...$state, $message];
        },
    ])
    ->reduce($messages);
```

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

### After: Snapshot attribute with public readonly properties

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/UPGRADE-3.0.md

Shows the new style of defining an attribute with public readonly properties, eliminating the need for getter methods. This is the 'After' example for the attribute changes.

```php
#[Attribute(Attribute::TARGET_CLASS)]
final class Snapshot
{
    public function __construct(
        public readonly string $name,
        public readonly int|null $batch = null,
        public readonly string|null $version = null,
    ) {
    }
}
```

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

### Run subscriber from now with RunMode::FromNow

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/subscription.md

Operates exclusively on post-release events, ignoring historical data. Useful for subscribers interested only in events after a certain point. Consider using the Processor attribute.

```php
use Patchlevel\EventSourcing\Attribute\Subscriber;
use Patchlevel\EventSourcing\Subscription\RunMode;

#[Subscriber('welcome_email', RunMode::FromNow)]
final class WelcomeEmailSubscriber
{
   // ...
}
```

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

### Exclude archived events with ArchivedCriterion

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/store.md

Loads events while explicitly excluding archived events via ArchivedCriterion(false). Archived events get the ArchivedHeader when loaded again; pass ArchivedCriterion(true) to include them for replay.

```php
use Patchlevel\EventSourcing\Store\Criteria\ArchivedCriterion;
use Patchlevel\EventSourcing\Store\Criteria\Criteria;
use Patchlevel\EventSourcing\Store\Store;

/** @var Store $store */
$stream = $store->load(new Criteria(new ArchivedCriterion(false)));
```

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

### Configure RetryStrategyRepository with named strategies

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/subscription.md

Creates a RetryStrategyRepository with two named strategies: 'default' using ClockBasedRetryStrategy and 'no_retry' using NoRetryStrategy. This is the default configuration if not defined, and the default strategy can be changed by passing a name as the second constructor parameter.

```php
use Patchlevel\EventSourcing\Subscription\RetryStrategy\ClockBasedRetryStrategy;
use Patchlevel\EventSourcing\Subscription\RetryStrategy\NoRetryStrategy;
use Patchlevel\EventSourcing\Subscription\RetryStrategy\RetryStrategyRepository;

$retryStrategyRepository = new RetryStrategyRepository([
    'default' => new ClockBasedRetryStrategy(
        baseDelay: 5,
        delayFactor: 2,
        maxAttempts: 5,
    ),
    'no_retry' => new NoRetryStrategy(),
]);
```

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

### Test aggregate with FrozenClock

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/testing.md

Uses a FrozenClock to control time in an aggregate test. The clock is passed to the aggregate and to the when() method, allowing assertions on time-dependent events. The example sleeps the clock to simulate time passing.

```php
use Patchlevel\EventSourcing\Clock\FrozenClock;
use Patchlevel\EventSourcing\PhpUnit\Test\AggregateRootTestCase;

final class ProfileTest extends AggregateRootTestCase
{
    // protected function aggregateClass(): string;

    public function testCreateProfile(): void
    {
        $clock = new FrozenClock(new DateTimeImmutable('2021-01-01 00:00:00'));

        $profile = Profile::createProfile(
            ProfileId::generate(),
            Email::fromString('info@patchlevel.de'),
            $clock,
        );

        $clock->sleep(10);

        $profile->changeEmail(Email::fromString('info@patchlevel.de'));

        $this
            ->given(new ProfileCreated(ProfileId::fromString('1'), Email::fromString('hq@patchlevel.de')))
            ->when(
                new ChangeEmail(ProfileId::fromString('1'), Email::fromString('new-hq@patchlevel.de')),
                $clock,
            )
            ->then(
                new EmailChanged(
                    ProfileId::fromString('1'),
                    Email::fromString('new-hq@patchlevel.de'),
                    new DateTimeImmutable('2021-01-01 00:00:10'),
                ),
                static fn (Profile $profile) => self::assertSame('new-hq@patchlevel.de', $profile->email()->toString()),
            );
    }
}
```

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

### Create schema with SchemaDirector::create

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/store.md

Creates the database schema from scratch using the SchemaDirector's create method. This is the primary way to set up the required tables for event sourcing.

```php
use Patchlevel\EventSourcing\Schema\SchemaDirector;

/** @var SchemaDirector $schemaDirector */
$schemaDirector->create();
```

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

### Select retry strategy with RetryStrategy attribute

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/subscription.md

Use the RetryStrategy attribute to select a preconfigured retry strategy for a subscriber. The 'default' strategy retries 5 times, while 'no_retry' does not retry. This example uses the 'default' strategy.

```php
use Patchlevel\EventSourcing\Attribute\RetryStrategy;
use Patchlevel\EventSourcing\Attribute\Subscribe;
use Patchlevel\EventSourcing\Attribute\Subscriber;
use Patchlevel\EventSourcing\Message\Message;
use Patchlevel\EventSourcing\Subscription\RunMode;

#[Subscriber('welcome_email', RunMode::FromNow)]
#[RetryStrategy('default')]
final class WelcomeSubscriber
{
    #[Subscribe('*')]
    public function onProfileCreated(Message $message): void
    {
        echo 'Welcome!';
    }
}
```

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

### Configure ClockBasedRetryStrategy

Source: https://github.com/patchlevel/event-sourcing/blob/3.23.x/docs/subscription.md

Creates a ClockBasedRetryStrategy with a base delay of 5 seconds, a delay factor of 2, and a maximum of 5 attempts. This is the default retry strategy.

```php
use Patchlevel\EventSourcing\Subscription\RetryStrategy\ClockBasedRetryStrategy;

$retryStrategy = new ClockBasedRetryStrategy(
    baseDelay: 5,
    delayFactor: 2,
    maxAttempts: 5,
);
```
Tokens:
Raw