API errors

async function callXPay<T>(path: string, body: unknown): Promise<T> {
  const res = await fetch(`https://api.xpay.app${path}`, {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.XPAY_SECRET_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify(body),
  });

  if (res.ok) return res.json() as Promise<T>;

  // Read the canonical envelope. Every XPay error response has `error.type`.
  const payload = await res.json().catch(() => null);
  const xpayError = payload?.error;
  const requestId = payload?.request_id;

  if (!xpayError?.type) {
    // Transport-level failure: not XPay-shaped. Treat as a client-side bug.
    throw new Error(`Non-XPay response: ${res.status}`);
  }

  // Always log first, branch second.
  log.error("xpay api error", {
    requestId,
    type: xpayError.type,
    code: xpayError.code,
    param: xpayError.param,
    message: xpayError.message,
    docUrl: xpayError.doc_url,
  });

  switch (xpayError.type) {
    case "invalid_request_error":
      // Your request is wrong. Don't retry. Bubble up to whoever sent it.
      throw new BadRequest(xpayError);

    case "authentication_error":
      // Your secret key is wrong. Page yourself; don't retry.
      throw new ConfigError(xpayError);

    case "api_error":
      // XPay is having a moment. Retry with backoff.
      throw new RetryableError(xpayError);

    default:
      // Unknown type. Treat as retryable to be safe.
      throw new RetryableError(xpayError);
  }
}

import os, requests

def call_xpay(path: str, body: dict) -> dict:
    res = requests.post(
        f"https://api.xpay.app{path}",
        headers={
            "Authorization": f"Bearer {os.environ['XPAY_SECRET_KEY']}",
            "Content-Type": "application/json",
        },
        json=body,
        timeout=30,
    )

    if res.ok:
        return res.json()

    payload = res.json() if res.content else {}
    xpay_error = payload.get("error") or {}
    request_id = payload.get("request_id")

    if not xpay_error.get("type"):
        # Transport-level failure: not XPay-shaped.
        raise RuntimeError(f"Non-XPay response: {res.status_code}")

    log.error(
        "xpay api error",
        extra={
            "request_id": request_id,
            "type": xpay_error.get("type"),
            "code": xpay_error.get("code"),
            "param": xpay_error.get("param"),
            "message": xpay_error.get("message"),
            "doc_url": xpay_error.get("doc_url"),
        },
    )

    error_type = xpay_error["type"]
    if error_type == "invalid_request_error":
        raise BadRequest(xpay_error)
    if error_type == "authentication_error":
        raise ConfigError(xpay_error)
    if error_type == "api_error":
        raise RetryableError(xpay_error)
    raise RetryableError(xpay_error)  # unknown type, treat as retryable