Sync a brand's prompts

ORG_ID="7b1e6c1a-3f52-4d0e-9a57-2c8f1e0b4d11"
BRAND_ID="c2a4e8f0-6b1d-4c3a-8e5f-9d7b2a1c4e60"
# One key per sync you intend. Send the same value again if you retry this request.
IDEMPOTENCY_KEY="$(uuidgen)"

curl -sS -i -X PUT "https://api.surfais.com/v1/orgs/$ORG_ID/brands/$BRAND_ID/prompts" \
  -H "Authorization: Bearer $SURFAIS_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $IDEMPOTENCY_KEY" \
  -d '{
    "deactivate_missing": true,
    "prompts": [
      { "text": "best boutique hotels in Dublin city centre", "countries": ["IE", "GB"] },
      { "text": "hotels near Dublin Airport with parking", "countries": ["IE"], "tags": ["airport"] }
    ]
  }'

import os
import sys
import time
import uuid

import requests

BASE_URL = "https://api.surfais.com/v1"
ORG_ID = "7b1e6c1a-3f52-4d0e-9a57-2c8f1e0b4d11"
BRAND_ID = "c2a4e8f0-6b1d-4c3a-8e5f-9d7b2a1c4e60"
URL = f"{BASE_URL}/orgs/{ORG_ID}/brands/{BRAND_ID}/prompts"

sync_body = {
    "deactivate_missing": True,
    "prompts": [
        {"text": "best boutique hotels in Dublin city centre", "countries": ["IE", "GB"]},
        {"text": "hotels near Dublin Airport with parking", "countries": ["IE"], "tags": ["airport"]},
    ],
}

# Safe to retry with the same key. quota_exceeded is left out on purpose:
# its Retry-After counts to the end of the month.
RETRYABLE_CODES = {"rate_limited", "internal_error", "idempotency_key_in_flight"}


def apply_sync(body, max_attempts=5):
    # One key for this sync. Every retry reuses it, so the sync is never applied twice.
    idempotency_key = str(uuid.uuid4())

    for attempt in range(max_attempts):
        try:
            response = requests.put(
                URL,
                headers={
                    "Authorization": f"Bearer {os.environ['SURFAIS_API_KEY']}",
                    "Idempotency-Key": idempotency_key,
                },
                json=body,
                timeout=120,
            )
        except requests.RequestException:
            time.sleep(2**attempt)
            continue

        if response.status_code == 200:
            return response.json()["data"]

        try:
            payload = response.json()
            code = payload["error"]["code"]
        except (ValueError, KeyError):
            payload, code = {}, None

        if response.status_code == 503 or code in RETRYABLE_CODES:
            retry_after = response.headers.get("Retry-After")
            time.sleep(int(retry_after) if retry_after else 2**attempt)
            continue

        sys.exit(f"{response.status_code} {code} (request {payload.get('request_id')})")

    sys.exit("The sync did not complete. Run it again.")


result = apply_sync(sync_body)
print(result["summary"])

failed = [row for row in result["results"] if row["action"] == "failed"]
for row in failed:
    print("failed:", row["text"], "-", row["error"]["code"])
if failed:
    sys.exit(1)

// sync-prompts.mjs — run with Node 18 or later: node sync-prompts.mjs
import { randomUUID } from "node:crypto";

const BASE_URL = "https://api.surfais.com/v1";
const ORG_ID = "7b1e6c1a-3f52-4d0e-9a57-2c8f1e0b4d11";
const BRAND_ID = "c2a4e8f0-6b1d-4c3a-8e5f-9d7b2a1c4e60";
const URL_SYNC = `${BASE_URL}/orgs/${ORG_ID}/brands/${BRAND_ID}/prompts`;

const syncBody = {
  deactivate_missing: true,
  prompts: [
    { text: "best boutique hotels in Dublin city centre", countries: ["IE", "GB"] },
    { text: "hotels near Dublin Airport with parking", countries: ["IE"], tags: ["airport"] },
  ],
};

// Safe to retry with the same key. quota_exceeded is left out on purpose:
// its Retry-After counts to the end of the month.
const RETRYABLE_CODES = new Set(["rate_limited", "internal_error", "idempotency_key_in_flight"]);

const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function applySync(body, maxAttempts = 5) {
  // One key for this sync. Every retry reuses it, so the sync is never applied twice.
  const idempotencyKey = randomUUID();

  for (let attempt = 0; attempt < maxAttempts; attempt++) {
    let response;
    try {
      response = await fetch(URL_SYNC, {
        method: "PUT",
        headers: {
          Authorization: `Bearer ${process.env.SURFAIS_API_KEY}`,
          "Content-Type": "application/json",
          "Idempotency-Key": idempotencyKey,
        },
        body: JSON.stringify(body),
        signal: AbortSignal.timeout(120_000),
      });
    } catch {
      await sleep(2 ** attempt * 1000);
      continue;
    }

    if (response.status === 200) return (await response.json()).data;

    const payload = await response.json().catch(() => ({}));
    const code = payload.error?.code;

    if (response.status === 503 || RETRYABLE_CODES.has(code)) {
      const retryAfter = Number(response.headers.get("Retry-After"));
      await sleep((retryAfter || 2 ** attempt) * 1000);
      continue;
    }

    throw new Error(`${response.status} ${code} (request ${payload.request_id})`);
  }

  throw new Error("The sync did not complete. Run it again.");
}

const result = await applySync(syncBody);
console.log(result.summary);

const failed = result.results.filter((row) => row.action === "failed");
for (const row of failed) console.log("failed:", row.text, "-", row.error.code);
if (failed.length > 0) process.exit(1);