Manejo de Errores

{
  "error": {
    "code": "ERROR_CODE",
    "message": "Descripción legible por humanos",
    "details": [
      {
        "field": "nombre_campo",
        "message": "Mensaje de error específico"
      }
    ]
  }
}

{
  "error": {
    "code": "UNAUTHORIZED",
    "message": "Se requiere autenticación"
  }
}

{
  "error": {
    "code": "INSUFFICIENT_PERMISSIONS",
    "message": "Permiso insuficiente: se requiere components:write"
  }
}

{
  "error": {
    "code": "VALIDATION_ERROR",
    "message": "Los datos de solicitud son inválidos",
    "details": [
      {
        "field": "name",
        "message": "El nombre es requerido"
      },
      {
        "field": "url",
        "message": "Debe ser una URL válida"
      }
    ]
  }
}

{
  "error": {
    "code": "NOT_FOUND",
    "message": "Componente no encontrado",
    "details": {
      "resourceType": "Component",
      "resourceId": "comp-123"
    }
  }
}

{
  "error": {
    "code": "RATE_LIMIT_EXCEEDED",
    "message": "Límite de tasa excedido. Intenta de nuevo en 60 segundos.",
    "details": {
      "retryAfter": 60,
      "limit": 100,
      "remaining": 0
    }
  }
}

{
  "error": {
    "code": "INTERNAL_ERROR",
    "message": "Ocurrió un error inesperado"
  }
}

async function fetchComponents() {
  const response = await fetch('/api/v1/components', {
    headers: { 'Authorization': 'Bearer sk_live_xxx' }
  });
 
  if (!response.ok) {
    const error = await response.json();
 
    switch (response.status) {
      case 401:
        // Refrescar token o re-autenticar
        throw new Error('Autenticación requerida');
      case 403:
        throw new Error(`Acceso denegado: ${error.error.message}`);
      case 404:
        return null; // Recurso no existe
      case 422:
        // Manejar errores de validación
        const fields = error.error.details.map(d => d.field);
        throw new Error(`Campos inválidos: ${fields.join(', ')}`);
      case 429:
        // Implementar backoff exponencial
        const retryAfter = error.error.details.retryAfter;
        await sleep(retryAfter * 1000);
        return fetchComponents(); // Reintentar
      default:
        throw new Error(error.error.message);
    }
  }
 
  return response.json();
}

import requests
import time
 
def fetch_components():
    response = requests.get(
        'https://tu-dominio.com/api/v1/components',
        headers={'Authorization': 'Bearer sk_live_xxx'}
    )
 
    if response.status_code == 401:
        raise Exception('Autenticación requerida')
 
    if response.status_code == 403:
        error = response.json()
        raise Exception(f"Acceso denegado: {error['error']['message']}")
 
    if response.status_code == 404:
        return None
 
    if response.status_code == 422:
        error = response.json()
        fields = [d['field'] for d in error['error']['details']]
        raise Exception(f"Campos inválidos: {', '.join(fields)}")
 
    if response.status_code == 429:
        error = response.json()
        retry_after = error['error']['details']['retryAfter']
        time.sleep(retry_after)
        return fetch_components()  # Reintentar
 
    response.raise_for_status()
    return response.json()

if (!response.ok) {
  // Manejar error
}

async function fetchWithRetry(url: string, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    const response = await fetch(url);
 
    if (response.status === 429) {
      const delay = Math.pow(2, i) * 1000; // Backoff exponencial
      await sleep(delay);
      continue;
    }
 
    return response;
  }
  throw new Error('Max reintentos alcanzado');
}

try {
  const data = await fetchComponents();
} catch (error) {
  console.error('Error de API:', {
    message: error.message,
    code: error.code,
    requestId: response.headers.get('x-request-id')
  });
}

if (error.code === 'VALIDATION_ERROR') {
  // Muestra errores junto a los campos del formulario
  error.details.forEach(detail => {
    showFieldError(detail.field, detail.message);
  });
}