Adapter Pattern: Translate at the Boundary

What is the Adapter pattern?

The Adapter pattern is a structural design pattern that lets objects with incompatible interfaces work together. An adapter implements the interface your code expects, wraps the object that has the wrong shape, and translates every call between the two — in both directions when needed.

Its real value is architectural: it pins incompatibility to one file. Without an adapter, a vendor's payload shape seeps into every caller, and swapping vendors means an archaeology project. With adapters, your domain defines the contract it wants, each vendor gets one translation layer, and replacing Stripe with a bank gateway means writing one new adapter — not rewriting checkout.

The logic, step by step

// The contract YOUR domain wants:
interface PaymentGateway {
  charge(amountCents: number, currency: string, token: string): Promise<ChargeResult>;
}

// The vendor SDK you actually have (wrong shape, wrong units):
class StripeClient {
  async createPaymentIntent(opts: {
    amount: number; currency: string; payment_method: string; confirm: boolean;
  }): Promise<{ id: string; status: 'succeeded' | 'requires_action' }> { /* ... */ }
}

class StripeAdapter implements PaymentGateway {
  constructor(private stripe: StripeClient) {}

  async charge(amountCents: number, currency: string, token: string): Promise<ChargeResult> {
    const intent = await this.stripe.createPaymentIntent({
      amount: amountCents,
      currency: currency.toLowerCase(),   // vendor quirk stays here
      payment_method: token,
      confirm: true,
    });
    return { ok: intent.status === 'succeeded', reference: intent.id };
  }
}

// Checkout depends on PaymentGateway only — Stripe is a config detail.
const gateway: PaymentGateway = new StripeAdapter(new StripeClient());

When to use it — and when not to

Adapter vs related patterns

Decorator pattern — Both wrap an object, but Decorator preserves the interface and adds behavior, while Adapter changes the interface and adds nothing. Same mechanics, opposite purpose.

Facade pattern — Adapter reshapes one incompatible thing to fit an existing contract; Facade invents a new, simpler contract over many things. Adapter fits, Facade simplifies.