TypeScript
Design Patterns

class DatabaseConnection {
  private static instance: DatabaseConnection | null = null;
  private connectionCount = 0;

  // Private constructor — no one can call `new DatabaseConnection()`
  private constructor(private connectionString: string) {
    console.log(`🔌 DB connected: ${this.connectionString}`);
  }

  // The ONLY way to get a DatabaseConnection
  static getInstance(connectionString: string): DatabaseConnection {
    if (!DatabaseConnection.instance) {
      DatabaseConnection.instance = new DatabaseConnection(connectionString);
    }
    return DatabaseConnection.instance;
  }

  query(sql: string): string {
    this.connectionCount++;
    return `Result of: ${sql} (query #${this.connectionCount})`;
  }
}

// Across your entire app, these all return the SAME instance
const db1 = DatabaseConnection.getInstance("postgres://localhost/mydb");
const db2 = DatabaseConnection.getInstance("postgres://localhost/mydb");
console.log(db1 === db2); // true ✅

db1.query("SELECT * FROM users");
db2.query("SELECT * FROM orders"); // query #2 on same connection

interface Logger {
  log(message: string): void;
  error(message: string): void;
}

class ConsoleLogger implements Logger {
  log(msg: string) { console.log(`[CONSOLE] ℹ ${msg}`); }
  error(msg: string) { console.error(`[CONSOLE] ❌ ${msg}`); }
}

class FileLogger implements Logger {
  log(msg: string) { console.log(`[FILE] Writing: ${msg}`); }
  error(msg: string) { console.log(`[FILE] Error: ${msg}`); }
}

class CloudLogger implements Logger {
  log(msg: string) { console.log(`[DATADOG] Sending metric: ${msg}`); }
  error(msg: string) { console.log(`[DATADOG] Alert: ${msg}`); }
}

// Factory — single place to decide which logger to create
type LoggerType = "console" | "file" | "cloud";

function createLogger(type: LoggerType): Logger {
  const factories: Record<LoggerType, () => Logger> = {
    console: () => new ConsoleLogger(),
    file:    () => new FileLogger(),
    cloud:   () => new CloudLogger(),
  };
  return factories[type]();
}

// Config-driven — switch logger without changing callers
const env = process.env.NODE_ENV;
const logger = createLogger(env === "production" ? "cloud" : "console");
logger.log("App started");
logger.error("Something went wrong");

interface HttpRequestConfig {
  url: string;
  method: string;
  headers: Record<string, string>;
  body?: unknown;
  timeout?: number;
  retries?: number;
}

class HttpRequestBuilder {
  private config: Partial<HttpRequestConfig> = {
    method: "GET",
    headers: {},
  };

  url(url: string): this {
    this.config.url = url;
    return this; // return this for chaining
  }

  method(method: "GET" | "POST" | "PUT" | "DELETE"): this {
    this.config.method = method;
    return this;
  }

  header(key: string, value: string): this {
    this.config.headers![key] = value;
    return this;
  }

  bearerToken(token: string): this {
    return this.header("Authorization", `Bearer ${token}`);
  }

  body(data: unknown): this {
    this.config.body = data;
    return this.header("Content-Type", "application/json");
  }

  timeout(ms: number): this {
    this.config.timeout = ms;
    return this;
  }

  retries(count: number): this {
    this.config.retries = count;
    return this;
  }

  build(): HttpRequestConfig {
    if (!this.config.url) throw new Error("URL is required");
    return this.config as HttpRequestConfig;
  }
}

// Readable, fluent API — like writing English
const request = new HttpRequestBuilder()
  .url("https://api.example.com/users")
  .method("POST")
  .bearerToken("eyJ...")
  .body({ name: "Ravi", email: "ravi@example.com" })
  .timeout(5000)
  .retries(3)
  .build();

console.log(request);

// What YOUR system expects
interface AnalyticsService {
  trackEvent(event: string, userId: string, props: object): void;
}

// What MIXPANEL actually provides (their SDK)
class MixpanelSDK {
  track(eventName: string, distinctId: string, metadata: object): void {
    console.log(`[Mixpanel] ${eventName} for ${distinctId}:`, metadata);
  }
}

