Error Handling

import { SmartbillsClient } from '@smartbills/sdk';

const client = new SmartbillsClient({
  accessToken: 'YOUR_API_KEY',
  businessId: 123
});

try {
  const expense = await client.expenses.get(12345);
} catch (error) {
  if (error instanceof SmartbillsValidationError) {
    // Handle validation errors - inspect field-level details
    console.error('Validation failed:', error.message);
    error.details.forEach(detail => {
      console.error(`  Field "${detail.field}": ${detail.message}`);
    });
  } else if (error instanceof SmartbillsAuthenticationError) {
    // Handle authentication errors - refresh token or prompt login
    console.error('Authentication failed:', error.message);
  } else if (error instanceof SmartbillsPermissionError) {
    // Handle permission errors - user lacks access
    console.error('Permission denied:', error.message);
  } else if (error instanceof SmartbillsNotFoundError) {
    // Handle not found errors - resource does not exist
    console.error('Resource not found:', error.message);
  } else if (error instanceof SmartbillsRateLimitError) {
    // Handle rate limit errors - wait and retry
    console.error('Rate limited. Retry after:', error.retryAfter);
  } else if (error instanceof SmartbillsApiError) {
    // Handle any other API error
    console.error('API error:', error.code, error.message);
    console.error('Request ID:', error.requestId);
  }
}

from smartbills import SmartbillsClient
from smartbills.errors import (
    SmartbillsApiError,
    SmartbillsValidationError,
    SmartbillsAuthenticationError,
    SmartbillsPermissionError,
    SmartbillsNotFoundError,
    SmartbillsRateLimitError
)

client = SmartbillsClient(access_token="YOUR_API_KEY", business_id=123)

try:
    expense = client.expenses.get(12345)
except SmartbillsValidationError as e:
    # Handle validation errors - inspect field-level details
    print(f"Validation failed: {e.message}")
    for detail in e.details:
        print(f"  Field '{detail['field']}': {detail['message']}")
except SmartbillsAuthenticationError as e:
    # Handle authentication errors
    print(f"Authentication failed: {e.message}")
except SmartbillsPermissionError as e:
    # Handle permission errors
    print(f"Permission denied: {e.message}")
except SmartbillsNotFoundError as e:
    # Handle not found errors
    print(f"Resource not found: {e.message}")
except SmartbillsRateLimitError as e:
    # Handle rate limit errors - wait and retry
    print(f"Rate limited. Retry after: {e.retry_after}")
except SmartbillsApiError as e:
    # Handle any other API error
    print(f"API error: {e.code} - {e.message}")
    print(f"Request ID: {e.request_id}")

try {
  await client.expenses.create({
    amount: -10,
    currency: 'INVALID'
  });
} catch (error) {
  if (error instanceof SmartbillsValidationError) {
    const fieldErrors = error.details;

    fieldErrors.forEach(({ field, message }) => {
      // Display field-level errors in your UI
      showFieldError(field, message);
    });
  }
}

try:
    client.expenses.create(amount=-10, currency="INVALID")
except SmartbillsValidationError as e:
    for detail in e.details:
        # Display field-level errors in your UI
        show_field_error(detail["field"], detail["message"])

async function retryableRequest(fn, maxRetries = 3) {
  const retryableStatuses = [408, 429, 500, 502, 503, 504];

  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      return await fn();
    } catch (error) {
      const isLastAttempt = attempt === maxRetries - 1;
      const shouldRetry = error.status &&
                         retryableStatuses.includes(error.status);

      if (isLastAttempt || !shouldRetry) {
        throw error;
      }

      // Exponential backoff: 1s, 2s, 4s...
      const delay = Math.min(1000 * Math.pow(2, attempt), 10000);

      console.log(
        `Request failed, retrying in ${delay}ms (attempt ${attempt + 1}/${maxRetries})`
      );

      await new Promise(resolve => setTimeout(resolve, delay));
    }
  }
}

// Usage
const expense = await retryableRequest(() =>
  client.expenses.get(12345)
);

import time

def retryable_request(fn, max_retries=3):
    retryable_statuses = [408, 429, 500, 502, 503, 504]

    for attempt in range(max_retries):
        try:
            return fn()
        except SmartbillsApiError as e:
            is_last_attempt = attempt == max_retries - 1
            should_retry = e.status in retryable_statuses

            if is_last_attempt or not should_retry:
                raise

            # Exponential backoff: 1s, 2s, 4s...
            delay = min(2 ** attempt, 10)

            print(f"Request failed, retrying in {delay}s "
                  f"(attempt {attempt + 1}/{max_retries})")

            time.sleep(delay)

# Usage
expense = retryable_request(lambda: client.expenses.get(12345))