Circuit breaker wrapper for flaky third-party APIs

import { CircuitBreakerOptions, CircuitOpenError, CircuitState } from "./types";

export class CircuitBreaker {
  private state: CircuitState = "closed";
  private failures = 0;
  private openedAt = 0;

  constructor(private readonly opts: CircuitBreakerOptions) {}

  async execute<T>(fn: () => Promise<T>): Promise<T> {
    if (this.state === "open") {
      const elapsed = Date.now() - this.openedAt;
      if (elapsed < this.opts.resetTimeout) {
        throw new CircuitOpenError(this.opts.resetTimeout - elapsed);
      }
      this.transition("half-open");
    }

    try {
      const result = await fn();
      this.onSuccess();
      return result;
    } catch (err) {
      this.onFailure();
      throw err;
    }
  }

  private onSuccess(): void {
    this.failures = 0;
    if (this.state !== "closed") this.transition("closed");
  }

  private onFailure(): void {
    this.failures += 1;
    if (this.state === "half-open" || this.failures >= this.opts.failureThreshold) {
      this.openedAt = Date.now();
      this.transition("open");
    }
  }

  private transition(to: CircuitState): void {
    if (to === this.state) return;
    const from = this.state;
    this.state = to;
    if (to === "closed") this.failures = 0;
    this.opts.onStateChange?.(from, to);
  }
}

import { CircuitBreaker } from "./CircuitBreaker";

export interface Charge {
  id: string;
  status: "pending" | "succeeded" | "failed";
}

export class PaymentApiClient {
  private readonly breaker: CircuitBreaker;

  constructor(private readonly baseUrl: string, private readonly apiKey: string) {
    this.breaker = new CircuitBreaker({
      failureThreshold: 5,
      resetTimeout: 30_000,
      onStateChange: (from, to) =>
        console.warn(`[payments] circuit ${from} -> ${to}`),
    });
  }

  createCharge(amountCents: number, currency: string): Promise<Charge> {
    return this.breaker.execute(() =>
      this.request<Charge>("POST", "/v1/charges", { amountCents, currency }),
    );
  }

  getCharge(id: string): Promise<Charge> {
    return this.breaker.execute(() =>
      this.request<Charge>("GET", `/v1/charges/${id}`),
    );
  }

  private async request<T>(method: string, path: string, body?: unknown): Promise<T> {
    const res = await this.withTimeout(5_000, (signal) =>
      fetch(`${this.baseUrl}${path}`, {
        method,
        signal,
        headers: {
          Authorization: `Bearer ${this.apiKey}`,
          "Content-Type": "application/json",
        },
        body: body ? JSON.stringify(body) : undefined,
      }),
    );

    if (!res.ok) {
      throw new Error(`payment api ${res.status} on ${method} ${path}`);
    }
    return (await res.json()) as T;
  }

  private async withTimeout<T>(ms: number, fn: (signal: AbortSignal) => Promise<T>): Promise<T> {
    const controller = new AbortController();
    const timer = setTimeout(() => controller.abort(), ms);
    try {
      return await fn(controller.signal);
    } finally {
      clearTimeout(timer);
    }
  }
}