Error Codes

{
  "error": {
    "code": "validation_error",
    "message": "Validation failed for the request",
    "details": {
      "url": ["The url field must be a valid HTTPS URL"]
    }
  }
}

async function createWebhookJob(data: any) {
  try {
    const response = await fetch('https://api.hookmesh.com/v1/webhook-jobs', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${process.env.HOOKMESH_API_KEY}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(data)
    });

    // Success
    if (response.ok) {
      return await response.json();
    }

    // Parse error response
    const error = await response.json();

    // Handle specific errors
    switch (response.status) {
      case 401:
        throw new Error('Invalid API key - check your credentials');

      case 403:
        throw new Error(`Missing permission: ${error.error.message}`);

      case 404:
        throw new Error(`Resource not found: ${error.error.message}`);

      case 422:
        // Validation errors - extract field-specific messages
        const validationErrors = error.error.details;
        const fieldErrors = Object.entries(validationErrors)
          .map(([field, messages]) => `${field}: ${messages.join(', ')}`)
          .join('; ');
        throw new Error(`Validation failed: ${fieldErrors}`);

      case 429:
        // Rate limit - check Retry-After header
        const retryAfter = response.headers.get('Retry-After');
        throw new Error(`Rate limit exceeded. Retry after ${retryAfter} seconds`);

      case 500:
      case 503:
        // Server errors - retry with exponential backoff
        throw new Error(`Server error (${response.status}). Please retry.`);

      default:
        throw new Error(`API error (${response.status}): ${error.error.message}`);
    }
  } catch (err) {
    console.error('Failed to create webhook job:', err);
    throw err;
  }
}

import requests
import time
from typing import Dict, Any

def create_webhook_job(data: Dict[str, Any], max_retries: int = 3) -> Dict[str, Any]:
    """Create a webhook job with automatic retry on server errors."""

    for attempt in range(max_retries):
        try:
            response = requests.post(
                'https://api.hookmesh.com/v1/webhook-jobs',
                headers={
                    'Authorization': f'Bearer {os.environ["HOOKMESH_API_KEY"]}',
                    'Content-Type': 'application/json'
                },
                json=data
            )

            # Success
            if response.ok:
                return response.json()

            # Parse error
            error = response.json()

            # 401/403/404/422 - Don't retry (permanent errors)
            if response.status_code in [401, 403, 404, 422]:
                if response.status_code == 422:
                    # Format validation errors
                    details = error['error'].get('details', {})
                    field_errors = '; '.join(
                        f'{field}: {", ".join(msgs)}'
                        for field, msgs in details.items()
                    )
                    raise ValueError(f'Validation failed: {field_errors}')
                raise ValueError(f'{response.status_code}: {error["error"]["message"]}')

            # 429 - Rate limit
            if response.status_code == 429:
                retry_after = int(response.headers.get('Retry-After', 60))
                if attempt < max_retries - 1:
                    print(f'Rate limited. Waiting {retry_after} seconds...')
                    time.sleep(retry_after)
                    continue
                raise ValueError(f'Rate limit exceeded: {error["error"]["message"]}')

            # 500/503 - Server error, retry with backoff
            if response.status_code in [500, 503]:
                if attempt < max_retries - 1:
                    backoff = (2 ** attempt) * 1  # 1s, 2s, 4s
                    print(f'Server error. Retrying in {backoff}s...')
                    time.sleep(backoff)
                    continue
                raise RuntimeError(f'Server error after {max_retries} attempts')

            # Other errors
            raise RuntimeError(f'{response.status_code}: {error["error"]["message"]}')

        except requests.RequestException as e:
            # Network errors - retry
            if attempt < max_retries - 1:
                backoff = (2 ** attempt) * 1
                print(f'Network error: {e}. Retrying in {backoff}s...')
                time.sleep(backoff)
                continue
            raise RuntimeError(f'Network error after {max_retries} attempts: {e}')

    raise RuntimeError('Max retries exceeded')