Error Handling

{
  "error": "error_type",
  "description": "Human-readable error message explaining what went wrong"
}

{
  "error": "invalid_input",
  "description": "Validation failed for project creation",
  "details": {
    "field": "slug",
    "message": "Slug is already taken"
  }
}

async function makeApiRequest(url, options = {}) {
  try {
    const response = await fetch(url, {
      ...options,
      headers: {
        'User-Agent': 'my-app/1.0.0',
        ...options.headers
      }
    });
    
    // Handle rate limiting
    if (response.status === 429) {
      const retryAfter = response.headers.get('Retry-After');
      throw new RateLimitError(
        `Rate limited. Retry after ${retryAfter} seconds`,
        parseInt(retryAfter)
      );
    }
    
    // Handle client errors
    if (response.status >= 400 && response.status < 500) {
      const error = await response.json();
      throw new ClientError(error.description, response.status, error.error);
    }
    
    // Handle server errors
    if (response.status >= 500) {
      const error = await response.json();
      throw new ServerError(error.description, response.status, error.error);
    }
    
    // Success
    return response.json();
    
  } catch (error) {
    if (error instanceof RateLimitError) {
      // Wait and retry
      await sleep(error.retryAfter * 1000);
      return makeApiRequest(url, options);
    }
    
    if (error instanceof ClientError) {
      // Log and handle client error
      console.error('Client error:', error.message);
      throw error;
    }
    
    if (error instanceof ServerError) {
      // Retry with exponential backoff
      console.warn('Server error, retrying...');
      await sleep(1000);
      return makeApiRequest(url, options);
    }
    
    // Network or other error
    throw error;
  }
}

class RateLimitError extends Error {
  constructor(message, retryAfter) {
    super(message);
    this.name = 'RateLimitError';
    this.retryAfter = retryAfter;
  }
}

class ClientError extends Error {
  constructor(message, status, type) {
    super(message);
    this.name = 'ClientError';
    this.status = status;
    this.type = type;
  }
}

class ServerError extends Error {
  constructor(message, status, type) {
    super(message);
    this.name = 'ServerError';
    this.status = status;
    this.type = type;
  }
}

import time
import requests
from requests.exceptions import RequestException

def make_request_with_retry(url, max_retries=5):
    """Make API request with exponential backoff retry logic."""
    
    for attempt in range(max_retries):
        try:
            response = requests.get(
                url,
                headers={'User-Agent': 'my-app/1.0.0'}
            )
            
            # Handle rate limiting
            if response.status_code == 429:
                retry_after = int(response.headers.get('Retry-After', 60))
                print(f"Rate limited. Waiting {retry_after} seconds...")
                time.sleep(retry_after)
                continue
            
            # Handle server errors with exponential backoff
            if response.status_code >= 500:
                wait_time = min(2 ** attempt, 60)  # Max 60 seconds
                print(f"Server error. Retrying in {wait_time} seconds...")
                time.sleep(wait_time)
                continue
            
            # Raise for client errors (don't retry)
            if 400 <= response.status_code < 500:
                error_data = response.json()
                raise Exception(
                    f"{error_data.get('error')}: {error_data.get('description')}"
                )
            
            # Success
            response.raise_for_status()
            return response.json()
            
        except RequestException as e:
            if attempt == max_retries - 1:
                raise
            
            wait_time = min(2 ** attempt, 60)
            print(f"Request failed: {e}. Retrying in {wait_time} seconds...")
            time.sleep(wait_time)
    
    raise Exception(f"Max retries ({max_retries}) exceeded")

# Usage
try:
    data = make_request_with_retry('https://api.modrinth.com/v2/search')
    print(data)
except Exception as e:
    print(f"Request failed: {e}")

class ApiClient {
  constructor(baseUrl, logger) {
    this.baseUrl = baseUrl;
    this.logger = logger;
  }
  
  async request(endpoint, options = {}) {
    const url = `${this.baseUrl}${endpoint}`;
    
    this.logger.info('API Request', {
      method: options.method || 'GET',
      url,
      timestamp: new Date().toISOString()
    });
    
    try {
      const response = await fetch(url, {
        ...options,
        headers: {
          'User-Agent': 'my-app/1.0.0',
          ...options.headers
        }
      });
      
      // Log rate limit info
      const remaining = response.headers.get('X-Ratelimit-Remaining');
      if (remaining !== null) {
        this.logger.debug('Rate Limit', {
          remaining,
          limit: response.headers.get('X-Ratelimit-Limit'),
          reset: response.headers.get('X-Ratelimit-Reset')
        });
      }
      
      if (!response.ok) {
        const error = await response.json();
        
        this.logger.error('API Error', {
          status: response.status,
          error: error.error,
          description: error.description,
          url,
          timestamp: new Date().toISOString()
        });
        
        throw new Error(error.description);
      }
      
      this.logger.info('API Success', {
        status: response.status,
        url
      });
      
      return response.json();
      
    } catch (error) {
      this.logger.error('Request Failed', {
        error: error.message,
        url,
        timestamp: new Date().toISOString()
      });
      throw error;
    }
  }
}

function getUserFriendlyError(error) {
  const errorMessages = {
    'not_found': 'The requested item could not be found.',
    'unauthorized': 'Please sign in to continue.',
    'ratelimit_error': 'Too many requests. Please wait a moment and try again.',
    'conflict': 'This name is already taken. Please choose another.',
    'invalid_input': 'Please check your input and try again.',
    'internal_error': 'Something went wrong on our end. Please try again later.'
  };
  
  return errorMessages[error.type] || error.description;
}

// Usage in UI
try {
  await createProject(data);
} catch (error) {
  const message = getUserFriendlyError(error);
  showNotification(message, 'error');
}

curl -i "https://api.modrinth.com/v2/project/invalid-id"

HTTP/2 404
content-type: application/json
x-ratelimit-limit: 300
x-ratelimit-remaining: 299
x-ratelimit-reset: 60

{
  "error": "not_found",
  "description": "Resource not found"
}

# Test authentication
curl -H "Authorization: YOUR_TOKEN" \
  "https://api.modrinth.com/v2/user"

# Test with verbose output
curl -v "https://api.modrinth.com/v2/project/fabric-api"

# Test POST request
curl -X POST "https://api.modrinth.com/v2/project" \
  -H "Authorization: YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"name": "My Project", "slug": "my-project"}'