Event sourcing: इतिहास खोना बंद करो, उसे इस्तेमाल करो

Event sourcing क्या है (और नहीं, ये सिर्फ logging नहीं है)

Event sourcing में events ही source of truth होते हैं। तुम किसी object का "final state" नहीं रखते, बल्कि जो कुछ भी उसके साथ होता है वो save करते हो। फिर उन्हीं events को replay करके state बनाते हो। हां, जैसे replay. और नहीं, ये "बस logs" नहीं हैं: log कहानी बताता है, event सच होता है।

सरल उदाहरण: balance = 120 सेव करने की जगह तुम MoneyDeposited(200) और फिर MoneyWithdrawn(80) रिकॉर्ड करते हो। balance नतीजा है, कोई जादुई नंबर नहीं।

ये झंझट क्यों उठाओ?

क्योंकि future-you तब धन्यवाद देगा जब:

• तुम्हें audit करना हो कि किसने क्या किया, कब और क्यों,
• तुम debug के लिए reality को replay करना चाहो,
• business changes के बाद model rebuild करना पड़े,
• तुम projections (read models) चाहो बिना database को तोड़े।

संक्षेप में: अभी थोड़ी complexity, बाद में कम post-mortem ड्रामा।

ज़रूरी हिस्से (धुएं के बिना)

• Event: past में हुआ immutable fact. OrderPlaced, नहीं PlaceOrder.
• Stream: एक aggregate के events की sequence.
• Aggregate: domain object जो events apply करके state बनाता है.
• Projection: derived view (SQL, Elastic, cache, आदि) तेज़ read के लिए.

कब इस्तेमाल करें (और कब नहीं)

इस्तेमाल करो अगर:

• तुम्हारा domain अक्सर बदलता है,
• history critical है,
• तुम्हें solid traceability चाहिए।

Avoid करो अगर:

• तुम्हारा CRUD बहुत basic है,
• audit की जरूरत नहीं है,
• टीम अभी repositories सीख रही है।

Symfony में छोटा शुरुआती उदाहरण

बहुत simple रखते हैं: Cart aggregate, events, और in-memory event store. ना full CQRS, ना Kafka, ना जादू. बस core idea.

1) Event define करो

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) Aggregate जो events replay करता है

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) Minimal in-memory event store

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) Symfony service में usage

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}

बस हो गया. न ORM, न cache, न parade. सिर्फ core idea: events ही truth हैं, state एक computed view है। बाद में projections और Symfony Messenger listeners जोड़ लेना अगर बड़ी लीग में खेलना है।

याद रखने लायक बातें

• Event sourcing history स्टोर करता है, सिर्फ result नहीं.
• Events replay करके state बनती है.
• Audit और बदलते domains के लिए बढ़िया, boring CRUD के लिए बेकार.
• Symfony खुद सब नहीं करता, लेकिन structure साफ रखने देता है.

अगर ये भारी लगे, तो सही है: तुम short-term comfort के बदले long-term clarity ले रहे हो। अभी भुगतान करो या future-you करेगा। पसंद तुम्हारी।