design-patterns

Design Patterns

Structural design patterns for solving recurring design problems with proven solutions.

When to Use

• Eliminating complex conditional logic (if/else chains, switch statements)
• Designing plugin/extension systems
• Integrating external APIs or legacy systems
• Separating concerns with clear interfaces
• Evaluating whether a pattern solves a concrete problem

When Not to Use

• Class-level SOLID violations (use solid-principles)
• Architectural boundary decisions (use clean-architecture)
• Testing strategy configuration (use testable-design)
• NEVER apply patterns preemptively for imagined future needs

Pattern Selection Workflow

Step 1: Identify the Design Problem

Output: Concrete problem statement without pattern jargon.

Ask:

• What conditional logic or coupling exists?
• What needs to vary independently?
• What external system needs integration?

Example:

Problem: Payment processing logic uses if/else chains to select processors.
Adding new processors requires editing existing code (OCP violation).

Step 2: Evaluate Pattern Fit

Output: Pattern choice with explicit win condition.

Ask before choosing a pattern:

• Does this pattern solve the concrete problem?
• What complexity does it remove vs. add?
• Can the team maintain it?

Example:

Pattern: Strategy (not Factory).
Win condition: Eliminates if/else chains for payment processor selection.
Cost: One interface + implementations. Benefit: Easy to add new processors.

Step 3: Document Pattern Application

Output: Pattern applied with before/after comparison.

Template:

Pattern: Strategy
Problem: if/else chain for payment processor selection
Solution: PaymentProcessor interface + implementations (Stripe, PayPal, etc.)
Validation: New processors added without editing existing code

Common Patterns

Strategy Pattern

Use when: Conditional logic selects between algorithms.

Example:

// Before: if/else chain
if (type === 'stripe') {
  // Stripe logic
} else if (type === 'paypal') {
  // PayPal logic
}

// After: Strategy pattern
interface PaymentProcessor {
  process(amount: number): Promise<Receipt>
}

class StripeProcessor implements PaymentProcessor { /* ... */ }
class PayPalProcessor implements PaymentProcessor { /* ... */ }

// Select strategy
const processor = processors[type]
await processor.process(amount)