🧱 Design Patterns

Classic and modern patterns for solving recurring software problems.

Creational patterns

Factory

Create objects without specifying the exact class.

function createNotification(type: 'email' | 'sms' | 'push'): Notification {
  switch (type) {
    case 'email': return new EmailNotification()
    case 'sms': return new SmsNotification()
    case 'push': return new PushNotification()
  }
}

Builder

Construct complex objects step by step.

const query = new QueryBuilder()
  .select('name', 'email')
  .from('users')
  .where('active', true)
  .orderBy('name')
  .build()

Singleton

Single shared instance (use sparingly — prefer dependency injection).

Structural patterns

Adapter

Wrap an interface to match another expected interface. Useful for integrating third-party libraries.

Decorator

Add behavior to objects dynamically.

const logger = withRetry(withTimeout(httpClient, 5000), 3)

Facade

Provide a simple interface to a complex subsystem.

Behavioral patterns

Strategy

Swap algorithms at runtime.

interface PricingStrategy {
  calculate(order: Order): number
}
// StandardPricing, PremiumPricing, DiscountPricing

Observer / Event Emitter

Notify subscribers when state changes.

Chain of Responsibility

Pass request through a chain of handlers (middleware pattern).

Modern patterns in practice

Pattern	Real-world example
Factory	API client creation based on provider
Builder	Query builders, form builders
Strategy	Payment processors, auth strategies
Observer	Event systems, webhooks
Middleware	Express/Koa middleware chain
Repository	Data access abstraction
Decorator	Logging, caching, retry wrappers

When to use patterns

• When you recognize a recurring problem
• When the pattern simplifies the code
• NOT when it adds unnecessary abstraction
• NOT to impress — use the simplest solution that works