Replace conditional with polymorphism

Pin the behaviour before you touch the structure — characterization tests come first. You cannot safely transform code you can’t observe. Before introducing any interface, write tests that capture what the switch currently does for every case, including the weird ones. These aren’t tests of correct behaviour; they’re tests of actual behaviour — a net under the trapeze.

// characterize the CURRENT fee() for every method — including the 'wire = 0' edge
describe("fee (current behaviour)", () => {
  test.each([
    ["card",   1000, 59],   // 1000 * 0.029 + 30
    ["paypal", 1000, 83],   // 1000 * 0.034 + 49
    ["wire",   1000, 0],
    ["ach",    1000, 0],    // legacy: ACH was silently free — pin it even if it's a bug
  ])("%s on %d → %d", (method, amount, expected) => {
    expect(fee({ method, amount } as Payment)).toBe(expected);
  });
});

If ach returning 0 is actually a latent bug, you still pin it. The refactor must preserve behaviour exactly; fixing the bug is a separate commit with its own test change. Mixing the two is how “just a refactor” ships a regression.

Introduce the interface and a factory beside the live switch — don’t replace anything yet (parallel change). Add the new structure next to the old code so both exist at once. Nothing calls the new classes yet; the switch still runs in production. This is the expand phase of a parallel change: you build the destination before you redirect traffic to it.

interface PaymentMethod {
  fee(amount: number): number;
}

class Card implements PaymentMethod {
  fee(amount: number) { return amount * 0.029 + 30; }
}

// factory: the ONE place that still knows the string→type mapping
function methodFor(p: Payment): PaymentMethod {
  switch (p.method) {
    case "card": return new Card();
    // others fall through to the old path for now
    default: return new LegacyAdapter(p);
  }
}

The LegacyAdapter delegates back to the original switch for any case not yet migrated. Now the system runs on the new dispatch path for card and the old path for everything else — and your characterization tests still pass, because behaviour is identical. Commit here.

Migrate one case at a time; run the tests after each. This is the heart of the move. For each variant: create its class, copy the case body into the method, point the factory at it, delete that one case from the original switch, run the suite. One case, one green bar, one commit. If a step goes red, you’ve isolated the break to a single small change you can revert in seconds.

class Wire implements PaymentMethod {
  fee(_amount: number) { return 0; }   // copied verbatim from `case "wire"`
}
// factory gains: case "wire": return new Wire();
// original switch loses: case "wire": return 0;
// → run tests → green → commit

Resist the urge to migrate all five at once “to save commits.” The whole value of the technique is that a mistake is bounded to one case and reversible. Five-at-once turns a safe sequence into a risky rewrite that just happens to be split across fewer keystrokes.

Delete the switch last — only when nothing reads it. When every case has moved onto a class and the factory’s default/LegacyAdapter branch is unreachable, the original switch and the adapter are dead code. Now delete them. The contraction phase: the old path is gone, the new path is the only path, and the tests that passed at every step still pass.

function methodFor(p: Payment): PaymentMethod {
  switch (p.method) {           // now the ONLY switch left — a pure factory
    case "card":   return new Card();
    case "paypal": return new PayPal();
    case "wire":   return new Wire();
    case "ach":    return new Ach();
  }
}
// every OTHER switch on p.method across the codebase is now gone

Notice one switch survives — the factory. That’s correct and intended: you’ve collapsed N scattered type-switches into a single point of dispatch. Adding crypto is now one class plus one factory line, not a hunt across four files. If you also want the compiler to enforce exhaustiveness, a Record<Payment["method"], …> dispatch map replaces even the factory switch.