Rate Limits

class TokenBucket {
  constructor(capacityTokens, refillRatePerSecond) {
    this.capacity = capacityTokens;
    this.tokens = capacityTokens;
    this.refillRate = refillRatePerSecond;
    this.lastRefill = Date.now();
  }

  async acquire() {
    while (true) {
      const now = Date.now();
      const elapsed = (now - this.lastRefill) / 1000;
      this.tokens = Math.min(this.capacity, this.tokens + elapsed * this.refillRate);
      this.lastRefill = now;

      if (this.tokens >= 1) {
        this.tokens -= 1;
        return;
      }

      const waitMs = ((1 - this.tokens) / this.refillRate) * 1000;
      await new Promise((resolve) => setTimeout(resolve, waitMs));
    }
  }
}

// One bucket per customer. Conservative defaults — adjust upward only after
// confirming the live rate limit allows it.
const bucket = new TokenBucket(10, 1.0); // 10 burst, 1 req/sec sustained

async function rateLimitedRaiseCall(...args) {
  await bucket.acquire();
  return fetch(...args);
}

async function callRaiseWithRetry(url, options, maxAttempts = 5) {
  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
    const response = await fetch(url, options);

    if (response.status !== 429) {
      return response;
    }

    // Rate limited. Honor Retry-After if present; otherwise exponential backoff.
    const retryAfterHeader = response.headers.get('Retry-After');
    const retryAfterSeconds = retryAfterHeader
      ? parseInt(retryAfterHeader, 10)
      : Math.pow(2, attempt);

    console.warn(`Rate limited (attempt ${attempt}); waiting ${retryAfterSeconds}s`);
    await new Promise((resolve) => setTimeout(resolve, retryAfterSeconds * 1000));
  }

  throw new Error(`Rate limited after ${maxAttempts} retry attempts`);
}