JavaScript SDKSoon

import crypto from "node:crypto";

export class InfraredError extends Error {
  constructor(response, body) {
    const error = body?.error ?? {};
    super(error.message ?? `Infrared answered ${response.status}`);
    this.name = "InfraredError";
    this.status = response.status; // 401, 404, 422, 429, 500
    this.code = error.code ?? null; // "rate_limited", "validation_error"
    this.details = error.details ?? []; // [{ field, message }]
    this.request_id = error.request_id ?? response.headers.get("x-request-id");
    this.retry_after = Number(response.headers.get("retry-after")) || null; // seconds, on a 429
  }
}

export function createClient(key = process.env.INFRARED_KEY, { baseUrl = "https://api.useinfrared.com" } = {}) {
  // One request. Returns the parsed body, or throws an InfraredError.
  async function request(method, path, { query, body, headers } = {}) {
    const url = new URL(path, baseUrl);
    for (const [name, value] of Object.entries(query ?? {})) {
      if (value !== undefined && value !== null) url.searchParams.set(name, value);
    }
    const response = await fetch(url, {
      method,
      headers: { Authorization: `Bearer ${key}`, ...(body === undefined ? {} : { "Content-Type": "application/json" }), ...headers },
      body: body === undefined ? undefined : JSON.stringify(body),
    });
    const text = await response.text();
    let data = null;
    try {
      data = text ? JSON.parse(text) : null;
    } catch {
      // Not JSON: something between you and the API answered.
    }
    if (!response.ok) throw new InfraredError(response, data);
    return data;
  }

  // Every item of a list, page after page.
  async function* list(path, query = {}) {
    let cursor;
    do {
      const page = await request("GET", path, { query: { ...query, cursor } });
      yield* page.data;
      cursor = page.has_more ? page.next_cursor : undefined;
    } while (cursor);
  }

  return { request, list };
}

export class SignatureError extends Error {}

// rawBody: the request body as received, a Buffer or a string, before any JSON parsing
// header:  the value of the Infrared-Signature header
// secret:  the endpoint's signing secret, or an array of two while you replace an endpoint
export function constructEvent(rawBody, header, secret, toleranceSeconds = 300) {
  const parts = {};
  for (const item of String(header ?? "").split(",")) {
    const at = item.indexOf("=");
    if (at > 0) parts[item.slice(0, at).trim()] = item.slice(at + 1).trim();
  }
  if (!/^[0-9]{1,15}$/.test(parts.t ?? "") || !parts.v1) throw new SignatureError("malformed signature header");

  const age = Math.abs(Math.floor(Date.now() / 1000) - Number(parts.t));
  if (age > toleranceSeconds) throw new SignatureError("timestamp outside the tolerance");

  const body = Buffer.isBuffer(rawBody) ? rawBody : Buffer.from(String(rawBody), "utf8");
  const received = Buffer.from(parts.v1, "utf8");
  let valid = false;
  for (const candidate of [secret].flat()) {
    const expected = Buffer.from(crypto.createHmac("sha256", candidate).update(`${parts.t}.`).update(body).digest("hex"), "utf8");
    // timingSafeEqual throws when the lengths differ, so compare them first.
    if (received.length === expected.length && crypto.timingSafeEqual(received, expected)) valid = true;
  }
  if (!valid) throw new SignatureError("signature mismatch");

  return JSON.parse(body.toString("utf8"));
}

import { createClient } from "./infrared.js";

const infrared = createClient(); // reads INFRARED_KEY from the environment

const moderation = await infrared.request("POST", "/v1/moderations", {
  body: { type: "text", input: "Is this still available? I can collect on Saturday.", content_id: "message_7702" },
  headers: { "Idempotency-Key": "message-7702-v2" },
});

console.log(moderation.id, moderation.recommendation);

mod_4iiStmy545F7ONwOybqtsD allow

import { createClient, InfraredError } from "./infrared.js";

const infrared = createClient();

try {
  await infrared.request("GET", "/v1/moderations/mod_1B7lY4kzM9n2Qx8sRt3wVu");
} catch (error) {
  if (!(error instanceof InfraredError)) throw error; // no answer at all: the network failed

  console.error(error.status, error.code, error.request_id);
  if (error.code === "rate_limited") console.error(`retry in ${error.retry_after} seconds`);
}

404 not_found req_8cb281489b904ef89f9564f04661e5e6

import { createClient } from "./infrared.js";

const infrared = createClient();

for await (const event of infrared.list("/v1/webhooks/events", { type: "moderation.completed", limit: 100 })) {
  console.log(event.id, event.data.moderation.recommendation);
}