📘 Chain of Responsibility: Request Handling

🎯 Introduction

Ever been to a help desk where your request gets passed from one person to another until someone can help? That’s the Chain of Responsibility pattern in action! 🎭 In this tutorial, we’ll explore how to implement this powerful pattern in TypeScript to create flexible, maintainable request handling systems.

Imagine building a customer support system where different types of requests need different handlers - some can be handled by bots 🤖, others need human agents 👤, and critical issues go straight to supervisors 👨‍💼. The Chain of Responsibility pattern makes this elegantly simple!

By the end of this tutorial, you’ll be creating request handling chains that would make any support team jealous! Let’s dive in! 🏊‍♂️

📚 Understanding Chain of Responsibility

The Chain of Responsibility pattern is like a game of “hot potato” 🥔 where each player (handler) decides whether to handle the potato (request) or pass it to the next player. Each handler in the chain has two choices:

• Handle the request and stop the chain ✋
• Pass it to the next handler in line ➡️

Think of it as a series of filters or checkpoints. Each checkpoint examines the request and decides: “Is this for me? If yes, I’ll handle it. If not, next please!” 🎫

In TypeScript, we create a chain of handler objects, each knowing about the next handler. When a request comes in, it travels through the chain until someone handles it or it reaches the end.

🔧 Basic Syntax and Usage

Let’s start with a simple example - a support ticket system! 🎫

// 🎯 Define our request type
interface SupportTicket {
  id: string;
  priority: 'low' | 'medium' | 'high' | 'critical';
  issue: string;
  customerType: 'regular' | 'premium' | 'vip';
}

// 🏗️ Abstract handler class
abstract class SupportHandler {
  private nextHandler: SupportHandler | null = null;

  // 🔗 Set the next handler in chain
  setNext(handler: SupportHandler): SupportHandler {
    this.nextHandler = handler;
    return handler; // 💡 Return for chaining!
  }

  // 📨 Handle the request
  handle(ticket: SupportTicket): string {
    const result = this.processTicket(ticket);
    
    if (result) {
      return result;
    }
    
    if (this.nextHandler) {
      return this.nextHandler.handle(ticket);
    }
    
    return "⚠️ No handler available for this ticket!";
  }

  // 🎯 Each handler implements this
  protected abstract processTicket(ticket: SupportTicket): string | null;
}

// 🤖 Bot handler for simple issues
class BotHandler extends SupportHandler {
  protected processTicket(ticket: SupportTicket): string | null {
    if (ticket.priority === 'low') {
      return `🤖 Bot handled ticket ${ticket.id}: ${ticket.issue}`;
    }
    return null; // 👋 Pass to next handler
  }
}

// 👤 Human agent handler
class AgentHandler extends SupportHandler {
  protected processTicket(ticket: SupportTicket): string | null {
    if (ticket.priority === 'medium' || ticket.priority === 'high') {
      return `👤 Agent handled ticket ${ticket.id}: ${ticket.issue}`;
    }
    return null;
  }
}

// 👨‍💼 Supervisor handler for critical issues
class SupervisorHandler extends SupportHandler {
  protected processTicket(ticket: SupportTicket): string | null {
    if (ticket.priority === 'critical' || ticket.customerType === 'vip') {
      return `👨‍💼 Supervisor handled ticket ${ticket.id}: ${ticket.issue}`;
    }
    return null;
  }
}

💡 Practical Examples

Example 1: Customer Support System 🎧

Let’s build a complete support system with different handling strategies!

// 🎯 Enhanced ticket system with more features
interface EnhancedTicket extends SupportTicket {
  category: 'billing' | 'technical' | 'general' | 'complaint';
  responseTime: number; // in minutes
  resolved: boolean;
}

// 💰 Billing specialist handler
class BillingHandler extends SupportHandler {
  protected processTicket(ticket: EnhancedTicket): string | null {
    if (ticket.category === 'billing') {
      console.log(`💰 Processing billing issue...`);
      return `💳 Billing team resolved: ${ticket.issue}`;
    }
    return null;
  }
}

