Rate limits and retries

# call METHOD PATH [BODY]: one REST request; prints the body. On HTTP 429 it waits as long as
# Retry-After says (5 seconds when the header is missing) and tries again, three attempts in
# all. On any other error it prints "HTTP <status>, code <code> <name>: <message>" and the
# body, sets ERROR_CODE to the code and returns 1.
call() {
  local attempt headers response status delay
  local args=(-X "$1" "$COEVERA_BASE$2" -u "$COEVERA_API_KEY:$COEVERA_API_SECRET")
  if [ $# -ge 3 ]; then args+=(-H "Content-Type: application/json" -d "$3"); fi
  headers=$(mktemp)
  for attempt in 1 2 3; do
    response=$(curl -sS -D "$headers" -w '\n%{http_code}' "${args[@]}")
    status=${response##*$'\n'}
    response=${response%$'\n'*}
    if [ "$status" = 429 ] && [ "$attempt" -lt 3 ]; then
      delay=$(sed -n 's/^[Rr]etry-[Aa]fter: *\([0-9][0-9]*\).*/\1/p' "$headers")
      sleep "${delay:-5}"
      continue
    fi
    rm -f "$headers"
    if [ "$status" -ge 400 ]; then
      # The message is for people; branch on the numeric code.
      jq -r --arg status "$status" \
        '"HTTP \($status), code \(.code) \(.name): \(.message | sub("^\\s+"; "") | sub("\\s+$"; ""))"' <<<"$response"
      echo "$response"
      ERROR_CODE=$(jq -r '.code' <<<"$response")
      return 1
    fi
    echo "$response"
    return 0
  done
}

// An error the API answered: the HTTP status, and the code, name and message of its body.
class ApiError extends Error {
  constructor(
    readonly status: number,
    readonly code: number,
    readonly errorName: string,
    message: string,
    readonly body: unknown,
  ) {
    super(`HTTP ${status}, code ${code} ${errorName}: ${message}`);
  }
}

const sleep = (seconds: number) => new Promise((resolve) => setTimeout(resolve, seconds * 1000));

// call: one REST request. On HTTP 429 it waits as long as Retry-After says (5 seconds when the
// header is missing) and tries again, three attempts in all. Any other error is an ApiError.
async function call(path: string, init: { method?: string; body?: unknown } = {}) {
  for (let attempt = 1; ; attempt++) {
    const res = await fetch(`${base}${path}`, {
      method: init.method ?? "GET",
      headers: { Authorization: `Basic ${auth}`, "Content-Type": "application/json" },
      body: init.body === undefined ? undefined : JSON.stringify(init.body),
    });
    if (res.status === 429 && attempt < 3) {
      await sleep(Number(res.headers.get("Retry-After")) || 5);
      continue;
    }
    const body = await res.json();
    // The message is for people; branch on the numeric code.
    if (!res.ok) throw new ApiError(res.status, body.code, body.name, String(body.message).trim(), body);
    return body;
  }
}

class ApiError(Exception):
    """An error the API answered: the HTTP status, and the code, name and message of its body."""

    def __init__(self, status, body):
        self.status, self.body = status, body
        self.code, self.name = body.get("code"), body.get("name")
        message = str(body.get("message")).strip()
        super().__init__(f"HTTP {status}, code {self.code} {self.name}: {message}")


def call(method, path, **kwargs):
    """One REST request. On HTTP 429 it waits as long as Retry-After says (5 seconds when the
    header is missing) and tries again, three attempts in all. Any other error is an ApiError."""
    for attempt in range(1, 4):
        response = session.request(method, f"{BASE}{path}", timeout=30, **kwargs)
        if response.status_code == 429 and attempt < 3:
            time.sleep(float(response.headers.get("Retry-After") or 5))
            continue
        body = response.json()
        # The message is for people; branch on the numeric code.
        if not response.ok:
            raise ApiError(response.status_code, body)
        return body

# call REQUEST: POST one GraphQL request (a JSON body); prints the data. On HTTP 429 it waits as
# long as Retry-After says (5 seconds when the header is missing) and tries again, three
# attempts in all. On any error it prints "HTTP <status>, code <code> <name>: <message>" and
# the error, sets ERROR_CODE to the api_error code (null when there is none) and returns 1.
call() {
  local attempt headers response status delay
  headers=$(mktemp)
  for attempt in 1 2 3; do
    response=$(curl -sS -D "$headers" -w '\n%{http_code}' "$COEVERA_GRAPHQL" \
      -u "$COEVERA_API_KEY:$COEVERA_API_SECRET" \
      -H "Content-Type: application/json" \
      -d "$1")
    status=${response##*$'\n'}
    response=${response%$'\n'*}
    if [ "$status" = 429 ] && [ "$attempt" -lt 3 ]; then
      delay=$(sed -n 's/^[Rr]etry-[Aa]fter: *\([0-9][0-9]*\).*/\1/p' "$headers")
      sleep "${delay:-5}"
      continue
    fi
    rm -f "$headers"
    if [ "$status" != 200 ] || jq -e '.errors' <<<"$response" >/dev/null; then
      # The message is for people; branch on the numeric code.
      jq -r --arg status "$status" '.errors[0]
        | "HTTP \($status), code \(.api_error.code) \(.api_error.name // ""): \(.message | sub("^\\s+"; "") | sub("\\s+$"; ""))"' <<<"$response"
      jq '.errors[0]' <<<"$response"
      ERROR_CODE=$(jq -r '.errors[0].api_error.code' <<<"$response")
      return 1
    fi
    jq '.data' <<<"$response"
    return 0
  done
}

// An error the API answered: the HTTP status, and the code and name of api_error when the
// error has one (a document the schema refuses has none).
class ApiError extends Error {
  constructor(
    readonly status: number,
    readonly code: number | undefined,
    readonly errorName: string | undefined,
    message: string,
    readonly error: unknown,
  ) {
    super(`HTTP ${status}, code ${code ?? "none"} ${errorName ?? ""}: ${message}`);
  }
}

const sleep = (seconds: number) => new Promise((resolve) => setTimeout(resolve, seconds * 1000));

// call: one GraphQL request. On HTTP 429 it waits as long as Retry-After says (5 seconds when
// the header is missing) and tries again, three attempts in all. Any error is an ApiError.
async function call(query: string, variables: object = {}) {
  for (let attempt = 1; ; attempt++) {
    const res = await fetch(endpoint, {
      method: "POST",
      headers: { Authorization: `Basic ${auth}`, "Content-Type": "application/json" },
      body: JSON.stringify({ query, variables }),
    });
    if (res.status === 429 && attempt < 3) {
      await sleep(Number(res.headers.get("Retry-After")) || 5);
      continue;
    }
    const body = await res.json();
    const error = body.errors?.[0];
    // The message is for people; branch on the numeric code.
    if (!res.ok || error) {
      throw new ApiError(res.status, error?.api_error?.code, error?.api_error?.name, String(error?.message).trim(), error);
    }
    return body.data;
  }
}

class ApiError(Exception):
    """An error the API answered: the HTTP status, and the code and name of api_error when the
    error has one (a document the schema refuses has none)."""

    def __init__(self, status, code, name, message, error):
        super().__init__(f"HTTP {status}, code {code} {name}: {message}")
        self.status, self.code, self.name, self.error = status, code, name, error


def call(query, variables=None):
    """One GraphQL request. On HTTP 429 it waits as long as Retry-After says (5 seconds when the
    header is missing) and tries again, three attempts in all. Any error is an ApiError."""
    for attempt in range(1, 4):
        response = session.post(ENDPOINT, json={"query": query, "variables": variables or {}}, timeout=30)
        if response.status_code == 429 and attempt < 3:
            time.sleep(float(response.headers.get("Retry-After") or 5))
            continue
        body = response.json()
        error = (body.get("errors") or [None])[0]
        # The message is for people; branch on the numeric code.
        if not response.ok or error:
            api_error = (error or {}).get("api_error") or {}
            message = str((error or {}).get("message")).strip()
            raise ApiError(response.status_code, api_error.get("code"), api_error.get("name"), message, error)
        return body["data"]