Decorator

interface FareService { quote(rideId: string): number; }

class FareTimeout extends Error {}

// The real thing: a pricing service across the network that times out on calls 1 and 3.
class RemoteFares implements FareService {
  private readonly prices: Record<string, number> = { "R-1": 280, "R-2": 120 };
  calls = 0;
  quote(rideId: string): number {
    this.calls++;
    if (this.calls === 1 || this.calls === 3) throw new FareTimeout(rideId);
    return this.prices[rideId];
  }
}

// ---- Decorators: each is a FareService that holds another FareService and adds one behaviour. ----
class Retrying implements FareService {
  constructor(private readonly inner: FareService, private readonly attempts = 3) {}
  quote(rideId: string): number {
    for (let attempt = 1; ; attempt++) {
      try {
        return this.inner.quote(rideId);
      } catch (e) {
        if (!(e instanceof FareTimeout) || attempt === this.attempts) throw e;
      }
    }
  }
}

class Caching implements FareService {
  private readonly cache = new Map<string, number>();
  constructor(private readonly inner: FareService) {}
  quote(rideId: string): number {
    if (!this.cache.has(rideId)) this.cache.set(rideId, this.inner.quote(rideId));
    return this.cache.get(rideId)!;
  }
}

class Logging implements FareService {
  constructor(private readonly inner: FareService, private readonly log: string[]) {}
  quote(rideId: string): number {
    const pence = this.inner.quote(rideId);
    this.log.push(`quote ${rideId} -> ${pence}p`);
    return pence;
  }
}

const log: string[] = [];
const remote = new RemoteFares();
const fares: FareService = new Logging(new Caching(new Retrying(remote)), log);   // outermost first
for (const ride of ["R-1", "R-1", "R-2"]) console.log(`${ride}: ${fares.quote(ride)}p`);
console.log("log: " + log.join(" | "));
console.log(`remote calls: ${remote.calls} (two timeouts retried, one answer from the cache)`);

const log2: string[] = [];
const swapped: FareService = new Caching(new Logging(new Retrying(new RemoteFares()), log2));   // same wrappers, another order
for (const ride of ["R-1", "R-1", "R-2"]) swapped.quote(ride);
console.log(`with logging inside the cache: ${log2.length} log lines for 3 quotes`);

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Main {
    interface FareService { int quote(String rideId); }

    static class FareTimeout extends RuntimeException {
        private static final long serialVersionUID = 1L;
        FareTimeout(String rideId) { super(rideId); }
    }

    // The real thing: a pricing service across the network that times out on calls 1 and 3.
    static class RemoteFares implements FareService {
        private final Map<String, Integer> prices = Map.of("R-1", 280, "R-2", 120);
        int calls;
        public int quote(String rideId) {
            calls++;
            if (calls == 1 || calls == 3) throw new FareTimeout(rideId);
            return prices.get(rideId);
        }
    }

    // ---- Decorators: each is a FareService that holds another FareService and adds one behaviour. ----
    static class Retrying implements FareService {
        private final FareService inner;
        private final int attempts;
        Retrying(FareService inner, int attempts) { this.inner = inner; this.attempts = attempts; }
        public int quote(String rideId) {
            for (int attempt = 1; ; attempt++) {
                try {
                    return inner.quote(rideId);
                } catch (FareTimeout e) {
                    if (attempt == attempts) throw e;
                }
            }
        }
    }

    static class Caching implements FareService {
        private final FareService inner;
        private final Map<String, Integer> cache = new HashMap<>();
        Caching(FareService inner) { this.inner = inner; }
        public int quote(String rideId) {
            Integer hit = cache.get(rideId);
            if (hit != null) return hit;
            int pence = inner.quote(rideId);
            cache.put(rideId, pence);
            return pence;
        }
    }

    static class Logging implements FareService {
        private final FareService inner;
        private final List<String> log;
        Logging(FareService inner, List<String> log) { this.inner = inner; this.log = log; }
        public int quote(String rideId) {
            int pence = inner.quote(rideId);
            log.add("quote " + rideId + " -> " + pence + "p");
            return pence;
        }
    }

    public static void main(String[] args) {
        List<String> log = new ArrayList<>();
        RemoteFares remote = new RemoteFares();
        FareService fares = new Logging(new Caching(new Retrying(remote, 3)), log);   // outermost first
        for (String ride : List.of("R-1", "R-1", "R-2")) System.out.println(ride + ": " + fares.quote(ride) + "p");
        System.out.println("log: " + String.join(" | ", log));
        System.out.println("remote calls: " + remote.calls + " (two timeouts retried, one answer from the cache)");

        List<String> log2 = new ArrayList<>();
        FareService swapped = new Caching(new Logging(new Retrying(new RemoteFares(), 3), log2));   // same wrappers, another order
        for (String ride : List.of("R-1", "R-1", "R-2")) swapped.quote(ride);
        System.out.println("with logging inside the cache: " + log2.size() + " log lines for 3 quotes");
    }
}