@indreamai/client 0.1.0

package/dist/index.js

@@ -0,0 +1,489 @@
+var __defProp = Object.defineProperty;
+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;
+};
+
+// 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
+  });
+};
+export {
+  APIError,
+  AuthError,
+  IndreamClient,
+  RateLimitError,
+  ValidationError,
+  createApiError,
+  isExportTaskSnapshot,
+  isExportWebhookEvent,
+  isExportWebhookEventType,
+  isTaskStatus,
+  parseExportWebhookEvent,
+  toApiProblem,
+  verifyExportWebhookRequest,
+  verifyExportWebhookSignature
+};

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@indreamai/client",
+  "version": "0.1.0",
+  "description": "Official JavaScript client for Indream Open API (Node.js and Edge runtimes)",
+  "type": "module",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src tests",
+    "test": "vitest run",
+    "test:api": "vitest run tests/api",
+    "test:editor-state:core": "vitest run tests/editor-state/core",
+    "test:editor-state:full": "vitest run tests/editor-state/full",
+    "test:mock": "pnpm run test:api && pnpm run test:editor-state:core",
+    "test:ci": "pnpm run test:mock && pnpm run test:editor-state:full",
+    "test:live": "vitest run tests/integration",
+    "sync:spec": "node scripts/sync-spec.mjs",
+    "generate:types": "openapi-typescript openapi/openapi.yaml -o src/generated/openapi.ts"
+  },
+  "keywords": [
+    "indream",
+    "client",
+    "api",
+    "typescript",
+    "edge",
+    "workers"
+  ],
+  "license": "UNLICENSED",
+  "devDependencies": {
+    "@edge-runtime/vm": "5.0.0",
+    "@types/node": "24.10.0",
+    "@typescript-eslint/eslint-plugin": "8.46.3",
+    "@typescript-eslint/parser": "8.46.3",
+    "ajv": "8.17.1",
+    "eslint": "9.39.1",
+    "eslint-config-prettier": "10.1.8",
+    "eslint-plugin-prettier": "5.5.4",
+    "openapi-typescript": "7.10.1",
+    "prettier": "3.6.2",
+    "tsup": "8.5.0",
+    "typescript": "5.9.3",
+    "vitest": "3.2.4"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "packageManager": "pnpm@10.26.1"
+}