┌──────────┐  failure threshold  ┌──────────┐
│  CLOSED  │ ──────────────────→ │   OPEN   │
│ (normal) │                     │(fail fast)│
└──────────┘                     └──────────┘
     ↑                                │
     │   success                      │ cooldown expires
     │                                ↓
     │                          ┌───────────┐
     └───────────────────────── │ HALF-OPEN │
                                │  (testing) │
                                └───────────┘
              failure → back to OPEN

type CircuitState = 'CLOSED' | 'OPEN' | 'HALF_OPEN';

interface CircuitBreakerOptions {
  failureThreshold: number;  // failures before opening
  resetTimeout: number;      // ms before trying half-open
  monitorWindow: number;     // ms window for counting failures
}

class CircuitBreaker {
  private state: CircuitState = 'CLOSED';
  private failures: number[] = [];  // timestamps of recent failures
  private lastFailureTime: number = 0;
  private options: CircuitBreakerOptions;

  constructor(options: CircuitBreakerOptions) {
    this.options = options;
  }

  async call<T>(fn: () => Promise<T>): Promise<T> {
    // OPEN: fail immediately
    if (this.state === 'OPEN') {
      if (Date.now() - this.lastFailureTime >= this.options.resetTimeout) {
        this.state = 'HALF_OPEN';
      } else {
        throw new CircuitOpenError('Circuit is OPEN - failing fast');
      }
    }

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

  private onSuccess(): void {
    if (this.state === 'HALF_OPEN') {
      // Test request succeeded - close the circuit
      this.state = 'CLOSED';
      this.failures = [];
      console.log('Circuit CLOSED - service recovered');
    }
  }

  private onFailure(): void {
    const now = Date.now();
    this.lastFailureTime = now;

    // Remove failures outside the monitoring window
    this.failures = this.failures.filter(
      (t) => now - t < this.options.monitorWindow
    );
    this.failures.push(now);

    if (this.state === 'HALF_OPEN') {
      // Test request failed - reopen the circuit
      this.state = 'OPEN';
      console.log('Circuit OPEN - test request failed');
      return;
    }

    if (this.failures.length >= this.options.failureThreshold) {
      this.state = 'OPEN';
      console.log(
        `Circuit OPEN - ${this.failures.length} failures in ` +
        `${this.options.monitorWindow}ms`
      );
    }
  }

  getState(): CircuitState {
    return this.state;
  }
}

class CircuitOpenError extends Error {
  constructor(message: string) {
    super(message);
    this.name = 'CircuitOpenError';
  }
}

const paymentBreaker = new CircuitBreaker({
  failureThreshold: 5,     // open after 5 failures
  resetTimeout: 30000,     // try again after 30 seconds
  monitorWindow: 60000,    // count failures in a 60-second window
});

async function chargeCustomer(amount: number): Promise<PaymentResult> {
  try {
    return await paymentBreaker.call(() =>
      fetch('https://payments.example.com/charge', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ amount }),
      }).then((res) => {
        if (!res.ok) throw new Error(`Payment failed: ${res.status}`);
        return res.json();
      })
    );
  } catch (error) {
    if (error instanceof CircuitOpenError) {
      // Circuit is open - don't even try, return a friendly error
      return { status: 'unavailable', message: 'Payment service temporarily unavailable. Try again shortly.' };
    }
    throw error;
  }
}

import CircuitBreaker from 'opossum';

// Wrap any async function
const breaker = new CircuitBreaker(
  async (userId: string) => {
    const res = await fetch(`https://api.example.com/users/${userId}`);
    if (!res.ok) throw new Error(`API error: ${res.status}`);
    return res.json();
  },
  {
    timeout: 5000,            // call times out after 5s
    errorThresholdPercentage: 50,  // open at 50% failure rate
    resetTimeout: 30000,       // try half-open after 30s
    volumeThreshold: 10,       // need at least 10 calls before tripping
  }
);

// Fallback when circuit is open
breaker.fallback((userId: string) => {
  return { id: userId, name: 'Unknown', source: 'cache' };
});

// Events for monitoring
breaker.on('open', () => console.log('Circuit OPENED'));
breaker.on('halfOpen', () => console.log('Circuit HALF-OPEN'));
breaker.on('close', () => console.log('Circuit CLOSED'));
breaker.on('fallback', () => metrics.increment('circuit.fallback'));

// Use it
const user = await breaker.fire('user-123');