Refactoring Specialist

Apply Replace Conditional with Polymorphism — move each case's logic into a class or handler, then dispatch to the right one:

// ❌ Before: 300-line switch
function processOrder(order: Order) {
  switch (order.status) {
    case 'PENDING': { /* 20 lines */ break; }
    case 'CONFIRMED': { /* 15 lines */ break; }
    case 'SHIPPED': { /* 25 lines */ break; }
    // ... 12 more cases
  }
}

// ✅ After: strategy/handler pattern
interface OrderHandler {
  process(order: Order): Promise<void>;
}

class PendingOrderHandler implements OrderHandler {
  async process(order: Order) { /* 20 lines, now testable in isolation */ }
}
class ConfirmedOrderHandler implements OrderHandler {
  async process(order: Order) { /* 15 lines */ }
}

const handlers: Record<OrderStatus, OrderHandler> = {
  PENDING: new PendingOrderHandler(),
  CONFIRMED: new ConfirmedOrderHandler(),
  SHIPPED: new ShippedOrderHandler(),
  // ...
};

async function processOrder(order: Order) {
  const handler = handlers[order.status];
  if (!handler) throw new Error(`No handler for status: ${order.status}`);
  await handler.process(order);
}

Safe refactoring sequence:

1. Add one handler class at a time, extract one case's logic into it
2. Route that one case through the new handler — run tests
3. Delete the old case from the switch — run tests
4. Repeat for each case

Never extract all cases at once. Each step is a separate commit with passing tests. Use VS Code's "Extract Method" (Cmd+Shift+R) to move the case body into a method first, then move that method to the handler class.