Error Handling

{
  "error": {
    "code": "validation_error",
    "message": "The request body contains invalid fields",
    "details": [
      {
        "field": "email",
        "code": "invalid_format",
        "message": "Email address is not valid"
      },
      {
        "field": "phone",
        "code": "missing_required",
        "message": "Phone number is required"
      }
    ],
    "request_id": "req_abc123xyz",
    "documentation_url": "https://docs.synaptis.io/errors/validation_error"
  }
}

class APIClient {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.maxRetries = 3;
    this.baseDelay = 1000;
  }

  async request(endpoint, options = {}) {
    let lastError;
    
    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
      try {
        const response = await fetch(`https://api.synaptis.io/v1${endpoint}`, {
          ...options,
          headers: {
            'Authorization': `Bearer ${this.apiKey}`,
            'Content-Type': 'application/json',
            ...options.headers
          }
        });

        // Don't retry client errors (except rate limiting)
        if (response.status >= 400 && response.status < 500 && response.status !== 429) {
          const error = await response.json();
          throw new APIError(error, response.status);
        }

        // Retry on rate limit
        if (response.status === 429) {
          const retryAfter = parseInt(response.headers.get('Retry-After') || '60');
          await this.sleep(retryAfter * 1000);
          continue;
        }

        // Retry on server errors
        if (response.status >= 500) {
          throw new Error(`Server error: ${response.status}`);
        }

        return await response.json();
        
      } catch (error) {
        lastError = error;
        
        if (error instanceof APIError) throw error;
        
        if (attempt < this.maxRetries) {
          // Exponential backoff with jitter
          const delay = this.baseDelay * Math.pow(2, attempt);
          const jitter = delay * 0.2 * Math.random();
          await this.sleep(delay + jitter);
        }
      }
    }
    
    throw lastError;
  }

  sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
}