Adapter

// ---- What Pedal's checkout wants: pence in, a clear result out. ----
interface ChargeResult { ok: boolean; detail: string; }   // detail: a reference when ok, a reason when not

interface PaymentGateway { charge(rider: string, pence: number): ChargeResult; }

// ---- Two providers' SDKs, as they come. We can't change them. ----
class LumenPaySdk {   // takes pounds as a string, answers with a status object
  private nextRef = 1001;
  makePayment(amount: string, customer: string): Record<string, string> {
    void customer;
    if (Number(amount) > 500) return { status: "declined", reason: "insufficient funds" };
    return { status: "ok", ref: `LP-${this.nextRef++}` };
  }
}

class OrbitError extends Error {}
class OrbitTxn { constructor(readonly txnId: number) {} }

class OrbitCardsSdk {   // takes minor units and a currency code, throws on failure
  private count = 0;
  debit(account: string, minorUnits: number, currency: string): OrbitTxn {
    void account; void currency;
    if (minorUnits > 50_000) throw new OrbitError("limit exceeded");
    return new OrbitTxn(++this.count);
  }
}

// ---- Adapters: each makes one SDK look like a PaymentGateway. ----
class LumenAdapter implements PaymentGateway {
  constructor(private readonly sdk: LumenPaySdk) {}
  charge(rider: string, pence: number): ChargeResult {
    const reply = this.sdk.makePayment(`${Math.floor(pence / 100)}.${String(pence % 100).padStart(2, "0")}`, rider);   // pence -> "2.80"
    return reply.status === "ok" ? { ok: true, detail: reply.ref } : { ok: false, detail: reply.reason };
  }
}

class OrbitAdapter implements PaymentGateway {
  constructor(private readonly sdk: OrbitCardsSdk) {}
  charge(rider: string, pence: number): ChargeResult {
    try {
      const txn = this.sdk.debit(rider, pence, "GBP");                    // pence are already minor units
      return { ok: true, detail: `ORB-${txn.txnId}` };
    } catch (e) {
      if (e instanceof OrbitError) return { ok: false, detail: e.message };   // exception -> result
      throw e;
    }
  }
}

// ---- The client: written once, against the interface it wanted. ----
function checkout(gateway: PaymentGateway, name: string, rider: string, pence: number): string {
  const r = gateway.charge(rider, pence);
  return `checkout via ${name}: ${pence}p ` + (r.ok ? `charged, ref ${r.detail}` : `declined (${r.detail})`);
}

const gateways: [string, PaymentGateway][] = [["lumen", new LumenAdapter(new LumenPaySdk())], ["orbit", new OrbitAdapter(new OrbitCardsSdk())]];
for (const [name, gw] of gateways) console.log(checkout(gw, name, "rider-7", 280));
for (const [name, gw] of gateways) console.log(checkout(gw, name, "rider-7", 99_999));

import java.math.BigDecimal;
import java.util.LinkedHashMap;
import java.util.Map;

public class Main {
    // ---- What Pedal's checkout wants: pence in, a clear result out. ----
    record ChargeResult(boolean ok, String detail) {}   // detail: a reference when ok, a reason when not

    interface PaymentGateway { ChargeResult charge(String rider, int pence); }

    // ---- Two providers' SDKs, as they come. We can't change them. ----
    static class LumenPaySdk {   // takes pounds as a string, answers with a status map
        private int nextRef = 1001;
        Map<String, String> makePayment(String amount, String customer) {
            if (new BigDecimal(amount).compareTo(new BigDecimal(500)) > 0) return Map.of("status", "declined", "reason", "insufficient funds");
            return Map.of("status", "ok", "ref", "LP-" + nextRef++);
        }
    }

    static class OrbitException extends Exception {
        private static final long serialVersionUID = 1L;
        OrbitException(String message) { super(message); }
    }

    record OrbitTxn(int txnId) {}

    static class OrbitCardsSdk {   // takes minor units and a currency code, throws on failure
        private int count;
        OrbitTxn debit(String account, int minorUnits, String currency) throws OrbitException {
            if (minorUnits > 50_000) throw new OrbitException("limit exceeded");
            return new OrbitTxn(++count);
        }
    }

    // ---- Adapters: each makes one SDK look like a PaymentGateway. ----
    static class LumenAdapter implements PaymentGateway {
        private final LumenPaySdk sdk;
        LumenAdapter(LumenPaySdk sdk) { this.sdk = sdk; }
        public ChargeResult charge(String rider, int pence) {
            Map<String, String> reply = sdk.makePayment(String.format("%d.%02d", pence / 100, pence % 100), rider);   // pence -> "2.80"
            return reply.get("status").equals("ok") ? new ChargeResult(true, reply.get("ref")) : new ChargeResult(false, reply.get("reason"));
        }
    }

    static class OrbitAdapter implements PaymentGateway {
        private final OrbitCardsSdk sdk;
        OrbitAdapter(OrbitCardsSdk sdk) { this.sdk = sdk; }
        public ChargeResult charge(String rider, int pence) {
            try {
                OrbitTxn txn = sdk.debit(rider, pence, "GBP");                       // pence are already minor units
                return new ChargeResult(true, "ORB-" + txn.txnId());
            } catch (OrbitException e) {                                           // exception -> result
                return new ChargeResult(false, e.getMessage());
            }
        }
    }

    // ---- The client: written once, against the interface it wanted. ----
    static String checkout(PaymentGateway gateway, String name, String rider, int pence) {
        ChargeResult r = gateway.charge(rider, pence);
        return "checkout via " + name + ": " + pence + "p " + (r.ok() ? "charged, ref " + r.detail() : "declined (" + r.detail() + ")");
    }

    public static void main(String[] args) {
        Map<String, PaymentGateway> gateways = new LinkedHashMap<>();
        gateways.put("lumen", new LumenAdapter(new LumenPaySdk()));
        gateways.put("orbit", new OrbitAdapter(new OrbitCardsSdk()));
        for (Map.Entry<String, PaymentGateway> e : gateways.entrySet()) System.out.println(checkout(e.getValue(), e.getKey(), "rider-7", 280));
        for (Map.Entry<String, PaymentGateway> e : gateways.entrySet()) System.out.println(checkout(e.getValue(), e.getKey(), "rider-7", 99_999));
    }
}