event-driven

Event-Driven Architecture

Overview

Event-driven architecture (EDA) uses events as the primary mechanism for communication between components. Events represent facts — things that have happened — and enable loose coupling, scalability, and auditability.

Patterns

Event Notification

Producer → Event Bus → Consumer(s)

OrderService                    NotificationService
    │                                  │
    ├── publishes ──►  OrderPlaced ──► │ sends email
    │                                  │
InventoryService                PaymentService
    │                                  │
    ├── subscribes ─► OrderPlaced ──►  │ charges card

Event Sourcing

// Store events, not state — rebuild state by replaying events
class OrderEventStore {
  async save(orderId: string, events: DomainEvent[]): Promise<void> {
    for (const event of events) {
      await this.db.insert('events', {
        stream_id: orderId,
        type: event.type,
        data: JSON.stringify(event),
        version: event.version,
        occurred_at: event.occurredAt,
      });
    }
  }

  async load(orderId: string): Promise<DomainEvent[]> {
    return this.db.query(
      'SELECT * FROM events WHERE stream_id = $1 ORDER BY version ASC',
      [orderId]
    );
  }
}

// Rebuild aggregate from events
function rehydrate(events: DomainEvent[]): Order {
  const order = new Order();
  for (const event of events) {
    order.apply(event); // Mutates internal state
  }
  return order;
}

CQRS (Command Query Responsibility Segregation)

Commands (Write)                    Queries (Read)
    │                                   │
    ▼                                   ▼
┌──────────┐   events    ┌──────────────────┐
│ Write DB │ ──────────► │ Read Projections  │
│ (events) │             │ (denormalized)    │
└──────────┘             └──────────────────┘

// Command side — validates and stores events
async function placeOrder(cmd: PlaceOrderCommand): Promise<void> {
  const order = await eventStore.load(cmd.orderId);
  const events = order.place(cmd.items); // Returns new events
  await eventStore.save(cmd.orderId, events);
  await eventBus.publish(events);
}

// Query side — read from optimized projections
async function getOrderSummary(orderId: string): Promise<OrderSummary> {
  return readDb.query('SELECT * FROM order_summaries WHERE id = $1', [orderId]);
}

// Projector — updates read model when events arrive
class OrderProjector {
  async handle(event: OrderPlaced): Promise<void> {
    await readDb.insert('order_summaries', {
      id: event.orderId,
      status: 'placed',
      total: event.total,
      item_count: event.items.length,
    });
  }
}