// 🔧 Technical support handler
class TechnicalHandler extends SupportHandler {
  private readonly expertise = ['login', 'performance', 'bug', 'crash'];
  
  protected processTicket(ticket: EnhancedTicket): string | null {
    if (ticket.category === 'technical') {
      const canHandle = this.expertise.some(keyword => 
        ticket.issue.toLowerCase().includes(keyword)
      );
      
      if (canHandle) {
        return `🔧 Tech support fixed: ${ticket.issue}`;
      }
    }
    return null;
  }
}

// 🚨 Escalation handler for complaints
class EscalationHandler extends SupportHandler {
  protected processTicket(ticket: EnhancedTicket): string | null {
    if (ticket.category === 'complaint' || 
        ticket.responseTime > 60 ||
        ticket.customerType === 'vip') {
      return `🚨 Escalated to management: ${ticket.issue}`;
    }
    return null;
  }
}

// 🏗️ Build the support chain
const buildSupportChain = (): SupportHandler => {
  const bot = new BotHandler();
  const billing = new BillingHandler();
  const tech = new TechnicalHandler();
  const agent = new AgentHandler();
  const escalation = new EscalationHandler();
  const supervisor = new SupervisorHandler();
  
  // 🔗 Chain them together!
  bot.setNext(billing)
     .setNext(tech)
     .setNext(agent)
     .setNext(escalation)
     .setNext(supervisor);
  
  return bot; // 🎯 Return first handler
};

// 🎮 Let's test it!
const supportChain = buildSupportChain();

const tickets: EnhancedTicket[] = [
  {
    id: "T001",
    priority: 'low',
    issue: "How do I reset my password?",
    customerType: 'regular',
    category: 'general',
    responseTime: 5,
    resolved: false
  },
  {
    id: "T002",
    priority: 'high',
    issue: "Billing error on my account",
    customerType: 'premium',
    category: 'billing',
    responseTime: 15,
    resolved: false
  },
  {
    id: "T003",
    priority: 'critical',
    issue: "System crash losing customer data!",
    customerType: 'regular',
    category: 'technical',
    responseTime: 120,
    resolved: false
  }
];

tickets.forEach(ticket => {
  console.log(supportChain.handle(ticket));
});

Example 2: Authentication Chain 🔐

Let’s create a security chain for authentication!

// 🔐 Authentication request
interface AuthRequest {
  username: string;
  password?: string;
  token?: string;
  biometric?: string;
  ipAddress: string;
  deviceId: string;
}

interface AuthResult {
  success: boolean;
  method: string;
  message: string;
  userId?: string;
}

// 🏗️ Authentication handler base
abstract class AuthHandler {
  private next: AuthHandler | null = null;
  
  setNext(handler: AuthHandler): AuthHandler {
    this.next = handler;
    return handler;
  }
  
  async authenticate(request: AuthRequest): Promise<AuthResult> {
    const result = await this.tryAuthenticate(request);
    
    if (result.success) {
      return result;
    }
    
    if (this.next) {
      return this.next.authenticate(request);
    }
    
    return {
      success: false,
      method: 'none',
      message: '❌ All authentication methods failed'
    };
  }
  
  protected abstract tryAuthenticate(request: AuthRequest): Promise<AuthResult>;
}

// 🔑 Password authentication
class PasswordAuthHandler extends AuthHandler {
  private users = new Map([
    ['alice', { password: 'secure123', id: 'U001' }],
    ['bob', { password: 'secret456', id: 'U002' }]
  ]);
  
  protected async tryAuthenticate(request: AuthRequest): Promise<AuthResult> {
    if (!request.password) {
      return { success: false, method: 'password', message: 'No password provided' };
    }
    
    const user = this.users.get(request.username);
    if (user && user.password === request.password) {
      console.log(`🔑 Password auth successful for ${request.username}`);
      return {
        success: true,
        method: 'password',
        message: '✅ Password authentication successful',
        userId: user.id
      };
    }
    
    return { success: false, method: 'password', message: 'Invalid credentials' };
  }
}

