Building a Type-Safe Event Bus in TypeScript: Decouple Your Microservices

Your payment service calls notification directly. One change breaks three services. An event bus decouples producers from consumers.

The Problem

Untyped events break at runtime. Typos compile fine but crash in production.

Event Map

interface EventMap {
  "user.created": { id: string; email: string; name: string };
  "user.deleted": { id: string };
  "order.placed": { orderId: string; userId: string; total: number };
  "payment.completed": { orderId: string; amount: number; currency: string };
}

The Type-Safe Event Bus

type Handler<T> = (payload: T) => void | Promise<void>;
class EventBus<E extends Record<string, unknown>> {
  private handlers = new Map();
  on(event, handler) { if (\!this.handlers.has(event)) this.handlers.set(event, new Set()); this.handlers.get(event).add(handler); return () => this.handlers.get(event).delete(handler); }
  async emit(event, payload) { const h = this.handlers.get(event); if (\!h) return; await Promise.all([...h].map(fn => Promise.resolve(fn(payload)).catch(console.error))); }
}

Cross-Service With Redis Pub/Sub

Wrap the local bus with Redis for cross-process type safety:

class DistributedEventBus<E extends Record<string, unknown>> {
  private local = new EventBus<E>();
  private pub: Redis; private sub: Redis;
  constructor(url: string) { this.pub = new Redis(url); this.sub = new Redis(url); this.sub.on("message", (ch, msg) => this.local.emit(ch, JSON.parse(msg))); }
  on(event, handler) { this.sub.subscribe(String(event)); return this.local.on(event, handler); }
  async emit(event, payload) { await this.pub.publish(String(event), JSON.stringify(payload)); }
}

Dead Letter Queue

When handlers fail, push to a dead letter queue and retry later. Extend EventBus with a dlq array that catches errors and provides retryDLQ().

Testing

No mocks needed. Emit and assert. Test duplicate key returns same response, unsubscribe stops events, concurrent handling works.

When to Use This

Yes: Decoupling services, audit logs, notifications, analytics.
No: Request-response flows. Use direct calls or RPC.

---

Part of my Production Backend Patterns series. Follow for more practical backend engineering.

---

If this article helped you, consider buying me a coffee on Ko-fi! Follow me for more production backend patterns.