Error Handling

{
  "success": false,
  "error": {
    "code": "VALIDATION_ERROR",
    "message": "Invalid email format",
    "details": {
      "field": "email",
      "value": "not-an-email",
      "expected": "valid email address"
    }
  }
}

{
  "success": false,
  "error": {
    "code": "TOKEN_EXPIRED",
    "message": "Your session has expired. Please log in again."
  }
}

{
  "success": false,
  "error": {
    "code": "VALIDATION_ERROR",
    "message": "Validation failed",
    "details": {
      "errors": [
        { "field": "email", "message": "Invalid email format" },
        { "field": "password", "message": "Must be at least 8 characters" }
      ]
    }
  }
}

X-RateLimit-Limit: 100
X-RateLimit-Remaining: 0
X-RateLimit-Reset: 1705320600
Retry-After: 60

{
  "success": false,
  "error": {
    "code": "RATE_LIMITED",
    "message": "Rate limit exceeded. Please wait before retrying.",
    "details": {
      "limit": 100,
      "remaining": 0,
      "reset_at": "2024-01-15T10:30:00Z",
      "retry_after": 60
    }
  }
}

async function makeRequest(url: string) {
  try {
    const response = await fetch(url, {
      headers: { Authorization: `Bearer ${token}` },
    });
 
    const data = await response.json();
 
    if (!data.success) {
      // Handle API error
      switch (data.error.code) {
        case "UNAUTHORIZED":
        case "TOKEN_EXPIRED":
          // Redirect to login
          redirectToLogin();
          break;
        case "RATE_LIMITED":
          // Wait and retry
          const retryAfter = data.error.details?.retry_after || 60;
          await sleep(retryAfter * 1000);
          return makeRequest(url);
        case "VALIDATION_ERROR":
          // Show validation errors to user
          showValidationErrors(data.error.details.errors);
          break;
        default:
          // Show generic error
          showError(data.error.message);
      }
      return null;
    }
 
    return data.data;
  } catch (error) {
    // Network error
    showError("Network error. Please check your connection.");
    return null;
  }
}

import requests
 
def make_request(url):
    try:
        response = requests.get(url, headers={"Authorization": f"Bearer {token}"})
        data = response.json()
        
        if not data.get("success"):
            error = data.get("error", {})
            code = error.get("code")
            
            if code in ["UNAUTHORIZED", "TOKEN_EXPIRED"]:
                refresh_token()
                return make_request(url)  # Retry
            elif code == "RATE_LIMITED":
                retry_after = error.get("details", {}).get("retry_after", 60)
                time.sleep(retry_after)
                return make_request(url)  # Retry
            else:
                raise APIError(error.get("message"))
        
        return data.get("data")
    except requests.exceptions.RequestException as e:
        raise NetworkError(str(e))

const data = await response.json();
if (!data.success) {
  // Handle error
}

async function requestWithRetry(url: string, maxRetries = 3) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    const response = await fetch(url);
    const data = await response.json();
    
    if (data.error?.code === "RATE_LIMITED") {
      const delay = Math.pow(2, attempt) * 1000; // 1s, 2s, 4s
      await sleep(delay);
      continue;
    }
    
    return data;
  }
  throw new Error("Max retries exceeded");
}

if (!data.success) {
  console.error("API Error:", {
    code: data.error.code,
    message: data.error.message,
    details: data.error.details,
    endpoint: url,
    timestamp: new Date().toISOString(),
  });
}

const userMessages = {
  UNAUTHORIZED: "Please log in to continue",
  RATE_LIMITED: "Too many requests. Please wait a moment.",
  NOT_FOUND: "The requested item was not found",
  INTERNAL_ERROR: "Something went wrong. Please try again later.",
};
 
const message = userMessages[error.code] || "An error occurred";
showToast(message);