CQRS

// Command side - Write model
interface CreateOrderCommand {
  customerId: string;
  items: OrderItem[];
  shippingAddress: Address;
}
 
class OrderCommandHandler {
  constructor(
    private orderRepository: OrderRepository,
    private eventBus: EventBus
  ) {}
 
  async handle(command: CreateOrderCommand): Promise<void> {
    const order = new Order(
      command.customerId,
      command.items,
      command.shippingAddress
    );
    
    await this.orderRepository.save(order);
    
    // Publish event for read model projection
    await this.eventBus.publish(new OrderCreatedEvent(order));
  }
}
 
// Query side - Read model
interface OrderSummaryQuery {
  customerId: string;
  status?: OrderStatus;
  dateRange?: DateRange;
}
 
class OrderQueryHandler {
  constructor(private readDatabase: ReadDatabase) {}
 
  async handle(query: OrderSummaryQuery): Promise<OrderSummary[]> {
    return this.readDatabase.query(`
      SELECT 
        order_id,
        customer_name,
        total_amount,
        status,
        created_at
      FROM order_summaries 
      WHERE customer_id = $1
        AND ($2::text IS NULL OR status = $2)
        AND created_at BETWEEN $3 AND $4
      ORDER BY created_at DESC
    `, [query.customerId, query.status, query.dateRange?.start, query.dateRange?.end]);
  }
}
 
// Event handler for projection
class OrderProjectionHandler {
  async on(event: OrderCreatedEvent): Promise<void> {
    await this.readDatabase.execute(`
      INSERT INTO order_summaries (
        order_id, customer_id, customer_name, 
        total_amount, status, created_at
      ) VALUES ($1, $2, $3, $4, $5, $6)
    `, [
      event.orderId,
      event.customerId,
      event.customerName,
      event.totalAmount,
      'PENDING',
      event.timestamp
    ]);
  }
}

class OrderQueryService {
  async getOrderWithFallback(orderId: string): Promise<OrderView> {
    // Try read model first
    const orderView = await this.readModel.findById(orderId);
    
    if (orderView) {
      return orderView;
    }
    
    // Fallback to write model if not yet projected
    const order = await this.writeModel.findById(orderId);
    if (!order) {
      throw new OrderNotFoundError(orderId);
    }
    
    // Build view on-the-fly
    return this.buildOrderView(order);
  }
  
  private buildOrderView(order: Order): OrderView {
    return {
      id: order.id,
      customerName: order.customer.name,
      status: order.status,
      totalAmount: order.calculateTotal(),
      createdAt: order.createdAt
    };
  }
}

class OrderService {
  async createOrder(command: CreateOrderCommand): Promise<void> {
    const transaction = await this.database.beginTransaction();
    
    try {
      // Update write model
      const order = await this.orderRepository.create(command, transaction);
      
      // Update read model in same transaction
      await this.orderSummaryRepository.create({
        orderId: order.id,
        customerId: order.customerId,
        totalAmount: order.totalAmount,
        status: order.status
      }, transaction);
      
      await transaction.commit();
    } catch (error) {
      await transaction.rollback();
      throw error;
    }
  }
}