// 🎫 Token authentication
class TokenAuthHandler extends AuthHandler {
  private validTokens = new Map([
    ['TOKEN-123', { userId: 'U001', expires: Date.now() + 3600000 }],
    ['TOKEN-456', { userId: 'U002', expires: Date.now() + 3600000 }]
  ]);
  
  protected async tryAuthenticate(request: AuthRequest): Promise<AuthResult> {
    if (!request.token) {
      return { success: false, method: 'token', message: 'No token provided' };
    }
    
    const tokenData = this.validTokens.get(request.token);
    if (tokenData && tokenData.expires > Date.now()) {
      console.log(`🎫 Token auth successful`);
      return {
        success: true,
        method: 'token',
        message: '✅ Token authentication successful',
        userId: tokenData.userId
      };
    }
    
    return { success: false, method: 'token', message: 'Invalid or expired token' };
  }
}

// 👆 Biometric authentication
class BiometricAuthHandler extends AuthHandler {
  private biometricData = new Map([
    ['FINGER-001', 'U001'],
    ['FACE-002', 'U002']
  ]);
  
  protected async tryAuthenticate(request: AuthRequest): Promise<AuthResult> {
    if (!request.biometric) {
      return { success: false, method: 'biometric', message: 'No biometric data' };
    }
    
    const userId = this.biometricData.get(request.biometric);
    if (userId) {
      console.log(`👆 Biometric auth successful`);
      return {
        success: true,
        method: 'biometric',
        message: '✅ Biometric authentication successful',
        userId
      };
    }
    
    return { success: false, method: 'biometric', message: 'Biometric not recognized' };
  }
}

// 🌍 IP-based authentication (for trusted networks)
class IPAuthHandler extends AuthHandler {
  private trustedIPs = ['192.168.1.100', '10.0.0.50'];
  
  protected async tryAuthenticate(request: AuthRequest): Promise<AuthResult> {
    if (this.trustedIPs.includes(request.ipAddress)) {
      console.log(`🌍 Trusted IP authentication`);
      return {
        success: true,
        method: 'ip',
        message: '✅ Trusted IP authentication',
        userId: 'guest'
      };
    }
    
    return { success: false, method: 'ip', message: 'Untrusted IP address' };
  }
}

Example 3: Request Validation Pipeline 🚦

Let’s build a validation chain for API requests!

// 📦 API Request type
interface APIRequest {
  method: 'GET' | 'POST' | 'PUT' | 'DELETE';
  path: string;
  headers: Record<string, string>;
  body?: unknown;
  apiKey?: string;
  timestamp: number;
}

interface ValidationResult {
  valid: boolean;
  error?: string;
  processedBy: string;
}

// 🏗️ Validation handler base
abstract class ValidationHandler {
  private next: ValidationHandler | null = null;
  
  setNext(handler: ValidationHandler): ValidationHandler {
    this.next = handler;
    return handler;
  }
  
  validate(request: APIRequest): ValidationResult {
    const result = this.performValidation(request);
    
    if (!result.valid) {
      return result; // 🛑 Stop on first failure
    }
    
    if (this.next) {
      return this.next.validate(request);
    }
    
    return { valid: true, processedBy: 'all' };
  }
  
  protected abstract performValidation(request: APIRequest): ValidationResult;
}

// 🔑 API Key validator
class APIKeyValidator extends ValidationHandler {
  private validKeys = new Set(['KEY-123', 'KEY-456', 'KEY-789']);
  
  protected performValidation(request: APIRequest): ValidationResult {
    if (!request.apiKey) {
      return {
        valid: false,
        error: '🔑 API key required',
        processedBy: 'APIKeyValidator'
      };
    }
    
    if (!this.validKeys.has(request.apiKey)) {
      return {
        valid: false,
        error: '❌ Invalid API key',
        processedBy: 'APIKeyValidator'
      };
    }
    
    console.log('✅ API key validated');
    return { valid: true, processedBy: 'APIKeyValidator' };
  }
}

