Adapter pattern

Overview

The Adapter pattern converts the interface of an existing class into the interface a client expects, so classes with incompatible interfaces can work together. Your code expects PaymentGateway.charge(amount), but the vendor SDK offers createTransaction({ value, currency, metadata }); an adapter translates between them.

Adapters are the standard way to integrate third-party libraries, legacy code, and external APIs without spreading their types through your codebase. Combined with DIP, they form the 'adapters' in ports-and-adapters architecture.

When to use it

• Integrating a vendor SDK or legacy class with a different interface.
• Supporting several providers behind one interface.
• Isolating your code from external API changes.

Where it shows up in interviews

Where it is used in real software

Key terms

Target

The interface the client expects.

Adaptee

The existing class with an incompatible interface.

Adapter

Implements the target and delegates to the adaptee.

Object vs class adapter

Composition (preferred) vs inheritance.

How it works, step by step

1. 1
   Define the target interface

   What your domain needs.

2. 2
   Wrap the adaptee

   Hold it as a field.

3. 3
   Translate calls

   Map parameters, units, and names.

4. 4
   Translate results and errors

   Return domain types and exceptions.

5. 5
   Inject the adapter

   Clients only see the target.

Payment provider adapters

Target: charge(customerId, amountCents): ChargeResult

Business code calls one interface; each provider's quirks stay in its adapter.

Implementation

1// Target interface owned by our domain2interface PaymentGateway {3  charge(customerId: string, amountCents: number): Promise<{ ok: boolean; reference: string }>;4}5 6// Adaptee: legacy client with a different shape7class LegacyBankClient {8  async debit(account: string, amount: string): Promise<{ code: "00" | "51" | "91"; txn: string }> {9    return { code: "00", txn: "TX-" + account + "-" + amount };10  }11}12 13class LegacyBankAdapter implements PaymentGateway {14  constructor(private bank: LegacyBankClient, private accounts: Map<string, string>) {}15 16  async charge(customerId: string, amountCents: number) {17    const account = this.accounts.get(customerId);18    if (!account) throw new Error("No bank account on file");19    const res = await this.bank.debit(account, (amountCents / 100).toFixed(2)); // unit conversion20    return { ok: res.code === "00", reference: res.txn };                      // result mapping21  }22}

Complexity and performance

Trade-offs

Variants and related techniques

Common mistakes

• Leaking adaptee exceptions or types.

  Fix: Translate them to domain types.

• Adding business logic to adapters.

  Fix: Adapters translate; rules belong in the domain.

Interview questions

Practice problems