Error Handling

{
  "errors": [
    {
      "message": "Human-readable error description.",
      "extensions": {
        "code": "ERROR_CODE",
        "correlationId": "20260131T235915-a1b2c3d4",
        "retryable": false,
        "category": "VALIDATION"
      }
    }
  ]
}

import time
import random
import requests
from requests.auth import HTTPBasicAuth

def execute_query_with_retry(url, query, max_retries=3):
    auth = HTTPBasicAuth("YOUR_SHOP_ID", "YOUR_API_TOKEN")
    headers = {"Content-Type": "application/json"}

    for attempt in range(max_retries + 1):
        response = requests.post(
            url,
            json={"query": query},
            auth=auth,
            headers=headers,
        )

        # Handle HTTP 401 (UNAUTHORIZED)
        if response.status_code == 401:
            raise Exception("Authentication failed. Check your Shop ID and API token.")

        data = response.json()

        # Check for GraphQL errors
        if "errors" in data:
            error = data["errors"][0]
            extensions = error.get("extensions", {})
            code = extensions.get("code", "UNKNOWN")
            retryable = extensions.get("retryable", False)

            if retryable and attempt < max_retries:
                base_delay = 2 ** attempt  # 1, 2, 4 seconds
                jitter = random.uniform(0, base_delay * 0.5)
                delay = base_delay + jitter
                print(f"Retryable error ({code}). Retrying in {delay:.1f}s "
                      f"(attempt {attempt + 1}/{max_retries})...")
                time.sleep(delay)
                continue
            else:
                correlation_id = extensions.get("correlationId", "N/A")
                raise Exception(
                    f"API error: {code} - {error['message']} "
                    f"(correlationId: {correlation_id})"
                )

        return data

# Usage
result = execute_query_with_retry(
    "https://api.payretailers.com/data-api/graphql",
    '{ payins(first: 10, filter: { createdDateFrom: "2026-01-01", createdDateTo: "2026-01-31" }) { edges { node { transactionId amount } } } }'
)

import axios, { AxiosError } from "axios";

interface GraphQLError {
  message: string;
  extensions?: {
    code: string;
    correlationId: string;
    retryable: boolean;
    category: string;
  };
}

async function executeQueryWithRetry(
  url: string,
  query: string,
  maxRetries = 3
): Promise<any> {
  const credentials = Buffer.from("YOUR_SHOP_ID:YOUR_API_TOKEN").toString("base64");

  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    try {
      const response = await axios.post(
        url,
        { query },
        {
          headers: {
            "Content-Type": "application/json",
            Authorization: `Basic ${credentials}`,
          },
        }
      );

      const data = response.data;

      if (data.errors && data.errors.length > 0) {
        const error: GraphQLError = data.errors[0];
        const retryable = error.extensions?.retryable ?? false;
        const code = error.extensions?.code ?? "UNKNOWN";

        if (retryable && attempt < maxRetries) {
          const baseDelay = Math.pow(2, attempt) * 1000;
          const jitter = Math.random() * baseDelay * 0.5;
          const delay = baseDelay + jitter;
          console.log(
            `Retryable error (${code}). Retrying in ${(delay / 1000).toFixed(1)}s...`
          );
          await new Promise((resolve) => setTimeout(resolve, delay));
          continue;
        }

        throw new Error(
          `API error: ${code} - ${error.message} ` +
            `(correlationId: ${error.extensions?.correlationId ?? "N/A"})`
        );
      }

      return data;
    } catch (err) {
      if (axios.isAxiosError(err) && err.response?.status === 401) {
        throw new Error("Authentication failed. Check your Shop ID and API token.");
      }
      throw err;
    }
  }
}

// Usage
const result = await executeQueryWithRetry(
  "https://api.payretailers.com/data-api/graphql",
  `{ payins(first: 10, filter: { createdDateFrom: "2026-01-01", createdDateTo: "2026-01-31" }) { edges { node { transactionId amount } } } }`
);