Errors

async function createCharge(body, idempotencyKey) {
  const res = await fetch('https://api.fingopay.io/v1/mpesa/charge', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.FINGO_API_KEY}`,
      'Content-Type': 'application/json',
      'Idempotency-Key': idempotencyKey,
    },
    body: JSON.stringify(body),
  });

  const data = await res.json();

  if (!res.ok) {
    const { type, code, message, param } = data.error;

    switch (type) {
      case 'authentication_error':
        // Check credentials or org verification status
        throw new Error(`Auth failed: ${message}`);

      case 'invalid_request_error':
        if (code === 'missing_parameter' || code === 'invalid_parameter') {
          console.error(`Fix field '${param}': ${message}`);
        }
        if (code === 'duplicate') {
          console.warn(`Duplicate transaction: ${message}`);
        }
        throw new Error(`Bad request [${code}]: ${message}`);

      case 'rate_limit_error':
        const retryAfter = res.headers.get('Retry-After') || '5';
        await new Promise((r) => setTimeout(r, parseInt(retryAfter, 10) * 1000));
        return createCharge(body, idempotencyKey);

      case 'conflict_error':
        // Generate a new idempotency key if the body changed
        throw new Error(`Conflict: ${message}`);

      case 'not_found_error':
        throw new Error(`Not found: ${message}`);

      case 'api_error':
        // Retry with backoff; contact support if persistent
        throw new Error(`Server error: ${message}`);

      default:
        throw new Error(`Unexpected error: ${message}`);
    }
  }

  return data;
}

import os, requests, time

def create_charge(body: dict, idempotency_key: str, attempt: int = 0):
    res = requests.post(
        "https://api.fingopay.io/v1/mpesa/charge",
        json=body,
        headers={
            "Authorization": f"Bearer {os.environ['FINGO_API_KEY']}",
            "Content-Type": "application/json",
            "Idempotency-Key": idempotency_key,
        },
    )

    if res.ok:
        return res.json()

    err = res.json()["error"]
    error_type = err["type"]
    code = err["code"]
    message = err["message"]
    param = err.get("param")

    if error_type == "authentication_error":
        raise Exception(f"Auth failed: {message}")

    elif error_type == "invalid_request_error":
        if code in ("missing_parameter", "invalid_parameter"):
            print(f"Fix field '{param}': {message}")
        if code == "duplicate":
            print(f"Duplicate transaction: {message}")
        raise Exception(f"Bad request [{code}]: {message}")

    elif error_type == "rate_limit_error":
        retry_after = int(res.headers.get("Retry-After", "5"))
        time.sleep(retry_after)
        return create_charge(body, idempotency_key, attempt + 1)

    elif error_type == "conflict_error":
        raise Exception(f"Conflict: {message}")

    elif error_type == "not_found_error":
        raise Exception(f"Not found: {message}")

    elif error_type == "api_error":
        if attempt < 3:
            time.sleep(2 ** attempt)
            return create_charge(body, idempotency_key, attempt + 1)
        raise Exception(f"Server error: {message}")

    else:
        raise Exception(f"Unexpected error: {message}")