Pagination and errors

const origin = "https://app.amber.ai";
const token = process.env.AMBER_API_KEY;
const brand = process.env.AMBER_BRAND;
if (!token || !brand) throw new Error("Set AMBER_API_KEY and AMBER_BRAND");
const brandPath = `/api/public/v1/brands/${encodeURIComponent(brand)}`;
const base = `${origin}${brandPath}/`;

export function apiUrl(resource, filters = {}) {
  const url = new URL(resource || `${origin}${brandPath}`, base);
  for (const [key, value] of Object.entries(filters)) {
    url.searchParams.set(key, String(value));
  }
  return url;
}

export async function readJson(input) {
  const url = new URL(input, origin);
  if (url.origin !== origin || (url.pathname !== brandPath && !url.pathname.startsWith(`${brandPath}/`))) {
    throw new Error("Expected an Amber API URL for the configured brand");
  }
  const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms + Math.random() * 250));
  for (let attempt = 0; attempt < 5; attempt++) {
    let response;
    let body;
    try {
      response = await fetch(url, {
        headers: { Authorization: `Bearer ${token}`, Accept: "application/json" },
        signal: AbortSignal.timeout(30_000),
        redirect: "manual",
      });
      if ([429, 500, 502, 503, 504].includes(response.status) && attempt < 4) {
        const retryAfter = response.headers.get("Retry-After");
        const requested = retryAfter === null ? NaN
          : /^\d+$/.test(retryAfter) ? Number(retryAfter) * 1000
          : Math.max(0, Date.parse(retryAfter) - Date.now());
        const delay = Number.isNaN(requested) ? 500 * 2 ** attempt : requested;
        if (delay <= 60_000) {
          await response.body?.cancel();
          await sleep(delay);
          continue;
        }
      }
      body = await response.json().catch((error) => {
        if (error instanceof SyntaxError) return null;
        throw error;
      });
    } catch (error) {
      const transient = error instanceof TypeError || ["TimeoutError", "AbortError"].includes(error.name);
      if (!transient || attempt === 4 || (response && !response.ok)) throw error;
      await sleep(500 * 2 ** attempt);
      continue;
    }
    if (!response.ok) {
      const error = new Error(`${response.status} ${body?.errorCode ?? "HTTP_ERROR"}: ${body?.error ?? response.statusText}`);
      error.status = response.status;
      error.errorCode = body?.errorCode;
      error.details = body?.details;
      error.retryAfter = response.headers.get("Retry-After");
      throw error;
    }
    if (body === null) throw new Error("Expected a JSON response from Amber");
    return body;
  }
}

function checkedPage(page) {
  if (!page || !Array.isArray(page.items) ||
      !(page.nextCursor === null || (typeof page.nextCursor === "string" && page.nextCursor.length > 0)) ||
      !Number.isInteger(page.totalItems) || page.totalItems < 0) {
    throw new Error("Expected an Amber collection page with items, nextCursor, and totalItems");
  }
  return page;
}

export async function* records(collectionUrl, cursor) {
  if (cursor === null) return;
  do {
    const url = new URL(collectionUrl, origin);
    url.searchParams.set("limit", "100");
    url.searchParams.delete("cursor");
    if (cursor) url.searchParams.set("cursor", cursor);
    const page = checkedPage(await readJson(url));
    if (cursor && page.nextCursor === cursor) throw new Error("Pagination cursor did not advance");
    yield* page.items;
    cursor = page.nextCursor;
  } while (cursor !== null);
}

export async function* includedRecords(page) {
  checkedPage(page);
  yield* page.items;
  yield* records(page.url, page.nextCursor);
}

export async function productGraph(productId, include = "all") {
  const { included, ...product } = await readJson(apiUrl(
    `products/${encodeURIComponent(productId)}`, { include, includeLimit: 100 },
  ));
  const relationships = {};
  for (const [name, page] of Object.entries(included)) {
    relationships[name] = [];
    for await (const record of includedRecords(page)) {
      relationships[name].push(record);
    }
  }
  return { product, relationships };
}

import { apiUrl, records } from "./amber-client.mjs";

for await (const product of records(apiUrl("products"))) {
  console.log(product.id, product.name);
}