Event sourcing: deja de perder el historial y úsalo

Event sourcing: qué es (y no, no es solo logging)

Con event sourcing, los eventos son la fuente de verdad. No guardas el "estado final" de un objeto, guardas todo lo que le pasa. Luego reconstruyes el estado reproduciendo esos eventos. Sí, como un replay. Y no, no es "solo logs": un log cuenta, un evento es la verdad.

Ejemplo básico: en vez de guardar balance = 120, registras MoneyDeposited(200) y luego MoneyWithdrawn(80). El saldo es un resultado, no un número mágico salido de la nada.

¿Por qué te complicas la vida?

Porque tu yo del futuro te lo agradecerá cuando:

• tengas que auditar quién hizo qué, cuándo y por qué,
• quieras debuggear reproduciendo la realidad,
• necesites reconstruir un modelo tras cambios de negocio,
• quieras proyecciones (read models) sin destrozar tu base.

En resumen: pagas un poco de complejidad ahora, para dejar de improvisar autopsias después.

Las piezas clave (sin humo)

• Evento: un hecho inmutable, en pasado. OrderPlaced, no PlaceOrder.
• Stream: la secuencia de eventos de un agregado.
• Agregado: el objeto de dominio que aplica eventos para reconstruirse.
• Proyección: una vista derivada (SQL, Elastic, caché, etc.) para leer rápido.

Cuándo usarlo (y cuándo evitarlo)

Úsalo si:

• tu dominio cambia a menudo,
• el historial es crítico,
• necesitas trazabilidad de acero.

Evítalo si:

• tu CRUD es básico,
• no necesitas auditoría,
• tu equipo todavía descubre los repositorios.

Mini ejemplo de iniciación en Symfony

Vamos al grano: un agregado Cart, eventos y un event store en memoria. Nada de CQRS completo, nada de Kafka, nada de magia. Solo el núcleo.

1) Definir el 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) El agregado que reproduce eventos

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 mínimo (en 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 en un servicio 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}

Listo. Ni ORM, ni caché, ni desfile. Solo la idea central: los eventos son la verdad, el estado es una vista calculada. Luego puedes enchufar proyecciones y listeners de Symfony Messenger si quieres jugar con los mayores.

Para llevar (por si tienes que explicarlo)

• Event sourcing guarda historia, no solo el resultado.
• Reconstruyes el estado reproduciendo eventos.
• Es genial para auditoría y dominios que cambian, inútil para CRUD aburrido.
• Symfony no lo hace por ti, pero te deja estructurarlo limpio.

Si te parece pesado, bien: estás cambiando comodidad inmediata por claridad a largo plazo. Pagas el coste ahora o lo paga tu yo del futuro. Tú decides.