Error Handling

async function fetchData(endpoint) {
  try {
    const response = await fetch(`https://api.portaldata.id/api/v1${endpoint}`, {
      headers: { 'X-API-Key': process.env.PORTALDATA_API_KEY }
    });

    // Parse response body
    const data = await response.json();

    // Check if response is OK
    if (!response.ok) {
      // Handle specific error codes
      switch (data.error) {
        case 'unauthorized':
          throw new Error('API key tidak valid. Periksa konfigurasi.');

        case 'rate_limit_exceeded':
          const retryAfter = data.retry_after || 30;
          console.log(`Rate limited. Retry dalam ${retryAfter} detik.`);
          await sleep(retryAfter * 1000);
          return fetchData(endpoint); // Retry

        case 'monthly_limit_exceeded':
          throw new Error('Kuota bulanan habis. Silakan upgrade.');

        case 'not_found':
          return null; // Resource tidak ada, return null

        case 'validation_error':
          console.error('Validation errors:', data.details?.errors);
          throw new Error(`Validasi gagal: ${data.message}`);

        case 'internal_error':
          throw new Error('Server error. Coba lagi nanti.');

        default:
          throw new Error(data.message || 'Unknown error');
      }
    }

    return data;

  } catch (error) {
    // Network error atau unexpected error
    console.error('Request failed:', error);
    throw error;
  }
}

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

import time
import requests

class PortalDataError(Exception):
    """Base exception for PortalData API errors"""
    def __init__(self, error_code, message, details=None):
        self.error_code = error_code
        self.message = message
        self.details = details
        super().__init__(message)

class UnauthorizedError(PortalDataError):
    pass

class RateLimitError(PortalDataError):
    def __init__(self, message, retry_after=30):
        super().__init__('rate_limit_exceeded', message)
        self.retry_after = retry_after

class NotFoundError(PortalDataError):
    pass

def fetch_data(endpoint, max_retries=3):
    """Fetch data from PortalData API with error handling"""
    url = f'https://api.portaldata.id/api/v1{endpoint}'
    headers = {'X-API-Key': os.environ['PORTALDATA_API_KEY']}

    for attempt in range(max_retries):
        response = requests.get(url, headers=headers)
        data = response.json()

        if response.ok:
            return data

        # Handle errors based on error code
        error_code = data.get('error')
        message = data.get('message', 'Unknown error')

        if error_code == 'unauthorized':
            raise UnauthorizedError(error_code, message)

        elif error_code == 'rate_limit_exceeded':
            retry_after = data.get('retry_after', 30)
            if attempt < max_retries - 1:
                print(f'Rate limited. Waiting {retry_after}s...')
                time.sleep(retry_after)
                continue
            raise RateLimitError(message, retry_after)

        elif error_code == 'monthly_limit_exceeded':
            raise PortalDataError(error_code, message)

        elif error_code == 'not_found':
            raise NotFoundError(error_code, message)

        elif error_code == 'validation_error':
            raise PortalDataError(error_code, message, data.get('details'))

        elif error_code == 'internal_error':
            if attempt < max_retries - 1:
                time.sleep(2 ** attempt)  # Exponential backoff
                continue
            raise PortalDataError(error_code, message)

        else:
            raise PortalDataError(error_code, message)

    raise Exception('Max retries exceeded')

# Penggunaan
try:
    regions = fetch_data('/regions?level=province')
    print(regions)
except NotFoundError:
    print('Data tidak ditemukan')
except RateLimitError as e:
    print(f'Rate limited. Retry dalam {e.retry_after} detik')
except PortalDataError as e:
    print(f'API Error: {e.error_code} - {e.message}')