// ⏰ Rate limit validator
class RateLimitValidator extends ValidationHandler {
  private requests = new Map<string, number[]>();
  private readonly limit = 10; // 10 requests per minute
  
  protected performValidation(request: APIRequest): ValidationResult {
    const key = request.apiKey || 'anonymous';
    const now = Date.now();
    const minute = 60000;
    
    // 🧹 Clean old requests
    const userRequests = this.requests.get(key) || [];
    const recentRequests = userRequests.filter(time => now - time < minute);
    
    if (recentRequests.length >= this.limit) {
      return {
        valid: false,
        error: `⏰ Rate limit exceeded (${this.limit}/min)`,
        processedBy: 'RateLimitValidator'
      };
    }
    
    recentRequests.push(now);
    this.requests.set(key, recentRequests);
    
    console.log(`✅ Rate limit OK (${recentRequests.length}/${this.limit})`);
    return { valid: true, processedBy: 'RateLimitValidator' };
  }
}

// 📝 Content validator
class ContentValidator extends ValidationHandler {
  protected performValidation(request: APIRequest): ValidationResult {
    // 🚫 Check content type for POST/PUT
    if (['POST', 'PUT'].includes(request.method)) {
      if (!request.headers['content-type']) {
        return {
          valid: false,
          error: '📝 Content-Type header required',
          processedBy: 'ContentValidator'
        };
      }
      
      if (!request.body) {
        return {
          valid: false,
          error: '📦 Request body required',
          processedBy: 'ContentValidator'
        };
      }
    }
    
    // 🔍 Validate JSON body
    if (request.headers['content-type']?.includes('application/json')) {
      try {
        if (typeof request.body === 'string') {
          JSON.parse(request.body);
        }
      } catch {
        return {
          valid: false,
          error: '❌ Invalid JSON body',
          processedBy: 'ContentValidator'
        };
      }
    }
    
    console.log('✅ Content validated');
    return { valid: true, processedBy: 'ContentValidator' };
  }
}

// 🛡️ Security validator
class SecurityValidator extends ValidationHandler {
  private blockedPaths = ['/admin', '/internal', '/.env'];
  private sqlPatterns = /(\bselect\b|\binsert\b|\bdelete\b|\bdrop\b)/i;
  
  protected performValidation(request: APIRequest): ValidationResult {
    // 🚫 Check blocked paths
    if (this.blockedPaths.some(path => request.path.includes(path))) {
      return {
        valid: false,
        error: '🛡️ Access denied to restricted path',
        processedBy: 'SecurityValidator'
      };
    }
    
    // 🔍 Check for SQL injection attempts
    const checkString = `${request.path} ${JSON.stringify(request.body || '')}`;
    if (this.sqlPatterns.test(checkString)) {
      return {
        valid: false,
        error: '⚠️ Potential SQL injection detected',
        processedBy: 'SecurityValidator'
      };
    }
    
    console.log('✅ Security check passed');
    return { valid: true, processedBy: 'SecurityValidator' };
  }
}

// 🎮 Test the validation chain!
const buildValidationChain = (): ValidationHandler => {
  const apiKey = new APIKeyValidator();
  const rateLimit = new RateLimitValidator();
  const content = new ContentValidator();
  const security = new SecurityValidator();
  
  apiKey.setNext(rateLimit)
        .setNext(security)
        .setNext(content);
  
  return apiKey;
};

const validator = buildValidationChain();

// 🧪 Test various requests
const testRequests: APIRequest[] = [
  {
    method: 'GET',
    path: '/api/users',
    headers: {},
    timestamp: Date.now()
  },
  {
    method: 'POST',
    path: '/api/users',
    headers: { 'content-type': 'application/json' },
    body: { name: 'Alice 🎉' },
    apiKey: 'KEY-123',
    timestamp: Date.now()
  },
  {
    method: 'DELETE',
    path: '/admin/users',
    headers: {},
    apiKey: 'KEY-456',
    timestamp: Date.now()
  }
];

testRequests.forEach((req, i) => {
  console.log(`\n🔍 Testing request ${i + 1}:`);
  const result = validator.validate(req);
  console.log(result);
});

