CQRS & Event Sourcing Cheat Sheet

// Command: intent to change state, handled by the write modelinterface PlaceOrderCommand {  orderId: string;  items: { productId: string; qty: number }[];}class PlaceOrderHandler {  constructor(private repo: OrderRepository) {}  async handle(cmd: PlaceOrderCommand): Promise<void> {    const order = Order.place(cmd.orderId, cmd.items);    await this.repo.save(order);  }}// Query: read-only, served by a separate (often denormalized) read modelinterface OrderSummaryQuery { orderId: string; }class OrderSummaryHandler {  constructor(private readDb: ReadDatabase) {}  async handle(q: OrderSummaryQuery): Promise<OrderSummaryDto> {    return this.readDb.orderSummaries.findById(q.orderId);  }}

type OrderEvent =  | { type: 'OrderPlaced'; orderId: string; items: Item[] }  | { type: 'OrderShipped'; orderId: string; trackingId: string }  | { type: 'OrderCancelled'; orderId: string; reason: string };class Order {  private status: 'placed' | 'shipped' | 'cancelled' = 'placed';  private uncommitted: OrderEvent[] = [];  static rehydrate(events: OrderEvent[]): Order {    const order = new Order();    events.forEach(e => order.apply(e, false));    return order;  }  private apply(event: OrderEvent, isNew: boolean): void {    if (event.type === 'OrderShipped') this.status = 'shipped';    if (event.type === 'OrderCancelled') this.status = 'cancelled';    if (isNew) this.uncommitted.push(event);  }  ship(trackingId: string): void {    if (this.status !== 'placed') throw new Error('cannot ship');    this.apply({ type: 'OrderShipped', orderId: this.id, trackingId }, true);  }}

// Projection: subscribes to the event stream, updates a read-optimized tableasync function onOrderShipped(event: OrderShippedEvent) {  await readDb.orderSummaries.update(event.orderId, {    status: 'shipped',    trackingId: event.trackingId,  });}// Snapshot: periodically persist current state to bound replay costinterface Snapshot { aggregateId: string; version: number; state: unknown; }async function loadOrder(id: string): Promise<Order> {  const snapshot = await snapshotStore.findLatest(id);  const eventsSince = await eventStore.readFrom(id, snapshot?.version ?? 0);  return Order.rehydrate(eventsSince, snapshot?.state);}// Rule of thumb: snapshot every N events (e.g. 100) or on a time interval