Event-Driven Architecture

Event-driven architecture enables loose coupling and reactive systems through asynchronous event processing.

Event Types

// Domain Event - Something that happened
interface DomainEvent {
  eventId: string;
  eventType: string;
  aggregateId: string;
  timestamp: Date;
  version: number;
  payload: Record;
}

// Example events
interface OrderCreatedEvent extends DomainEvent {
  eventType: 'OrderCreated';
  payload: {
    orderId: string;
    customerId: string;
    items: Array<{ productId: string; quantity: number }>;
    totalAmount: number;
  };
}

interface OrderShippedEvent extends DomainEvent {
  eventType: 'OrderShipped';
  payload: {
    orderId: string;
    trackingNumber: string;
    carrier: string;
    estimatedDelivery: Date;
  };
}

Event Sourcing

// Event Store
class EventStore {
  private events: DomainEvent[] = [];

  async appendEvent(event: DomainEvent): Promise {
    this.events.push(event);
    await this.publishEvent(event);
  }

  async getEventsForAggregate(aggregateId: string): Promise {
    return this.events.filter(e => e.aggregateId === aggregateId);
  }
}

// Aggregate rebuilt from events
class Order {
  private id: string;
  private status: 'pending' | 'confirmed' | 'shipped' | 'delivered';
  private items: Array<{ productId: string; quantity: number }> = [];
  private totalAmount: number = 0;

  static fromEvents(events: DomainEvent[]): Order {
    const order = new Order();
    events.forEach(event => order.applyEvent(event));
    return order;
  }

  private applyEvent(event: DomainEvent): void {
    switch (event.eventType) {
      case 'OrderCreated':
        this.id = event.payload.orderId;
        this.items = event.payload.items;
        this.totalAmount = event.payload.totalAmount;
        this.status = 'pending';
        break;
      case 'OrderConfirmed':
        this.status = 'confirmed';
        break;
      case 'OrderShipped':
        this.status = 'shipped';
        break;
      case 'OrderDelivered':
        this.status = 'delivered';
        break;
    }
  }
}

CQRS (Command Query Responsibility Segregation)

// Command Side - Write Model
class OrderCommandHandler {
  constructor(
    private eventStore: EventStore,
    private eventBus: EventBus
  ) {}

  async handleCreateOrder(command: CreateOrderCommand): Promise {
    // Validate
    await this.validateOrder(command);

    // Create event
    const event: OrderCreatedEvent = {
      eventId: generateId(),
      eventType: 'OrderCreated',
      aggregateId: command.orderId,
      timestamp: new Date(),
      version: 1,
      payload: {
        orderId: command.orderId,
        customerId: command.customerId,
        items: command.items,
        totalAmount: this.calculateTotal(command.items)
      }
    };

    // Store and publish
    await this.eventStore.appendEvent(event);
    await this.eventBus.publish(event);
  }
}

// Query Side - Read Model
class OrderQueryService {
  private orderViews: Map = new Map();

  // Event handler updates read model
  handleOrderCreated(event: OrderCreatedEvent): void {
    const view: OrderView = {
      orderId: event.payload.orderId,
      customerId: event.payload.customerId,
      status: 'pending',
      totalAmount: event.payload.totalAmount,
      itemCount: event.payload.items.length,
      createdAt: event.timestamp
    };
    this.orderViews.set(event.payload.orderId, view);
  }

  // Optimized queries on denormalized data
  getOrdersByCustomer(customerId: string): OrderView[] {
    return Array.from(this.orderViews.values())
      .filter(o => o.customerId === customerId);
  }
}

Event-Driven Patterns

Event-Driven Patterns

Event-Driven Architecture

Event Types

Event Sourcing

CQRS (Command Query Responsibility Segregation)