🚀 Advanced Concepts

Dynamic Chain Building 🏗️

Let’s create a system that builds chains dynamically based on configuration!

// 🎯 Generic handler with priority
interface HandlerConfig {
  name: string;
  priority: number;
  enabled: boolean;
  conditions?: Record<string, unknown>;
}

// 🏭 Handler factory
class HandlerFactory<T> {
  private handlers = new Map<string, new() => Handler<T>>();
  
  register(name: string, HandlerClass: new() => Handler<T>): void {
    this.handlers.set(name, HandlerClass);
  }
  
  create(name: string): Handler<T> | null {
    const HandlerClass = this.handlers.get(name);
    return HandlerClass ? new HandlerClass() : null;
  }
}

// 🔗 Advanced handler with middleware support
abstract class Handler<T> {
  private next: Handler<T> | null = null;
  private middlewares: ((data: T) => T)[] = [];
  
  setNext(handler: Handler<T>): Handler<T> {
    this.next = handler;
    return handler;
  }
  
  use(middleware: (data: T) => T): this {
    this.middlewares.push(middleware);
    return this;
  }
  
  async handle(data: T): Promise<T | null> {
    // 🎯 Apply middlewares
    let processedData = data;
    for (const middleware of this.middlewares) {
      processedData = middleware(processedData);
    }
    
    const result = await this.process(processedData);
    
    if (result !== null) {
      return result;
    }
    
    return this.next ? this.next.handle(data) : null;
  }
  
  protected abstract process(data: T): Promise<T | null>;
}

// 🎯 Chain builder with configuration
class ChainBuilder<T> {
  private factory: HandlerFactory<T>;
  
  constructor(factory: HandlerFactory<T>) {
    this.factory = factory;
  }
  
  build(configs: HandlerConfig[]): Handler<T> | null {
    // 🔢 Sort by priority
    const sorted = configs
      .filter(c => c.enabled)
      .sort((a, b) => a.priority - b.priority);
    
    if (sorted.length === 0) return null;
    
    // 🏗️ Build the chain
    const handlers = sorted
      .map(config => this.factory.create(config.name))
      .filter((h): h is Handler<T> => h !== null);
    
    if (handlers.length === 0) return null;
    
    // 🔗 Link them together
    for (let i = 0; i < handlers.length - 1; i++) {
      handlers[i].setNext(handlers[i + 1]);
    }
    
    return handlers[0];
  }
}

// 📊 Example: Order processing chain
interface Order {
  id: string;
  items: Array<{ name: string; price: number; emoji: string }>;
  total: number;
  status: string;
  customer: {
    name: string;
    membership: 'bronze' | 'silver' | 'gold';
    previousOrders: number;
  };
}

// 💰 Discount handler
class DiscountHandler extends Handler<Order> {
  protected async process(order: Order): Promise<Order | null> {
    if (order.customer.membership === 'gold') {
      const discount = order.total * 0.2;
      console.log(`💰 Applied 20% gold discount: -$${discount.toFixed(2)}`);
      return {
        ...order,
        total: order.total - discount,
        status: 'discounted'
      };
    }
    return null;
  }
}

// 🎁 Loyalty points handler
class LoyaltyHandler extends Handler<Order> {
  protected async process(order: Order): Promise<Order | null> {
    if (order.customer.previousOrders >= 5) {
      const points = Math.floor(order.total * 10);
      console.log(`🎁 Awarded ${points} loyalty points!`);
      return {
        ...order,
        status: 'loyalty_processed'
      };
    }
    return null;
  }
}

// 📦 Inventory check handler
class InventoryHandler extends Handler<Order> {
  private inventory = new Map([
    ['Pizza 🍕', 10],
    ['Burger 🍔', 15],
    ['Taco 🌮', 20]
  ]);
  
  protected async process(order: Order): Promise<Order | null> {
    for (const item of order.items) {
      const stock = this.inventory.get(item.name) || 0;
      if (stock < 1) {
        console.log(`❌ Out of stock: ${item.name}`);
        return {
          ...order,
          status: 'out_of_stock'
        };
      }
    }
    
    console.log('✅ All items in stock!');
    return null;
  }
}

