Resilience Patterns

interface RetryOptions {
  maxRetries?: number;
  baseDelayMs?: number;
  maxDelayMs?: number;
}

async function fetchWithRetry(
  url: string,
  options: RequestInit,
  { maxRetries = 3, baseDelayMs = 1000, maxDelayMs = 60_000 }: RetryOptions = {}
): Promise<Response> {
  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    const response = await fetch(url, options);

    // Do not retry permanent failures
    if (response.status >= 400 && response.status < 500 && response.status !== 429) {
      return response;
    }

    // Success -- return immediately
    if (response.ok) {
      return response;
    }

    // All retries exhausted
    if (attempt === maxRetries) {
      return response;
    }

    // Calculate delay
    let delayMs: number;

    if (response.status === 429) {
      // Prefer the server's Retry-After value
      const retryAfter = response.headers.get('Retry-After');
      delayMs = retryAfter ? parseInt(retryAfter, 10) * 1000 : baseDelayMs * 2 ** attempt;
    } else {
      delayMs = baseDelayMs * 2 ** attempt;
    }

    // Cap at max delay, add jitter
    delayMs = Math.min(delayMs, maxDelayMs);
    delayMs += Math.random() * baseDelayMs;

    await new Promise((resolve) => setTimeout(resolve, delayMs));
  }

  // Unreachable, but satisfies TypeScript
  throw new Error('Retry loop exited unexpectedly');
}

import { Signa } from '@signa-so/sdk';

const signa = new Signa({ api_key: 'sig_YOUR_KEY' });

async function fetchBatchWithRetry(ids: string[], maxRetries = 3): Promise<any[]> {
  let pending = ids;
  const results: any[] = [];

  for (let attempt = 0; attempt <= maxRetries && pending.length > 0; attempt++) {
    const response = await signa.trademarks.batch({ ids: pending });

    const retryIds: string[] = [];

    for (const item of response.data) {
      if (item.status === 'success') {
        results.push(item.data);
      } else if (item.error?.type === 'rate_limited' || item.error?.type === 'internal_error') {
        retryIds.push(item.id);
      }
      // Permanent errors are skipped (not retried)
    }

    pending = retryIds;

    if (pending.length > 0 && attempt < maxRetries) {
      const delay = 1000 * 2 ** attempt + Math.random() * 1000;
      await new Promise((resolve) => setTimeout(resolve, delay));
    }
  }

  return results;
}

const controller = new AbortController();
const timeout = setTimeout(() => controller.abort(), 10_000);

try {
  const response = await fetch('https://api.signa.so/v1/trademarks/tm_abc123', {
    headers: { Authorization: 'Bearer sig_YOUR_KEY' },
    signal: controller.signal,
  });
} finally {
  clearTimeout(timeout);
}

import { randomUUID } from 'crypto';

async function renameApiKeySafe(keyId: string, name: string, maxRetries = 2): Promise<any> {
  const idempotencyKey = randomUUID();

  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    try {
      const response = await fetch(`https://api.signa.so/v1/organization/api-keys/${keyId}`, {
        method: 'PATCH',
        headers: {
          'Authorization': `Bearer ${process.env.SIGNA_API_KEY}`,
          'Content-Type': 'application/json',
          'Idempotency-Key': idempotencyKey,
        },
        body: JSON.stringify({ name }),
      });

      if (response.ok) return response.json();
      if (response.status < 500) return response.json(); // permanent error
    } catch {
      if (attempt === maxRetries) throw new Error('Request failed after retries');
    }

    await new Promise(r => setTimeout(r, 1000 * 2 ** attempt));
  }
}