Error Handling

{
  "statusCode": 400,
  "message": "Validation failed",
  "error": "Bad Request",
  "errors": [
    {
      "field": "email",
      "message": "Invalid email format"
    }
  ]
}

{
  "statusCode": 401,
  "message": "Missing authorization header",
  "error": "Unauthorized"
}

-H "Authorization: Bearer YOUR_API_KEY"

{
  "statusCode": 401,
  "message": "Invalid API key",
  "error": "Unauthorized"
}

{
  "statusCode": 401,
  "message": "API key has expired",
  "error": "Unauthorized"
}

{
  "statusCode": 400,
  "message": "Missing required header 'x-meetergo-api-user-id' for API key authentication",
  "error": "Bad Request"
}

-H "x-meetergo-api-user-id: USER_UUID"

{
  "statusCode": 400,
  "message": "The selected time slot is no longer available",
  "error": "Bad Request"
}

async function bookWithRetry(bookingData, maxRetries = 3) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      return await createBooking(bookingData);
    } catch (error) {
      if (error.statusCode === 400 &&
          error.message.includes('no longer available')) {
        // Refresh availability
        const windows = await getBookableWindows(bookingData.hostIds[0]);
        if (windows.length === 0) {
          throw new Error('No available slots');
        }
        // Try next available slot
        bookingData.start = windows[0];
      } else {
        throw error;
      }
    }
  }
  throw new Error('Could not book after retries');
}

{
  "statusCode": 400,
  "message": "Duration must match one of the allowed durations for this meeting type",
  "error": "Bad Request"
}

{
  "statusCode": 400,
  "message": "hostIds or queueId is required",
  "error": "Bad Request"
}

{
  "statusCode": 400,
  "message": "Validation failed",
  "error": "Bad Request",
  "errors": [
    { "field": "email", "message": "Invalid email format" },
    { "field": "timezone", "message": "Invalid timezone identifier" }
  ]
}

function handleValidationErrors(error) {
  if (error.errors && Array.isArray(error.errors)) {
    const fieldErrors = {};
    for (const err of error.errors) {
      fieldErrors[err.field] = err.message;
    }
    return fieldErrors;
  }
  return { _general: error.message };
}

interface ApiError {
  statusCode: number;
  message: string;
  error: string;
  errors?: Array<{ field: string; message: string }>;
}

async function callApi<T>(
  url: string,
  options: RequestInit
): Promise<T> {
  const response = await fetch(url, {
    ...options,
    headers: {
      'Authorization': `Bearer ${API_KEY}`,
      'Content-Type': 'application/json',
      ...options.headers,
    },
  });

  if (!response.ok) {
    const error: ApiError = await response.json();
    throw error;
  }

  return response.json();
}

// Usage with error handling
async function createUser(userData: UserData) {
  try {
    const user = await callApi('/v4/user', {
      method: 'POST',
      body: JSON.stringify(userData),
    });
    return user;
  } catch (error) {
    if (error.statusCode === 401) {
      // Handle authentication error
      console.error('Authentication failed:', error.message);
      throw new Error('Please check your API key');
    }
    if (error.statusCode === 400) {
      // Handle validation error
      console.error('Validation failed:', error.errors);
      throw new Error(`Invalid input: ${error.message}`);
    }
    if (error.statusCode >= 500) {
      // Handle server error
      console.error('Server error:', error.message);
      throw new Error('Service temporarily unavailable');
    }
    throw error;
  }
}

import requests
from typing import Optional, Dict, Any

class MeetergoApiError(Exception):
    def __init__(self, status_code: int, message: str, errors: Optional[list] = None):
        self.status_code = status_code
        self.message = message
        self.errors = errors or []
        super().__init__(message)

def call_api(method: str, endpoint: str, data: Optional[Dict] = None) -> Dict[str, Any]:
    url = f"https://api.meetergo.com{endpoint}"
    headers = {
        'Authorization': f'Bearer {API_KEY}',
        'Content-Type': 'application/json'
    }

    response = requests.request(method, url, headers=headers, json=data)

    if not response.ok:
        error_data = response.json()
        raise MeetergoApiError(
            status_code=error_data.get('statusCode', response.status_code),
            message=error_data.get('message', 'Unknown error'),
            errors=error_data.get('errors')
        )

    return response.json()

# Usage with error handling
def create_booking(booking_data: dict) -> dict:
    try:
        return call_api('POST', '/v4/booking', booking_data)
    except MeetergoApiError as e:
        if e.status_code == 400 and 'no longer available' in e.message:
            # Handle slot taken
            raise ValueError('Time slot is no longer available')
        if e.status_code == 401:
            # Handle auth error
            raise PermissionError('Invalid API key')
        raise

async function withRetry(fn, maxRetries = 3) {
  let lastError;

  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      return await fn();
    } catch (error) {
      lastError = error;

      // Only retry on transient errors
      if (error.statusCode === 429 ||
          (error.statusCode >= 500 && error.statusCode < 600)) {

        const delay = Math.pow(2, attempt) * 1000; // 1s, 2s, 4s
        console.log(`Retry ${attempt + 1}/${maxRetries} after ${delay}ms`);
        await sleep(delay);
      } else {
        // Don't retry client errors (4xx except 429)
        throw error;
      }
    }
  }

  throw lastError;
}

const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));

// Usage
const booking = await withRetry(() => createBooking(data));