// Using node-fetch with separate connect and read timeouts
import { Agent } from 'http';

const agent = new Agent({
  timeout: 3000,          // connect timeout: 3 seconds
  keepAlive: true,
  maxSockets: 50,
});

const response = await fetch('https://api.example.com/data', {
  agent,
  signal: AbortSignal.timeout(10000),  // total timeout: 10 seconds
});

import axios from 'axios';

const client = axios.create({
  timeout: 10000,                 // total timeout: 10 seconds
  // For separate connect/read timeouts, use custom adapter or httpAgent
  httpAgent: new Agent({
    timeout: 3000,                // connect timeout
  }),
});

// Per-request override for slow endpoints
const report = await client.get('/reports/annual', {
  timeout: 30000,                 // this one is legitimately slow
});

User request (10s budget)
  ├── Service A (10s timeout) → might use 10s
  ├── Service B (10s timeout) → might use 10s
  └── Service C (10s timeout) → might use 10s

Worst case: 30 seconds. Gateway timed out at 10s.
The user sees an error. Your server is still working on a dead request.

class TimeoutBudget {
  private deadline: number;

  constructor(totalMs: number) {
    this.deadline = Date.now() + totalMs;
  }

  remaining(): number {
    return Math.max(0, this.deadline - Date.now());
  }

  hasExpired(): boolean {
    return Date.now() >= this.deadline;
  }

  // Create a signal that aborts when the budget is exhausted
  toAbortSignal(): AbortSignal {
    return AbortSignal.timeout(this.remaining());
  }
}

// Usage: distribute a 10-second budget across three calls
async function handleRequest(req: Request): Promise<Response> {
  const budget = new TimeoutBudget(10000); // 10 seconds total

  // Each call gets whatever time is left
  const user = await fetch('https://users.internal/api/user/123', {
    signal: budget.toAbortSignal(),
  }).then((r) => r.json());

  if (budget.hasExpired()) {
    return Response.json({ error: 'Timeout' }, { status: 504 });
  }

  const orders = await fetch('https://orders.internal/api/user/123/orders', {
    signal: budget.toAbortSignal(),
  }).then((r) => r.json());

  if (budget.hasExpired()) {
    return Response.json(
      { user, orders: [], note: 'Orders timed out' },
      { status: 200 }  // partial success
    );
  }

  const recommendations = await fetch('https://recs.internal/api/user/123', {
    signal: budget.toAbortSignal(),
  }).then((r) => r.json()).catch(() => []);  // optional, fail silently

  return Response.json({ user, orders, recommendations });
}

async function getProductPage(productId: string): Promise<ProductPage> {
  // Critical: product data must exist
  const product = await productService.getProduct(productId);

  // Degraded: show cached price if pricing service is down
  let price: Price;
  try {
    price = await pricingService.getPrice(productId);
  } catch {
    price = await cache.get(`price:${productId}`) ?? product.basePrice;
  }

  // Optional: recommendations are nice but not essential
  const recommendations = await recommendationService
    .getRecommendations(productId)
    .catch(() => getFallbackRecommendations(product.category));

  // Optional: reviews are non-critical
  const reviews = await reviewService
    .getReviews(productId)
    .catch(() => ({ items: [], total: 0, note: 'Reviews temporarily unavailable' }));

  return { product, price, recommendations, reviews };
}

async function fetchWithCache<T>(
  key: string,
  fetcher: () => Promise<T>,
  ttlMs: number = 300000  // 5 minutes default
): Promise<T> {
  try {
    const fresh = await fetcher();
    await cache.set(key, fresh, ttlMs);
    return fresh;
  } catch (error) {
    // Live fetch failed - try cache
    const cached = await cache.get<T>(key);
    if (cached) {
      console.warn(`Serving stale cache for ${key}: ${error}`);
      return cached;
    }

    // Nothing in cache either - now we truly fail
    throw error;
  }
}

// Without bulkhead: shared connection pool
// If recs hangs, payments can't get a connection
const sharedPool = new ConnectionPool({ maxConnections: 50 });

// With bulkhead: isolated pools per dependency
const paymentPool = new ConnectionPool({ maxConnections: 20 });
const recsPool = new ConnectionPool({ maxConnections: 10 });
const notificationPool = new ConnectionPool({ maxConnections: 5 });

class Semaphore {
  private queue: Array<() => void> = [];
  private active = 0;

  constructor(private maxConcurrency: number) {}

  async acquire(): Promise<void> {
    if (this.active < this.maxConcurrency) {
      this.active++;
      return;
    }

    return new Promise<void>((resolve) => {
      this.queue.push(() => {
        this.active++;
        resolve();
      });
    });
  }

  release(): void {
    this.active--;
    const next = this.queue.shift();
    if (next) next();
  }
}

// Isolate each dependency
const paymentBulkhead = new Semaphore(10);
const recsBulkhead = new Semaphore(5);

async function callPaymentService(data: PaymentRequest): Promise<PaymentResult> {
  await paymentBulkhead.acquire();
  try {
    return await fetch('https://payments.internal/charge', {
      method: 'POST',
      body: JSON.stringify(data),
      signal: AbortSignal.timeout(5000),
    }).then((r) => r.json());
  } finally {
    paymentBulkhead.release();
  }
}