Error Handling

class NovaClient {
  async request(method, path, body) {
    const maxRetries = 3;
    let lastError;
    
    for (let attempt = 0; attempt < maxRetries; attempt++) {
      try {
        const response = await fetch(`${this.baseUrl}${path}`, {
          method,
          headers: this.headers,
          body: body ? JSON.stringify(body) : undefined,
        });
        
        if (response.ok) {
          return response.json();
        }
        
        const error = await response.json();
        lastError = error.error;
        
        // Handle rate limiting
        if (response.status === 429) {
          const retryAfter = parseInt(response.headers.get('Retry-After') || '60');
          console.log(`Rate limited. Waiting ${retryAfter}s...`);
          await sleep(retryAfter * 1000);
          continue;
        }
        
        // Retry on server errors
        if (response.status >= 500 && attempt < maxRetries - 1) {
          const delay = Math.pow(2, attempt) * 1000;
          console.log(`Server error. Retrying in ${delay}ms...`);
          await sleep(delay);
          continue;
        }
        
        // Non-retryable error
        throw new NovaError(lastError);
        
      } catch (networkError) {
        lastError = networkError;
        if (attempt < maxRetries - 1) {
          await sleep(Math.pow(2, attempt) * 1000);
          continue;
        }
      }
    }
    
    throw new NovaError(lastError);
  }
}

class NovaError extends Error {
  constructor(error) {
    super(error.message);
    this.code = error.code;
    this.status = error.status;
    this.details = error.details;
    this.requestId = error.requestId;
  }
  
  get isRetryable() {
    return ['RATE_LIMITED', 'INTERNAL_ERROR', 'SERVICE_UNAVAILABLE'].includes(this.code);
  }
}