Reintentos, Backoff e Idempotencia

// src/api/retry.ts
export type RetryOptions = {
  maxAttempts?: number;
  baseDelayMs?: number;
  maxDelayMs?: number;
  shouldRetry?: (error: unknown, attempt: number) => boolean;
};
 
function jitter(ms: number): number {
  return ms * (0.5 + Math.random() * 0.5);
}
 
export async function fetchWithRetry(
  input: RequestInfo | URL,
  init?: RequestInit,
  opts: RetryOptions = {}
): Promise<Response> {
  const {
    maxAttempts = 4,
    baseDelayMs = 500,
    maxDelayMs = 8_000,
    shouldRetry = defaultShouldRetry,
  } = opts;
 
  let lastError: unknown;
 
  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
    try {
      const res = await fetch(input, init);
      if (res.status === 429) {
        const retryAfter = res.headers.get("Retry-After");
        const waitSec = retryAfter ? Number(retryAfter) : 2 ** attempt;
        await sleep(jitter(waitSec * 1000));
        continue;
      }
      if (res.ok || !shouldRetry(res, attempt)) return res;
      lastError = new Error(`HTTP ${res.status}`);
    } catch (error) {
      lastError = error;
      if (!shouldRetry(error, attempt)) throw error;
    }
 
    if (attempt < maxAttempts) {
      const delay = Math.min(baseDelayMs * 2 ** (attempt - 1), maxDelayMs);
      await sleep(jitter(delay));
    }
  }
 
  throw lastError;
}
 
function defaultShouldRetry(error: unknown, attempt: number): boolean {
  if (attempt >= 4) return false;
  if (error instanceof Response) {
    const status = error.status;
    return status >= 500 || status === 408 || status === 429;
  }
  if (error instanceof Error) {
    if (error.name === "AbortError") return false;
    return error instanceof TypeError; // fluctuación de red
  }
  return false;
}
 
function sleep(ms: number) {
  return new Promise((r) => setTimeout(r, ms));
}

import NetInfo from "@react-native-community/netinfo";
import { useMutation, useQueryClient } from "@tanstack/react-query";
import { useCallback } from "react";
import { fetchWithRetry } from "../api/retry";
 
const API = process.env.EXPO_PUBLIC_API_URL ?? "https://api.example.com";
 
function idempotencyKey(): string {
  return `idem-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
}
 
async function createOrder(items: { sku: string; qty: number }[], key: string) {
  const res = await fetchWithRetry(
    `${API}/orders`,
    {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "Idempotency-Key": key,
      },
      body: JSON.stringify({ items }),
    },
    {
      maxAttempts: 3,
      shouldRetry: (err, attempt) => {
        if (err instanceof Response) return err.status >= 500 && attempt < 3;
        return err instanceof TypeError && attempt < 3;
      },
    }
  );
 
  if (!res.ok) throw new Error(`HTTP ${res.status}`);
  return res.json();
}
 
export function useCreateOrder() {
  const queryClient = useQueryClient();
 
  const waitForOnline = useCallback(async () => {
    const state = await NetInfo.fetch();
    if (state.isConnected && state.isInternetReachable !== false) return;
    await new Promise<void>((resolve) => {
      const unsub = NetInfo.addEventListener((s) => {
        if (s.isConnected && s.isInternetReachable !== false) {
          unsub();
          resolve();
        }
      });
    });
  }, []);
 
  return useMutation({
    mutationFn: async (items: { sku: string; qty: number }[]) => {
      await waitForOnline();
      const key = idempotencyKey();
      return createOrder(items, key);
    },
    retry: false, // reintentos manejados en fetchWithRetry con clave de idempotencia
    onSuccess: () => queryClient.invalidateQueries({ queryKey: ["orders"] }),
  });
}

type IdempotentRequest = {
  idempotencyKey: string; // UUID generado por el cliente
  operation: "createOrder" | "capturePayment";
  payload: unknown;
};

export const queryClient = new QueryClient({
  defaultOptions: {
    queries: {
      retry: (failureCount, error) => {
        if (failureCount >= 3) return false;
        if (error instanceof Error && error.message.startsWith("HTTP 4")) return false;
        return true;
      },
      retryDelay: (attempt) => Math.min(1000 * 2 ** attempt, 30_000),
    },
    mutations: {
      retry: 0,
    },
  },
});

for (const item of queue) {
  try {
    await fetchWithRetry(url, { headers: { "Idempotency-Key": item.key }, ... });
    dequeue(item);
  } catch {
    incrementAttempts(item);
    if (item.attempts > 5) surfaceToUser(item);
  }
}