Error Handling

async function generatePdf(htmlFile) {
  const formData = new FormData();
  formData.append('files', htmlFile);
  formData.append('options', JSON.stringify({ fileName: 'document' }));

  try {
    const response = await fetch('https://api.syntaxdoc.com/pdf/generate', {
      method: 'POST',
      headers: { 'X-API-Key': 'YOUR_API_KEY' },
      body: formData
    });

    // Check if response is an error
    if (!response.ok) {
      const error = await response.json();
      
      switch (response.status) {
        case 401:
          throw new Error('Invalid API key. Check your credentials.');
        
        case 429:
          if (error.code === 'HOSTED_PDF_LIMIT_REACHED') {
            throw new Error('Hosted PDF limit reached. Delete some PDFs first.');
          }
          throw new Error('Conversion quota exceeded. Upgrade your plan.');
        
        case 400:
          throw new Error(`Bad request: ${error.message}`);
        
        default:
          throw new Error(error.message || 'Unknown error occurred');
      }
    }

    // Check content type for success response
    const contentType = response.headers.get('content-type');
    
    if (contentType?.includes('application/json')) {
      // Hosted PDF response
      return await response.json();
    } else {
      // Direct PDF binary
      return await response.blob();
    }
  } catch (error) {
    console.error('PDF generation failed:', error.message);
    throw error;
  }
}

import requests
import json

class SyntaxDocError(Exception):
    def __init__(self, code, message, status_code):
        self.code = code
        self.message = message
        self.status_code = status_code
        super().__init__(f"{code}: {message}")

def generate_pdf(html_file_path: str, api_key: str):
    url = 'https://api.syntaxdoc.com/pdf/generate'
    
    with open(html_file_path, 'rb') as f:
        files = [('files', ('index.html', f, 'text/html'))]
        data = {'options': json.dumps({'fileName': 'document'})}
        headers = {'X-API-Key': api_key}
        
        response = requests.post(url, headers=headers, files=files, data=data)
    
    if not response.ok:
        try:
            error = response.json()
            code = error.get('code', 'UNKNOWN_ERROR')
            message = error.get('message', 'Unknown error')
        except:
            code = 'UNKNOWN_ERROR'
            message = response.text
        
        raise SyntaxDocError(code, message, response.status_code)
    
    # Check if JSON response (hosted PDF) or binary
    if 'application/json' in response.headers.get('content-type', ''):
        return response.json()
    else:
        return response.content

# Usage
try:
    result = generate_pdf('document.html', 'YOUR_API_KEY')
    if isinstance(result, dict):
        print(f"Hosted PDF URL: {result['url']}")
    else:
        with open('output.pdf', 'wb') as f:
            f.write(result)
except SyntaxDocError as e:
    if e.status_code == 429:
        print(f"Quota exceeded: {e.message}")
    elif e.status_code == 401:
        print("Invalid API key")
    else:
        print(f"Error: {e.message}")

async function generatePdfWithRetry(htmlFile, maxRetries = 3) {
  const formData = new FormData();
  formData.append('files', htmlFile);

  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      const response = await fetch('https://api.syntaxdoc.com/pdf/generate', {
        method: 'POST',
        headers: { 'X-API-Key': 'YOUR_API_KEY' },
        body: formData
      });

      if (response.ok) {
        return await response.blob();
      }

      // Only retry on server errors
      if (response.status >= 500) {
        const delay = Math.pow(2, attempt) * 1000; // 1s, 2s, 4s
        console.log(`Retrying in ${delay}ms...`);
        await new Promise(resolve => setTimeout(resolve, delay));
        continue;
      }

      // Non-retryable error
      const error = await response.json();
      throw new Error(error.message);
    } catch (error) {
      if (attempt === maxRetries - 1) throw error;
    }
  }

  throw new Error('Max retries exceeded');
}

import time
import requests

def generate_pdf_with_retry(html_file_path: str, api_key: str, max_retries: int = 3):
    url = 'https://api.syntaxdoc.com/pdf/generate'
    
    for attempt in range(max_retries):
        with open(html_file_path, 'rb') as f:
            files = [('files', ('index.html', f, 'text/html'))]
            headers = {'X-API-Key': api_key}
            
            response = requests.post(url, headers=headers, files=files)
        
        if response.ok:
            return response.content
        
        # Only retry on server errors
        if response.status_code >= 500:
            delay = (2 ** attempt)  # 1s, 2s, 4s
            print(f"Retrying in {delay}s...")
            time.sleep(delay)
            continue
        
        # Non-retryable error
        error = response.json()
        raise Exception(error.get('message', 'Unknown error'))
    
    raise Exception('Max retries exceeded')