Webhook retries and backoff without duplicates

// Consume webhook payloads from Hooque and classify failures as retryable or permanent
const QUEUE_NEXT_URL =
  process.env.HOOQUE_QUEUE_NEXT_URL ??
  "https://app.hooque.io/queues/cons_webhook_events/next";
const TOKEN = process.env.HOOQUE_TOKEN ?? "hq_tok_replace_me";
const headers = { Authorization: `Bearer ${TOKEN}` };

class RetryableError extends Error {}
class PermanentError extends Error {}

async function processPayload(payload) {
  // Example: input validation failures are permanent.
  if (!payload || typeof payload !== "object") throw new PermanentError("invalid payload");

  // TODO: enforce idempotency using provider event ID (payload.id) or stable hash.
  // TODO: perform side effects (DB writes, API calls) with idempotency keys where supported.
}

while (true) {
  const resp = await fetch(QUEUE_NEXT_URL, { headers });
  if (resp.status === 204) break;
  if (!resp.ok) throw new Error(`Hooque next() failed: ${resp.status}`);

  const payload = await resp.json();
  const meta = JSON.parse(resp.headers.get("X-Hooque-Meta") ?? "{}");

  try {
    await processPayload(payload);
    await fetch(meta.ackUrl, { method: "POST", headers });
  } catch (err) {
    const isPermanent = err instanceof PermanentError;
    const url = isPermanent ? meta.rejectUrl : meta.nackUrl;
    const reason = isPermanent ? `permanent: ${err.message}` : `retryable: ${err.message}`;

    await fetch(url, {
      method: "POST",
      headers: { ...headers, "Content-Type": "application/json" },
      body: JSON.stringify({ reason }),
    });
  }
}

# Consume webhook payloads from Hooque and classify failures as retryable or permanent
import json
import os
import requests

QUEUE_NEXT_URL = os.getenv(
    "HOOQUE_QUEUE_NEXT_URL",
    "https://app.hooque.io/queues/cons_webhook_events/next",
)
TOKEN = os.getenv("HOOQUE_TOKEN", "hq_tok_replace_me")
headers = {"Authorization": f"Bearer {TOKEN}"}

class RetryableError(Exception):
    pass

class PermanentError(Exception):
    pass

def process_payload(payload: dict) -> None:
    if not isinstance(payload, dict):
        raise PermanentError("invalid payload")

    # TODO: enforce idempotency using provider event ID (payload.get("id")) or stable hash.
    # TODO: perform side effects with idempotency keys where supported.
    return None

while True:
    resp = requests.get(QUEUE_NEXT_URL, headers=headers, timeout=30)

    if resp.status_code == 204:
        break
    if resp.status_code >= 400:
        raise RuntimeError(f"Hooque next() failed: {resp.status_code} {resp.text}")

    payload = resp.json()
    meta = json.loads(resp.headers.get("X-Hooque-Meta", "{}"))

    try:
        process_payload(payload)
        requests.post(meta["ackUrl"], headers=headers, timeout=30)
    except Exception as err:
        is_permanent = isinstance(err, PermanentError)
        url = meta.get("rejectUrl") if is_permanent else meta.get("nackUrl")
        reason = f"{'permanent' if is_permanent else 'retryable'}: {err}"
        requests.post(
            url,
            headers={**headers, "Content-Type": "application/json"},
            json={"reason": reason},
            timeout=30,
        )