// What AMPLITUDE actually provides
class AmplitudeSDK {
  logEvent(eventType: string, userIdentifier: string, eventProperties: object): void {
    console.log(`[Amplitude] ${eventType} for ${userIdentifier}:`, eventProperties);
  }
}

// ADAPTERS — bridge the gap
class MixpanelAdapter implements AnalyticsService {
  constructor(private mixpanel: MixpanelSDK) {}

  trackEvent(event: string, userId: string, props: object): void {
    // Translate YOUR interface → Mixpanel's interface
    this.mixpanel.track(event, userId, props);
  }
}

class AmplitudeAdapter implements AnalyticsService {
  constructor(private amplitude: AmplitudeSDK) {}

  trackEvent(event: string, userId: string, props: object): void {
    this.amplitude.logEvent(event, userId, props);
  }
}

// Your app code never changes — just swap the adapter
class UserService {
  constructor(private analytics: AnalyticsService) {}

  onUserSignup(userId: string): void {
    // No Mixpanel/Amplitude knowledge here
    this.analytics.trackEvent("user_signed_up", userId, { source: "organic" });
  }
}

const service = new UserService(new MixpanelAdapter(new MixpanelSDK()));
service.onUserSignup("user_42");

interface DataSource {
  write(data: string): void;
  read(): string;
}

// Concrete component
class FileDataSource implements DataSource {
  private data: string = "";
  write(data: string): void { this.data = data; }
  read(): string { return this.data; }
}

// Base decorator — wraps a DataSource
abstract class DataSourceDecorator implements DataSource {
  constructor(protected wrapped: DataSource) {}
  write(data: string): void { this.wrapped.write(data); }
  read(): string { return this.wrapped.read(); }
}

// Concrete decorator 1: adds encryption
class EncryptionDecorator extends DataSourceDecorator {
  write(data: string): void {
    const encrypted = Buffer.from(data).toString("base64");
    console.log("🔐 Encrypting...");
    super.write(encrypted);
  }
  read(): string {
    const data = super.read();
    console.log("🔓 Decrypting...");
    return Buffer.from(data, "base64").toString();
  }
}

// Concrete decorator 2: adds compression
class CompressionDecorator extends DataSourceDecorator {
  write(data: string): void {
    console.log("🗜 Compressing...");
    super.write(`[compressed:${data}]`); // simplified
  }
  read(): string {
    const raw = super.read();
    console.log("📦 Decompressing...");
    return raw.replace(/\[compressed:(.*)\]/, "$1");
  }
}

// Layer decorators — file → encrypt → compress
const source = new CompressionDecorator(
  new EncryptionDecorator(
    new FileDataSource()
  )
);

source.write("user sensitive data");
console.log(source.read()); // "user sensitive data"

// Complex subsystems
class InventoryService {
  reserve(productId: string, qty: number): boolean {
    console.log(`Reserved ${qty}x ${productId}`); return true;
  }
}
class PaymentService {
  charge(userId: string, amount: number): boolean {
    console.log(`Charged ₹${amount} to ${userId}`); return true;
  }
}
class ShippingService {
  schedule(orderId: string, address: string): string {
    console.log(`Scheduled delivery for ${orderId}`);
    return `TRACK-${Date.now()}`;
  }
}
class NotificationService {
  sendOrderConfirmation(userId: string, orderId: string): void {
    console.log(`📧 Confirmation sent to ${userId} for ${orderId}`);
  }
}

// FACADE — simple interface over the complexity
class OrderFacade {
  private inventory = new InventoryService();
  private payment = new PaymentService();
  private shipping = new ShippingService();
  private notifications = new NotificationService();

  placeOrder(userId: string, productId: string, qty: number, address: string): string {
    const orderId = `ORD-${Date.now()}`;
    const amount = qty * 299; // simplified pricing

    if (!this.inventory.reserve(productId, qty)) throw new Error("Out of stock");
    if (!this.payment.charge(userId, amount)) throw new Error("Payment failed");
    const trackingId = this.shipping.schedule(orderId, address);
    this.notifications.sendOrderConfirmation(userId, orderId);

    return trackingId;
  }
}

