@convert-buddy/cloud-client 0.1.0-beta.1

package/dist/index.js

@@ -0,0 +1,158 @@
+import {
+  ProcessingClient,
+  ProcessingCloudError,
+  blobFile,
+  createBrowserProcessingClient,
+  createWidgetProcessingClient
+} from "./chunk-DIBGYTC7.js";
+
+// src/widget.ts
+import {
+  parseTargetSchemaV1
+} from "@convert-buddy/importer-contracts";
+var WidgetCloudError = class extends Error {
+  constructor(code, message, status, requestId) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.requestId = requestId;
+    this.name = "WidgetCloudError";
+  }
+  code;
+  status;
+  requestId;
+};
+var uuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function importPath(id) {
+  if (!uuid.test(id)) throw new TypeError("Invalid import ID");
+  return `/v2/widget/imports/${id}`;
+}
+var ConvertBuddyWidgetClient = class {
+  constructor(options) {
+    this.options = options;
+    this.#origin = new URL(options.apiUrl);
+    const u = this.#origin;
+    if (u.username || u.password || u.search || u.hash || u.pathname !== "/" || u.protocol !== "https:" && !(u.protocol === "http:" && ["localhost", "127.0.0.1"].includes(u.hostname))) throw new TypeError("API URL must be an HTTPS origin or local HTTP origin");
+    const publishableRoute = /^cb_pk_([a-f0-9]{64})\.[A-Za-z0-9_-]{43}$/.exec(options.publishableKey);
+    const sessionRoute = /^cb_ws_([a-f0-9]{64})\.[A-Za-z0-9_-]{43}$/.exec(options.sessionToken);
+    if (!publishableRoute || !sessionRoute || publishableRoute[1] !== sessionRoute[1]) throw new TypeError("A matching v2 publishable key and short-lived widget session are required");
+    this.#fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
+  }
+  options;
+  /** Explicitly retain prepared/corrected records as a downloadable hosted dataset. */
+  processing() {
+    return createWidgetProcessingClient({ apiUrl: this.options.apiUrl, publishableKey: this.options.publishableKey, sessionToken: () => this.options.sessionToken, fetch: this.options.fetch });
+  }
+  async archive(file, clientKey, signal) {
+    const client = this.processing();
+    const upload = await client.upload(file, { clientKey, operation: "import", contentType: "application/x-ndjson", signal });
+    return client.submit({ operation: "import", uploadId: upload.uploadId, options: { inputFormat: "ndjson", outputFormat: "ndjson" } }, clientKey, signal);
+  }
+  #origin;
+  #fetch;
+  async getConfig(signal) {
+    const config = await this.#request("GET", "/v2/widget/config", void 0, signal);
+    if (!config || !uuid.test(config.sessionId) || !uuid.test(config.versionId) || !config.config?.experience || !config.limits || config.limits.maximumBatchBytes < 1024) throw new WidgetCloudError("INVALID_RESPONSE", "Invalid widget configuration");
+    return { ...config, config: { ...config.config, schema: parseTargetSchemaV1(config.config.schema) } };
+  }
+  async createImport(clientKey, format, signal) {
+    if (!uuid.test(clientKey)) throw new TypeError("Invalid import client key");
+    const value = await this.#request("POST", "/v2/widget/imports", JSON.stringify({ clientKey, format }), signal);
+    if (!value || !uuid.test(value.importId)) throw new WidgetCloudError("INVALID_RESPONSE", "Invalid import response");
+    return value.importId;
+  }
+  getImport(id, signal) {
+    return this.#request("GET", importPath(id), void 0, signal);
+  }
+  async deliverBatch(id, batchId, records, signal) {
+    const body = JSON.stringify({ batchId, records });
+    if (!/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(batchId) || !records.length || records.length > 1e4 || new TextEncoder().encode(body).byteLength > 2097152) throw new WidgetCloudError("BATCH_LIMIT", "Batch exceeds the delivery contract");
+    for (let attempt = 0; ; attempt++) {
+      try {
+        const receipt = await this.#request("POST", `${importPath(id)}/batches`, body, signal);
+        if (!receipt || receipt.batchId !== batchId || receipt.recordCount !== records.length || !["delivered", "duplicate"].includes(receipt.status)) throw new WidgetCloudError("INVALID_RECEIPT", "The destination acknowledgement could not be verified");
+        return;
+      } catch (error) {
+        if (attempt >= 2 || !(error instanceof WidgetCloudError) || !["BATCH_IN_FLIGHT", "DELIVERY_UNCERTAIN"].includes(error.code)) throw error;
+        await new Promise((resolve, reject) => {
+          const abort = () => {
+            clearTimeout(timer);
+            reject(signal?.reason);
+          };
+          const timer = setTimeout(() => {
+            signal?.removeEventListener("abort", abort);
+            resolve();
+          }, 500 * 3 ** attempt);
+          if (signal?.aborted) abort();
+          else signal?.addEventListener("abort", abort, { once: true });
+        });
+      }
+    }
+  }
+  async completeImport(id, recordsRejected, recordsDeduplicated, signal) {
+    await this.#request("POST", `${importPath(id)}/complete`, JSON.stringify({ recordsRejected, recordsDeduplicated }), signal);
+  }
+  async cancelImport(id, signal) {
+    await this.#request("POST", `${importPath(id)}/cancel`, "{}", signal);
+  }
+  async #request(method, path, body, signal) {
+    const controller = new AbortController();
+    const abort = () => controller.abort(signal?.reason);
+    if (signal?.aborted) abort();
+    else signal?.addEventListener("abort", abort, { once: true });
+    const timer = setTimeout(() => controller.abort(new DOMException("Cloud request timed out", "TimeoutError")), 15e3);
+    try {
+      const response = await this.#fetch(new URL(path, this.#origin), { method, body, redirect: "manual", credentials: "omit", cache: "no-store", signal: controller.signal, headers: { authorization: `Bearer ${this.options.sessionToken}`, "X-Convert-Buddy-Key": this.options.publishableKey, ...body ? { "content-type": "application/json" } : {} } });
+      if (response.type === "opaqueredirect" || response.status >= 300 && response.status < 400) {
+        await response.body?.cancel();
+        throw new WidgetCloudError("REDIRECT_DENIED", "Cloud redirects are not permitted");
+      }
+      const reader = response.body?.getReader();
+      const parts = [];
+      let length = 0;
+      try {
+        while (reader) {
+          const chunk = await reader.read();
+          if (chunk.done) break;
+          length += chunk.value.byteLength;
+          if (length > 1048576) {
+            await reader.cancel();
+            throw new WidgetCloudError("RESPONSE_LIMIT", "Cloud metadata exceeds its limit");
+          }
+          parts.push(chunk.value);
+        }
+      } finally {
+        reader?.releaseLock();
+      }
+      const bytes = new Uint8Array(length);
+      let offset = 0;
+      for (const part of parts) {
+        bytes.set(part, offset);
+        offset += part.length;
+      }
+      let value;
+      try {
+        value = JSON.parse(new TextDecoder().decode(bytes));
+      } catch {
+        throw new WidgetCloudError("INVALID_RESPONSE", "Cloud returned invalid metadata", response.status);
+      }
+      if (!response.ok) {
+        const error = value;
+        throw new WidgetCloudError(error.error?.code ?? "HTTP_ERROR", error.error?.message ?? "Cloud request failed", response.status, response.headers.get("X-Request-Id") ?? void 0);
+      }
+      return value;
+    } finally {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", abort);
+    }
+  }
+};
+export {
+  ConvertBuddyWidgetClient,
+  ProcessingClient,
+  ProcessingCloudError,
+  WidgetCloudError,
+  blobFile,
+  createBrowserProcessingClient,
+  createWidgetProcessingClient
+};