@indreamai/client 0.1.0

package/README.md

@@ -0,0 +1,33 @@
+# @indreamai/client
+
+Official JavaScript/TypeScript client for the Indream Open API.
+
+- API docs: https://docs.indream.ai
+- Supports Node.js 18+ and Edge runtimes
+
+## Installation
+
+```bash
+pnpm add @indreamai/client
+```
+
+## Quick Start
+
+```ts
+import { IndreamClient } from '@indreamai/client'
+
+const client = new IndreamClient({
+  apiKey: process.env.INDREAM_API_KEY!,
+})
+
+const created = await client.exports.create({
+  editorState,
+  ratio: '9:16',
+  scale: 0.6,
+  fps: 30,
+  format: 'mp4',
+})
+
+const task = await client.exports.wait(created.taskId)
+console.log(task.status, task.outputUrl, task.durationSeconds, task.billedStandardSeconds)
+```

package/dist/index.cjs

@@ -0,0 +1,526 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  APIError: () => APIError,
+  AuthError: () => AuthError,
+  IndreamClient: () => IndreamClient,
+  RateLimitError: () => RateLimitError,
+  ValidationError: () => ValidationError,
+  createApiError: () => createApiError,
+  isExportTaskSnapshot: () => isExportTaskSnapshot,
+  isExportWebhookEvent: () => isExportWebhookEvent,
+  isExportWebhookEventType: () => isExportWebhookEventType,
+  isTaskStatus: () => isTaskStatus,
+  parseExportWebhookEvent: () => parseExportWebhookEvent,
+  toApiProblem: () => toApiProblem,
+  verifyExportWebhookRequest: () => verifyExportWebhookRequest,
+  verifyExportWebhookSignature: () => verifyExportWebhookSignature
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var APIError = class extends Error {
+  constructor(problem) {
+    super(problem.detail || problem.title);
+    this.name = "APIError";
+    this.status = problem.status;
+    this.type = problem.type;
+    this.detail = problem.detail;
+    this.errorCode = problem.errorCode;
+  }
+};
+var AuthError = class extends APIError {
+  constructor(problem) {
+    super(problem);
+    this.name = "AuthError";
+  }
+};
+var ValidationError = class extends APIError {
+  constructor(problem) {
+    super(problem);
+    this.name = "ValidationError";
+  }
+};
+var RateLimitError = class extends APIError {
+  constructor(problem) {
+    super(problem);
+    this.name = "RateLimitError";
+  }
+};
+var toApiProblem = (status, payload) => {
+  if (payload && typeof payload === "object") {
+    const problem = payload;
+    if (typeof problem.type === "string" && typeof problem.title === "string") {
+      return {
+        type: problem.type,
+        title: problem.title,
+        status: Number(problem.status || status),
+        detail: String(problem.detail || problem.title),
+        errorCode: problem.errorCode
+      };
+    }
+  }
+  return {
+    type: "INTERNAL_ERROR",
+    title: "Internal server error",
+    status,
+    detail: "Unexpected API response",
+    errorCode: "SDK_UNEXPECTED_RESPONSE"
+  };
+};
+var createApiError = (status, payload) => {
+  const problem = toApiProblem(status, payload);
+  if (status === 401 || status === 403) {
+    return new AuthError(problem);
+  }
+  if (status === 422 || status === 400) {
+    return new ValidationError(problem);
+  }
+  if (status === 429) {
+    return new RateLimitError(problem);
+  }
+  return new APIError(problem);
+};
+
+// src/resources/exports.ts
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set(["COMPLETED", "FAILED", "CANCELED"]);
+var sleep = async (ms) => {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+};
+var ExportsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async create(payload, options = {}) {
+    var _a;
+    const idempotencyKey = (_a = options.idempotencyKey) == null ? void 0 : _a.trim();
+    return await this.client.request("/v1/exports", {
+      method: "POST",
+      body: payload,
+      idempotencyKey: idempotencyKey || void 0,
+      signal: options.signal
+    });
+  }
+  async get(taskId, options = {}) {
+    return await this.client.request(`/v1/exports/${taskId}`, {
+      method: "GET",
+      signal: options.signal
+    });
+  }
+  async list(params) {
+    var _a;
+    const search = new URLSearchParams();
+    if (params == null ? void 0 : params.pageSize) {
+      search.set("pageSize", String(params.pageSize));
+    }
+    if (params == null ? void 0 : params.pageCursor) {
+      search.set("pageCursor", params.pageCursor);
+    }
+    if (params == null ? void 0 : params.createdByApiKeyId) {
+      search.set("createdByApiKeyId", params.createdByApiKeyId);
+    }
+    const query = search.toString();
+    const envelope = await this.client.requestEnvelope(
+      `/v1/exports${query ? `?${query}` : ""}`,
+      {
+        method: "GET",
+        signal: params == null ? void 0 : params.signal
+      }
+    );
+    return {
+      items: envelope.data || [],
+      nextPageCursor: typeof ((_a = envelope.meta) == null ? void 0 : _a.nextPageCursor) === "string" ? envelope.meta.nextPageCursor : null
+    };
+  }
+  async wait(taskId, options = {}) {
+    var _a;
+    const timeoutMs = options.timeoutMs || 10 * 60 * 1e3;
+    const pollIntervalMs = options.pollIntervalMs || this.client.pollIntervalMs;
+    const startedAt = Date.now();
+    while (true) {
+      if ((_a = options.signal) == null ? void 0 : _a.aborted) {
+        throw new Error("wait aborted by caller signal");
+      }
+      if (Date.now() - startedAt > timeoutMs) {
+        throw new Error(`wait timeout after ${timeoutMs}ms`);
+      }
+      const task = await this.get(taskId, {
+        signal: options.signal
+      });
+      if (TERMINAL_STATUSES.has(task.status)) {
+        if (task.status === "FAILED" || task.status === "CANCELED") {
+          throw new APIError({
+            type: "TASK_TERMINAL_FAILURE",
+            title: "Task failed",
+            status: 422,
+            detail: task.error || `Task ended with status ${task.status}`,
+            errorCode: "TASK_TERMINAL_FAILURE"
+          });
+        }
+        return task;
+      }
+      await sleep(pollIntervalMs);
+    }
+  }
+};
+
+// src/resources/editor.ts
+var EditorResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async capabilities(options = {}) {
+    return await this.client.request("/v1/editor/capabilities", {
+      method: "GET",
+      signal: options.signal
+    });
+  }
+  async validate(editorState, options = {}) {
+    return await this.client.request("/v1/editor/validate", {
+      method: "POST",
+      body: {
+        editorState
+      },
+      signal: options.signal,
+      skipRetry: true
+    });
+  }
+};
+
+// src/retry.ts
+var sleep2 = async (ms) => {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+};
+var shouldRetryStatus = (status) => {
+  return status === 429 || status >= 500;
+};
+var computeRetryDelay = (attempt, baseDelayMs = 300, maxDelayMs = 3e3) => {
+  const exponential = Math.min(maxDelayMs, baseDelayMs * 2 ** attempt);
+  const jitter = Math.floor(Math.random() * 100);
+  return exponential + jitter;
+};
+var withRetry = async (execute, options) => {
+  let attempt = 0;
+  while (true) {
+    try {
+      return await execute(attempt);
+    } catch (error) {
+      if (error && typeof error === "object" && "noRetry" in error) {
+        throw error;
+      }
+      if (attempt >= options.maxRetries) {
+        throw error;
+      }
+      const delay = computeRetryDelay(attempt, options.baseDelayMs, options.maxDelayMs);
+      await sleep2(delay);
+      attempt += 1;
+    }
+  }
+};
+
+// src/client.ts
+var IndreamClient = class {
+  constructor(options) {
+    if (!options.apiKey) {
+      throw new Error("apiKey is required");
+    }
+    this.apiKey = options.apiKey;
+    this.baseURL = (options.baseURL || "https://api.indream.ai").replace(/\/$/, "");
+    this.timeout = options.timeout || 6e4;
+    this.maxRetries = Number.isFinite(options.maxRetries) ? Number(options.maxRetries) : 2;
+    this.pollIntervalMs = options.pollIntervalMs || 2e3;
+    this.fetchImpl = options.fetch || fetch;
+    this.exports = new ExportsResource(this);
+    this.editor = new EditorResource(this);
+  }
+  async request(path, init) {
+    const envelope = await this.requestEnvelope(path, init);
+    return envelope.data;
+  }
+  async requestEnvelope(path, init) {
+    const url = `${this.baseURL}${path.startsWith("/") ? path : `/${path}`}`;
+    const payload = init.body === void 0 ? void 0 : JSON.stringify(init.body);
+    const execute = async () => {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+      const externalSignal = init.signal;
+      const onExternalAbort = () => controller.abort();
+      let hasExternalAbortListener = false;
+      if (externalSignal) {
+        if (externalSignal.aborted) {
+          controller.abort();
+        } else {
+          externalSignal.addEventListener("abort", onExternalAbort, { once: true });
+          hasExternalAbortListener = true;
+        }
+      }
+      const headers = __spreadValues({
+        "x-api-key": this.apiKey,
+        Accept: "application/json"
+      }, init.headers);
+      if (payload !== void 0) {
+        headers["Content-Type"] = "application/json";
+      }
+      if (init.idempotencyKey) {
+        headers["Idempotency-Key"] = init.idempotencyKey;
+      }
+      try {
+        const response = await this.fetchImpl(url, {
+          method: init.method,
+          body: payload,
+          headers,
+          signal: controller.signal
+        });
+        const text = await response.text();
+        const parsed = text ? JSON.parse(text) : null;
+        if (!response.ok) {
+          throw createApiError(response.status, parsed);
+        }
+        if (!parsed || typeof parsed !== "object" || !("data" in parsed)) {
+          throw createApiError(response.status, parsed);
+        }
+        return parsed;
+      } finally {
+        clearTimeout(timeoutId);
+        if (hasExternalAbortListener) {
+          externalSignal == null ? void 0 : externalSignal.removeEventListener("abort", onExternalAbort);
+        }
+      }
+    };
+    if (init.skipRetry) {
+      return await execute();
+    }
+    return await withRetry(
+      async () => {
+        try {
+          return await execute();
+        } catch (error) {
+          const apiError = error;
+          if ((apiError == null ? void 0 : apiError.status) && shouldRetryStatus(apiError.status)) {
+            throw error;
+          }
+          if (error instanceof Error && error.name === "AbortError") {
+            throw {
+              noRetry: true,
+              error
+            };
+          }
+          if (apiError == null ? void 0 : apiError.status) {
+            throw {
+              noRetry: true,
+              error
+            };
+          }
+          throw error;
+        }
+      },
+      {
+        maxRetries: this.maxRetries
+      }
+    ).catch((error) => {
+      if (error && typeof error === "object" && "noRetry" in error) {
+        throw error.error;
+      }
+      throw error;
+    });
+  }
+};
+
+// src/webhooks.ts
+var INDREAM_WEBHOOK_TIMESTAMP_HEADER = "X-Indream-Timestamp";
+var INDREAM_WEBHOOK_SIGNATURE_HEADER = "X-Indream-Signature";
+var DEFAULT_WEBHOOK_MAX_SKEW_SECONDS = 300;
+var EXPORT_WEBHOOK_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "EXPORT_STARTED",
+  "EXPORT_COMPLETED",
+  "EXPORT_FAILED"
+]);
+var TASK_STATUSES = /* @__PURE__ */ new Set([
+  "PENDING",
+  "PROCESSING",
+  "COMPLETED",
+  "FAILED",
+  "PAUSED",
+  "CANCELED"
+]);
+var isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isNullableString = (value) => typeof value === "string" || value === null;
+var toArrayBuffer = (bytes) => {
+  const copy = new Uint8Array(bytes.byteLength);
+  copy.set(bytes);
+  return copy.buffer;
+};
+var toUtf8ArrayBuffer = (value) => toArrayBuffer(new TextEncoder().encode(value));
+var parseHexToBytes = (value) => {
+  const normalized = value.trim().toLowerCase();
+  if (!/^[0-9a-f]+$/.test(normalized) || normalized.length % 2 !== 0) {
+    return null;
+  }
+  const bytes = new Uint8Array(normalized.length / 2);
+  for (let index = 0; index < bytes.length; index += 1) {
+    const start = index * 2;
+    bytes[index] = Number.parseInt(normalized.slice(start, start + 2), 16);
+  }
+  return bytes;
+};
+var parseTimestampSeconds = (value) => {
+  if (!/^\d+$/.test(value)) {
+    return null;
+  }
+  const parsed = Number(value);
+  if (!Number.isSafeInteger(parsed)) {
+    return null;
+  }
+  return parsed;
+};
+var resolveHeaderValue = (headers, targetKey) => {
+  if (headers instanceof Headers) {
+    const value = headers.get(targetKey);
+    if (typeof value !== "string") {
+      return null;
+    }
+    const trimmed = value.trim();
+    return trimmed ? trimmed : null;
+  }
+  const lowerKey = targetKey.toLowerCase();
+  for (const [key, rawValue] of Object.entries(headers)) {
+    if (key.toLowerCase() !== lowerKey) {
+      continue;
+    }
+    const value = Array.isArray(rawValue) ? rawValue[0] : rawValue;
+    if (typeof value !== "string") {
+      return null;
+    }
+    const trimmed = value.trim();
+    return trimmed ? trimmed : null;
+  }
+  return null;
+};
+var isExportWebhookEventType = (value) => typeof value === "string" && EXPORT_WEBHOOK_EVENT_TYPES.has(value);
+var isTaskStatus = (value) => typeof value === "string" && TASK_STATUSES.has(value);
+var isExportTaskSnapshot = (value) => {
+  if (!isObject(value)) {
+    return false;
+  }
+  return typeof value.taskId === "string" && isNullableString(value.createdByApiKeyId) && isNullableString(value.clientTaskId) && isTaskStatus(value.status) && typeof value.progress === "number" && isNullableString(value.error) && isNullableString(value.outputUrl) && typeof value.durationSeconds === "number" && typeof value.billedStandardSeconds === "number" && typeof value.chargedCredits === "string" && isNullableString(value.callbackUrl) && typeof value.createdAt === "string" && isNullableString(value.completedAt);
+};
+var isExportWebhookEvent = (value) => {
+  if (!isObject(value)) {
+    return false;
+  }
+  return isExportWebhookEventType(value.eventType) && typeof value.occurredAt === "string" && isExportTaskSnapshot(value.task);
+};
+var parseExportWebhookEvent = (value) => {
+  if (!isExportWebhookEvent(value)) {
+    throw new TypeError("Invalid export webhook payload");
+  }
+  return value;
+};
+var verifyExportWebhookSignature = async ({
+  webhookSecret,
+  timestamp,
+  rawBody,
+  signature
+}) => {
+  var _a;
+  if (!webhookSecret || !timestamp || !signature) {
+    return false;
+  }
+  const signatureBytes = parseHexToBytes(signature);
+  if (!signatureBytes) {
+    return false;
+  }
+  const subtle = (_a = globalThis.crypto) == null ? void 0 : _a.subtle;
+  if (!subtle) {
+    throw new Error("Web Crypto subtle API is not available in current runtime");
+  }
+  const key = await subtle.importKey(
+    "raw",
+    toUtf8ArrayBuffer(webhookSecret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["verify"]
+  );
+  return subtle.verify(
+    "HMAC",
+    key,
+    toArrayBuffer(signatureBytes),
+    toUtf8ArrayBuffer(`${timestamp}.${rawBody}`)
+  );
+};
+var verifyExportWebhookRequest = async ({
+  webhookSecret,
+  rawBody,
+  headers,
+  maxSkewSeconds = DEFAULT_WEBHOOK_MAX_SKEW_SECONDS,
+  nowTimestampSeconds = Math.floor(Date.now() / 1e3)
+}) => {
+  const timestamp = resolveHeaderValue(headers, INDREAM_WEBHOOK_TIMESTAMP_HEADER);
+  const signature = resolveHeaderValue(headers, INDREAM_WEBHOOK_SIGNATURE_HEADER);
+  if (!timestamp || !signature) {
+    return false;
+  }
+  const parsedTimestamp = parseTimestampSeconds(timestamp);
+  if (parsedTimestamp === null || !Number.isFinite(maxSkewSeconds) || maxSkewSeconds < 0) {
+    return false;
+  }
+  if (Math.abs(nowTimestampSeconds - parsedTimestamp) > maxSkewSeconds) {
+    return false;
+  }
+  return verifyExportWebhookSignature({
+    webhookSecret,
+    timestamp,
+    rawBody,
+    signature
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  APIError,
+  AuthError,
+  IndreamClient,
+  RateLimitError,
+  ValidationError,
+  createApiError,
+  isExportTaskSnapshot,
+  isExportWebhookEvent,
+  isExportWebhookEventType,
+  isTaskStatus,
+  parseExportWebhookEvent,
+  toApiProblem,
+  verifyExportWebhookRequest,
+  verifyExportWebhookSignature
+});