Event sourcing : arrête de perdre l'historique, utilise-le

L'event sourcing, c'est quoi (et non, ce n'est pas du logging)

En event sourcing, la source de vérité, ce sont les événements. Tu ne stockes pas "l'état final" d'un objet, tu stockes tout ce qui lui arrive. Ensuite, tu reconstruis l'état en rejouant ces événements. Oui, comme un replay. Et non, ce n'est pas "juste des logs" : un log raconte, un événement fait foi.

Exemple bête : au lieu de sauvegarder un balance = 120, tu enregistres MoneyDeposited(200) puis MoneyWithdrawn(80). Le solde est un résultat, pas une vérité magique tombée du ciel.

Pourquoi tu t'embêtes avec ça ?

Parce que ton futur toi va te remercier quand :

• tu dois auditer qui a fait quoi, quand, et pourquoi,
• tu veux debugger un bug en rejouant la réalité,
• tu dois reconstruire un modèle après un changement métier,
• tu veux brancher des projections (read models) sans massacrer ta base.

En clair : tu paies un peu de complexité maintenant, pour arrêter d'improviser des post-mortems plus tard.

Les briques à comprendre (version sans fumée)

• Événement : un fait immuable, au passé. OrderPlaced, pas PlaceOrder.
• Stream : la suite des événements d'un même agrégat.
• Agrégat : l'objet métier qui applique les événements pour se reconstruire.
• Projection : une vue dérivée (SQL, Elastic, cache, etc.) pour lire vite.

Quand l'utiliser (et quand éviter)

Tu l'utilises si :

• ton domaine change souvent,
• l'historique est critique,
• tu as besoin de traçabilité béton.

Tu l'évites si :

• ton CRUD est basique,
• tu n'as pas de besoins d'audit,
• tu ne veux pas expliquer ça à une équipe qui découvre déjà les repositories.

Mini exemple d'initiation en Symfony

On va faire simple : un agrégat Cart, des événements, et un petit event store en mémoire. Pas de CQRS complet, pas de Kafka, pas de magie. Juste le cœur.

1) Définir l'événement

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'agrégat qui rejoue les événements

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 minimal (en mémoire)

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) Usage dans un service 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}

Voilà : pas de ORM, pas de cache, pas de fanfare. Juste l'idée centrale : les événements sont la vérité, l'état est une vue calculée. Tu peux ensuite brancher des projections et des listeners Symfony Messenger si tu veux jouer avec les grands.

À retenir (si tu dois l'expliquer à quelqu'un)

• L'event sourcing stocke l'histoire, pas seulement le résultat.
• Tu reconstruis l'état en rejouant les événements.
• C'est parfait pour l'audit et l'évolution métier, inutile pour un CRUD banal.
• Symfony ne fait pas tout tout seul, mais il te laisse structurer proprement.

Si ça te paraît lourd, c'est normal : tu remplaces un confort immédiat par de la lisibilité long terme. Et ce trade-off, c'est toi qui le payes. Ou ton futur toi. À toi de voir.