Event sourcing: smetti di perdere la storia, usala

Event sourcing: cos'è (e no, non è solo logging)

Con event sourcing, gli eventi sono la fonte di verità. Non salvi lo "stato finale" di un oggetto, salvi tutto ciò che gli succede. Poi ricostruisci lo stato riproducendo quegli eventi. Sì, come un replay. E no, non sono "solo log": un log racconta, un evento fa fede.

Esempio base: invece di salvare balance = 120, registri MoneyDeposited(200) e poi MoneyWithdrawn(80). Il saldo è un risultato, non un numero magico uscito dal nulla.

Perché dovresti complicarti la vita?

Perché il tuo io futuro ti ringrazierà quando:

• dovrai auditare chi ha fatto cosa, quando e perché,
• vorrai debuggare riproducendo la realtà,
• ti servirà ricostruire un modello dopo cambi di business,
• vorrai proiezioni (read models) senza massacrare il database.

In breve: paghi un po' di complessità ora, per smettere di improvvisare post-mortem dopo.

I mattoni fondamentali (senza fumo)

• Evento: un fatto immutabile, al passato. OrderPlaced, non PlaceOrder.
• Stream: la sequenza di eventi di un aggregato.
• Aggregato: l'oggetto di dominio che applica gli eventi per ricostruirsi.
• Proiezione: una vista derivata (SQL, Elastic, cache, ecc.) per letture veloci.

Quando usarlo (e quando evitarlo)

Usalo se:

• il tuo dominio cambia spesso,
• la storia è critica,
• hai bisogno di tracciabilità granitica.

Evitalo se:

• il tuo CRUD è basico,
• non ti serve l'audit,
• il team sta ancora scoprendo i repository.

Mini esempio di avvio in Symfony

Facciamo semplice: un aggregato Cart, eventi e un event store in memoria. Niente CQRS completo, niente Kafka, niente magia. Solo il cuore.

1) Definire l'evento

php
1<?php
2
3namespace App\Cart\Domain\Event;
4
5final class ItemAdded
6{
7    public function __construct(
8        public readonly string $cartId,
9        public readonly string $sku,
10        public readonly int $quantity,
11    ) {
12    }
13}

2) L'aggregato che riproduce gli eventi

php
1<?php
2
3namespace App\Cart\Domain;
4
5use App\Cart\Domain\Event\ItemAdded;
6
7final class Cart
8{
9    private array $items = [];
10    private array $recordedEvents = [];
11
12    public static function reconstitute(array $events): self
13    {
14        $cart = new self();
15        foreach ($events as $event) {
16            $cart->apply($event);
17        }
18        return $cart;
19    }
20
21    public function addItem(string $cartId, string $sku, int $quantity): void
22    {
23        $event = new ItemAdded($cartId, $sku, $quantity);
24        $this->record($event);
25    }
26
27    public function recordedEvents(): array
28    {
29        return $this->recordedEvents;
30    }
31
32    private function record(object $event): void
33    {
34        $this->apply($event);
35        $this->recordedEvents[] = $event;
36    }
37
38    private function apply(object $event): void
39    {
40        if ($event instanceof ItemAdded) {
41            $this->items[$event->sku] = ($this->items[$event->sku] ?? 0) + $event->quantity;
42        }
43    }
44}

3) Un event store minimo (in memoria)

php
1<?php
2
3namespace App\Cart\Infrastructure;
4
5final class InMemoryEventStore
6{
7    private array $streams = [];
8
9    public function append(string $streamId, array $events): void
10    {
11        $this->streams[$streamId] ??= [];
12        $this->streams[$streamId] = array_merge($this->streams[$streamId], $events);
13    }
14
15    public function load(string $streamId): array
16    {
17        return $this->streams[$streamId] ?? [];
18    }
19}

4) Uso in un servizio Symfony

php
1<?php
2
3namespace App\Cart\Application;
4
5use App\Cart\Domain\Cart;
6use App\Cart\Infrastructure\InMemoryEventStore;
7
8final class AddItemToCart
9{
10    public function __construct(private InMemoryEventStore $eventStore)
11    {
12    }
13
14    public function __invoke(string $cartId, string $sku, int $quantity): void
15    {
16        $events = $this->eventStore->load($cartId);
17        $cart = Cart::reconstitute($events);
18
19        $cart->addItem($cartId, $sku, $quantity);
20
21        $this->eventStore->append($cartId, $cart->recordedEvents());
22    }
23}

Ecco. Niente ORM, niente cache, niente parata. Solo l'idea centrale: gli eventi sono la verità, lo stato è una vista calcolata. Poi puoi agganciare proiezioni e listener di Symfony Messenger se vuoi giocare con i grandi.

Da ricordare (se devi spiegarlo)

• Event sourcing salva la storia, non solo il risultato.
• Ricostruisci lo stato riproducendo gli eventi.
• Perfetto per audit e domini che cambiano, inutile per CRUD noioso.
• Symfony non lo fa al posto tuo, ma ti lascia strutturarlo bene.

Se ti sembra pesante, bene: stai scambiando comfort immediato con chiarezza a lungo termine. Paghi ora o paga il tuo io futuro. Scegli tu.