Advanced Error Handling & Retry Logic

function shouldRetry(error: Error): boolean {
  const message = error.message.toLowerCase();

  // Network errors - retry
  if (message.includes('timeout') ||
      message.includes('econnrefused') ||
      message.includes('network')) {
    return true;
  }

  // Rate limit - retry
  if (message.includes('rate limit') || message.includes('429')) {
    return true;
  }

  // Configuration errors - don't retry
  if (message.includes('no scheme registered') ||
      message.includes('insufficient funds') ||
      message.includes('invalid signature')) {
    return false;
  }

  // Default: don't retry
  return false;
}

async function retryWithBackoff<T>(
  operation: () => Promise<T>,
  maxRetries = 3
): Promise<T> {
  let delay = 1000; // Start with 1 second

  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    try {
      return await operation();
    } catch (error) {
      // Don't retry if non-retryable
      if (!shouldRetry(error as Error)) {
        throw error;
      }

      // Last attempt failed
      if (attempt === maxRetries) {
        throw error;
      }

      console.log(`Retry ${attempt + 1}/${maxRetries} in ${delay}ms...`);
      await new Promise(resolve => setTimeout(resolve, delay));

      // Double the delay for next attempt
      delay *= 2;
    }
  }

  throw new Error('Max retries reached');
}

// Usage
const data = await retryWithBackoff(async () => {
  const response = await fetchWithPayment('https://api.example.com/data');
  return response.json();
}, 3);

function addJitter(delay: number): number {
  // Add ±30% randomness
  const jitter = delay * 0.3 * (Math.random() * 2 - 1);
  return Math.max(0, delay + jitter);
}

// Instead of exactly 2000ms, get something like 1700ms or 2300ms
const delayWithJitter = addJitter(2000);

class CircuitBreaker {
  private failures = 0;
  private readonly threshold = 5;
  private isOpen = false;
  private resetTime = 0;

  async execute<T>(operation: () => Promise<T>): Promise<T> {
    // Circuit is open - reject immediately
    if (this.isOpen && Date.now() < this.resetTime) {
      throw new Error('Circuit breaker is OPEN');
    }

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

  private onSuccess() {
    this.failures = 0;
    this.isOpen = false;
  }

  private onFailure() {
    this.failures++;
    if (this.failures >= this.threshold) {
      this.isOpen = true;
      this.resetTime = Date.now() + 60000; // Wait 60s before trying again
      console.warn('Circuit breaker opened - too many failures');
    }
  }
}

// Usage
const breaker = new CircuitBreaker();

try {
  const data = await breaker.execute(async () => {
    const response = await fetchWithPayment(url);
    return response.json();
  });
} catch (error) {
  console.error('Request failed:', error.message);
}