// Client code is beautifully simple
const orders = new OrderFacade();
const tracking = orders.placeOrder("user_1", "iPhone15", 1, "MG Road, Bengaluru");
console.log(`Track your order: ${tracking}`);

type EventHandler<T> = (data: T) => void;

class EventEmitter<Events extends Record<string, unknown>> {
  private listeners = new Map<string, Set<EventHandler<unknown>>>();

  on<K extends keyof Events>(event: K, handler: EventHandler<Events[K]>): void {
    if (!this.listeners.has(event as string)) {
      this.listeners.set(event as string, new Set());
    }
    this.listeners.get(event as string)!.add(handler as EventHandler<unknown>);
  }

  off<K extends keyof Events>(event: K, handler: EventHandler<Events[K]>): void {
    this.listeners.get(event as string)?.delete(handler as EventHandler<unknown>);
  }

  emit<K extends keyof Events>(event: K, data: Events[K]): void {
    this.listeners.get(event as string)?.forEach(handler => handler(data));
  }
}

// Strongly typed events — no magic strings
interface OrderEvents {
  "order:created": { orderId: string; userId: string; amount: number };
  "order:shipped": { orderId: string; trackingId: string };
  "order:cancelled": { orderId: string; reason: string };
}

const eventBus = new EventEmitter<OrderEvents>();

// Subscribers register independently
eventBus.on("order:created", ({ orderId, amount }) => {
  console.log(`📧 Email: Order ${orderId} confirmed for ₹${amount}`);
});

eventBus.on("order:created", ({ orderId, userId }) => {
  console.log(`📊 Analytics: New order ${orderId} from ${userId}`);
});

eventBus.on("order:shipped", ({ orderId, trackingId }) => {
  console.log(`📦 Push: Your order ${orderId} is shipped! Track: ${trackingId}`);
});

// Publisher doesn't know WHO is listening
eventBus.emit("order:created", { orderId: "ORD-1", userId: "u_42", amount: 1299 });

interface HttpRequest {
  path: string;
  method: string;
  headers: Record<string, string>;
  body?: unknown;
  user?: { id: string; role: string };
}

type NextFn = () => void;

abstract class Middleware {
  protected next: Middleware | null = null;

  setNext(middleware: Middleware): Middleware {
    this.next = middleware;
    return middleware; // allows chaining: a.setNext(b).setNext(c)
  }

  protected pass(req: HttpRequest): void {
    this.next?.handle(req);
  }

  abstract handle(req: HttpRequest): void;
}

class RateLimiterMiddleware extends Middleware {
  private requestCounts = new Map<string, number>();

  handle(req: HttpRequest): void {
    const ip = req.headers["x-forwarded-for"] || "unknown";
    const count = (this.requestCounts.get(ip) || 0) + 1;
    this.requestCounts.set(ip, count);

    if (count > 100) {
      console.log("🚫 Rate limit exceeded"); return;
    }
    console.log("✅ Rate limit OK");
    this.pass(req);
  }
}

class AuthMiddleware extends Middleware {
  handle(req: HttpRequest): void {
    const token = req.headers["authorization"];
    if (!token?.startsWith("Bearer ")) {
      console.log("🚫 Unauthorized"); return;
    }
    req.user = { id: "user_1", role: "admin" }; // attach user to request
    console.log("✅ Authenticated");
    this.pass(req);
  }
}

class LoggingMiddleware extends Middleware {
  handle(req: HttpRequest): void {
    console.log(`📝 ${req.method} ${req.path} by ${req.user?.id}`);
    this.pass(req);
  }
}

class RouteHandler extends Middleware {
  handle(req: HttpRequest): void {
    console.log(`🎯 Handling ${req.path}...`);
  }
}

// Wire up the chain
const rateLimiter = new RateLimiterMiddleware();
rateLimiter
  .setNext(new AuthMiddleware())
  .setNext(new LoggingMiddleware())
  .setNext(new RouteHandler());

// Every incoming request runs through the chain
rateLimiter.handle({
  path: "/api/orders", method: "GET",
  headers: { authorization: "Bearer eyJ...", "x-forwarded-for": "1.2.3.4" }
});