// 🚚 Shipping handler
class ShippingHandler extends Handler<Order> {
  protected async process(order: Order): Promise<Order | null> {
    if (order.total > 50) {
      console.log('🚚 Free shipping applied!');
      return {
        ...order,
        status: 'free_shipping'
      };
    }
    return null;
  }
}

// 🎮 Let's use the advanced chain!
const setupOrderProcessing = () => {
  // 🏭 Setup factory
  const factory = new HandlerFactory<Order>();
  factory.register('discount', DiscountHandler);
  factory.register('loyalty', LoyaltyHandler);
  factory.register('inventory', InventoryHandler);
  factory.register('shipping', ShippingHandler);
  
  // 📋 Configuration
  const config: HandlerConfig[] = [
    { name: 'inventory', priority: 1, enabled: true },
    { name: 'discount', priority: 2, enabled: true },
    { name: 'shipping', priority: 3, enabled: true },
    { name: 'loyalty', priority: 4, enabled: true }
  ];
  
  // 🏗️ Build chain
  const builder = new ChainBuilder(factory);
  return builder.build(config);
};

// 🧪 Test the advanced chain
const orderChain = setupOrderProcessing();
if (orderChain) {
  const testOrder: Order = {
    id: 'ORD-001',
    items: [
      { name: 'Pizza 🍕', price: 15, emoji: '🍕' },
      { name: 'Burger 🍔', price: 12, emoji: '🍔' },
      { name: 'Taco 🌮', price: 8, emoji: '🌮' }
    ],
    total: 60,
    status: 'pending',
    customer: {
      name: 'Alice',
      membership: 'gold',
      previousOrders: 10
    }
  };
  
  orderChain.handle(testOrder).then(result => {
    console.log('📊 Final order:', result);
  });
}

⚠️ Common Pitfalls and Solutions

❌ Wrong: Forgetting to set next handler

// ❌ Broken chain - handlers not connected!
const handler1 = new BotHandler();
const handler2 = new AgentHandler();
const handler3 = new SupervisorHandler();

// 😱 They're not linked!
const result = handler1.handle(ticket); // Only handler1 will work

✅ Correct: Properly linking handlers

// ✅ Properly linked chain
const handler1 = new BotHandler();
const handler2 = new AgentHandler();
const handler3 = new SupervisorHandler();

// 🔗 Link them together
handler1.setNext(handler2).setNext(handler3);

const result = handler1.handle(ticket); // Full chain works!

❌ Wrong: Circular references

// ❌ Infinite loop danger!
const handlerA = new HandlerA();
const handlerB = new HandlerB();

handlerA.setNext(handlerB);
handlerB.setNext(handlerA); // 😱 Circular reference!

✅ Correct: Linear chain with termination

// ✅ Safe linear chain
const handlers: Handler[] = [
  new HandlerA(),
  new HandlerB(),
  new HandlerC()
];

// 🔗 Link in order
for (let i = 0; i < handlers.length - 1; i++) {
  handlers[i].setNext(handlers[i + 1]);
}
// Last handler has no next - chain ends safely

❌ Wrong: Not handling null results

// ❌ Assumes handler always returns something
class BadHandler extends Handler {
  handle(request: Request): Response {
    const result = this.process(request);
    return result.data; // 💥 What if result is null?
  }
}

✅ Correct: Proper null handling

// ✅ Handles null results properly
class GoodHandler extends Handler {
  handle(request: Request): Response | null {
    const result = this.process(request);
    
    if (result) {
      return result;
    }
    
    // 🔍 Try next handler or return default
    return this.next ? this.next.handle(request) : null;
  }
}

🛠️ Best Practices

1. Keep handlers focused 🎯

   • Each handler should have a single responsibility
   • Don’t put too much logic in one handler

2. Order matters 📊

   • Place more specific handlers before general ones
   • Consider performance - put fast checks first

3. Make handlers configurable ⚙️

   • Use constructor parameters for flexibility
   • Allow dynamic chain building

4. Add logging 📝

   • Log which handler processed the request
   • Track performance metrics

5. Handle errors gracefully 🛡️

   • Wrap handler logic in try-catch
   • Decide whether errors stop the chain

6. Use TypeScript features 💎

   • Leverage generics for reusable handlers
   • Use abstract classes for common behavior

7. Test each handler independently 🧪

   • Unit test individual handlers
   • Integration test the full chain

8. Document the chain flow 📚

   • Create diagrams showing handler order
   • Document what each handler handles

🧪 Hands-On Exercise

Time to build your own chain! Create a notification system that sends alerts through different channels based on priority and user preferences.

Your Challenge:

1. Create handlers for Email, SMS, Push, and Slack notifications
2. Implement priority-based routing (critical → all channels, high → SMS+Email, etc.)
3. Add user preference checking (some users might opt-out of certain channels)
4. Include retry logic for failed notifications

// 📱 Notification system implementation
interface Notification {
  id: string;
  message: string;
  priority: 'low' | 'medium' | 'high' | 'critical';
  userId: string;
  timestamp: number;
  channels?: string[];
}

interface UserPreferences {
  userId: string;
  enabledChannels: Set<string>;
  quietHours?: { start: number; end: number };
}

interface NotificationResult {
  sent: boolean;
  channel: string;
  error?: string;
}

// 🏗️ Base notification handler
abstract class NotificationHandler {
  private next: NotificationHandler | null = null;
  protected preferences = new Map<string, UserPreferences>([
    ['user1', { 
      userId: 'user1', 
      enabledChannels: new Set(['email', 'push', 'slack']),
      quietHours: { start: 22, end: 8 }
    }],
    ['user2', { 
      userId: 'user2', 
      enabledChannels: new Set(['email', 'sms']) 
    }]
  ]);
  
  setNext(handler: NotificationHandler): NotificationHandler {
    this.next = handler;
    return handler;
  }
  
  async send(notification: Notification): Promise<NotificationResult[]> {
    const results: NotificationResult[] = [];
    
    // 🔍 Check if this handler should process
    if (this.shouldHandle(notification)) {
      const result = await this.sendNotification(notification);
      results.push(result);
      
      // 🛑 Stop if critical and sent successfully
      if (notification.priority === 'critical' && result.sent) {
        return results;
      }
    }
    
    // 📨 Pass to next handler
    if (this.next) {
      const nextResults = await this.next.send(notification);
      results.push(...nextResults);
    }
    
    return results;
  }
  
  protected abstract shouldHandle(notification: Notification): boolean;
  protected abstract sendNotification(notification: Notification): Promise<NotificationResult>;
  
  protected canSendToUser(userId: string, channel: string): boolean {
    const prefs = this.preferences.get(userId);
    if (!prefs) return true; // Default to enabled
    
    // 🔕 Check quiet hours
    if (prefs.quietHours) {
      const hour = new Date().getHours();
      if (hour >= prefs.quietHours.start || hour < prefs.quietHours.end) {
        console.log(`🔕 User ${userId} is in quiet hours`);
        return false;
      }
    }
    
    return prefs.enabledChannels.has(channel);
  }
}

// 📧 Email handler
class EmailHandler extends NotificationHandler {
  private retryCount = 3;
  
  protected shouldHandle(notification: Notification): boolean {
    return notification.priority !== 'low' &&
           this.canSendToUser(notification.userId, 'email');
  }
  
  protected async sendNotification(notification: Notification): Promise<NotificationResult> {
    let attempts = 0;
    
    while (attempts < this.retryCount) {
      try {
        // 🎯 Simulate sending email
        await this.simulateSend();
        console.log(`📧 Email sent: ${notification.message}`);
        return { sent: true, channel: 'email' };
      } catch (error) {
        attempts++;
        console.log(`❌ Email attempt ${attempts} failed`);
      }
    }
    
    return { sent: false, channel: 'email', error: 'Max retries exceeded' };
  }
  
  private async simulateSend(): Promise<void> {
    // 90% success rate
    if (Math.random() > 0.9) {
      throw new Error('Network timeout');
    }
  }
}

// 📱 SMS handler
class SMSHandler extends NotificationHandler {
  protected shouldHandle(notification: Notification): boolean {
    return (notification.priority === 'high' || notification.priority === 'critical') &&
           this.canSendToUser(notification.userId, 'sms');
  }
  
  protected async sendNotification(notification: Notification): Promise<NotificationResult> {
    // 📝 Truncate message for SMS
    const truncated = notification.message.substring(0, 160);
    console.log(`📱 SMS sent: ${truncated}`);
    return { sent: true, channel: 'sms' };
  }
}

// 🔔 Push notification handler
class PushHandler extends NotificationHandler {
  protected shouldHandle(notification: Notification): boolean {
    return notification.priority !== 'low' &&
           this.canSendToUser(notification.userId, 'push');
  }
  
  protected async sendNotification(notification: Notification): Promise<NotificationResult> {
    console.log(`🔔 Push notification sent: ${notification.message}`);
    return { sent: true, channel: 'push' };
  }
}

// 💬 Slack handler
class SlackHandler extends NotificationHandler {
  protected shouldHandle(notification: Notification): boolean {
    return notification.priority === 'critical' &&
           this.canSendToUser(notification.userId, 'slack');
  }
  
  protected async sendNotification(notification: Notification): Promise<NotificationResult> {
    const formattedMessage = `🚨 *Critical Alert*\n${notification.message}`;
    console.log(`💬 Slack message sent: ${formattedMessage}`);
    return { sent: true, channel: 'slack' };
  }
}

// 🏗️ Build notification chain
const buildNotificationChain = (): NotificationHandler => {
  const email = new EmailHandler();
  const sms = new SMSHandler();
  const push = new PushHandler();
  const slack = new SlackHandler();
  
  email.setNext(sms).setNext(push).setNext(slack);
  
  return email;
};

// 🧪 Test the notification system
const testNotificationSystem = async () => {
  const chain = buildNotificationChain();
  
  const notifications: Notification[] = [
    {
      id: 'N001',
      message: 'Your order has been shipped! 📦',
      priority: 'low',
      userId: 'user1',
      timestamp: Date.now()
    },
    {
      id: 'N002',
      message: 'Payment reminder: $99 due tomorrow 💳',
      priority: 'high',
      userId: 'user1',
      timestamp: Date.now()
    },
    {
      id: 'N003',
      message: 'SECURITY ALERT: Unusual login detected! 🚨',
      priority: 'critical',
      userId: 'user2',
      timestamp: Date.now()
    }
  ];
  
  for (const notification of notifications) {
    console.log(`\n📨 Processing ${notification.priority} notification:`);
    const results = await chain.send(notification);
    console.log('Results:', results);
  }
};

// 🎮 Run the test!
testNotificationSystem();

🎓 Key Takeaways

You’ve mastered the Chain of Responsibility pattern! Here’s what you’ve learned:

• 🔗 Chain building: Link handlers together to create processing pipelines
• 🎯 Single responsibility: Each handler focuses on one type of request
• ➡️ Request forwarding: Pass requests along until someone handles them
• 🛡️ Decoupling: Senders don’t need to know about specific handlers
• 🔧 Flexibility: Easily add, remove, or reorder handlers
• 🎮 Real-world uses: Support systems, authentication, validation, and more!

The Chain of Responsibility pattern is perfect when you need to:

• Process requests through multiple steps
• Allow different handlers for different scenarios
• Build flexible, extensible systems
• Decouple request senders from handlers

🤝 Next Steps

Congratulations! 🎉 You’ve built some amazing chain-based systems! Your request handling skills are now top-notch!

To continue your journey:

• Try combining chains with other patterns (like Strategy or Observer)
• Build a middleware system for a web framework
• Create a plugin architecture using chains
• Implement an event processing pipeline

Keep building those chains, and remember - every great system is just a series of well-connected handlers! You’re doing fantastic! 🌟

Happy coding! 🚀✨