@ulvio/client 0.1.0

package/dist/index.cjs

@@ -0,0 +1,642 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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, {
+  AiClient: () => AiClient,
+  CONNECTOR_UNHEALTHY_CODE: () => CONNECTOR_UNHEALTHY_CODE,
+  FilesClient: () => FilesClient,
+  HTML_TO_PDF_NOT_CONFIGURED_CODE: () => HTML_TO_PDF_NOT_CONFIGURED_CODE,
+  HtmlToPdfClient: () => HtmlToPdfClient,
+  MailClient: () => MailClient,
+  MailboxClient: () => MailboxClient,
+  PLATFORM_NOT_CONFIGURED_CODE: () => PLATFORM_NOT_CONFIGURED_CODE,
+  SmsClient: () => SmsClient,
+  UTILITIES_NOT_CONFIGURED_CODE: () => UTILITIES_NOT_CONFIGURED_CODE,
+  Ulvio: () => Ulvio,
+  UlvioError: () => UlvioError,
+  UtilitiesClient: () => UtilitiesClient,
+  VoiceClient: () => VoiceClient,
+  WhatsAppClient: () => WhatsAppClient,
+  isConnectorUnhealthyError: () => isConnectorUnhealthyError
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var CONNECTOR_UNHEALTHY_CODE = "CONNECTOR_UNHEALTHY";
+var PLATFORM_NOT_CONFIGURED_CODE = "platform_not_configured";
+var HTML_TO_PDF_NOT_CONFIGURED_CODE = "html_to_pdf_not_configured";
+var UTILITIES_NOT_CONFIGURED_CODE = "utilities_not_configured";
+var UlvioError = class extends Error {
+  code;
+  status;
+  response;
+  constructor(code, message, options = {}) {
+    super(message, { cause: options.cause });
+    this.name = "UlvioError";
+    this.code = code;
+    this.status = options.status;
+    this.response = options.response;
+  }
+};
+function isConnectorUnhealthyError(err) {
+  if (err instanceof UlvioError) return err.code === CONNECTOR_UNHEALTHY_CODE;
+  const response = err?.response;
+  return response?.error?.code === CONNECTOR_UNHEALTHY_CODE;
+}
+
+// src/http.ts
+function trimSlash(url) {
+  return url.replace(/\/$/, "");
+}
+async function parseError(res, fallbackCode = "request_failed") {
+  let body;
+  try {
+    body = await res.json();
+  } catch {
+    body = void 0;
+  }
+  const code = body?.error?.code ?? fallbackCode;
+  const message = body?.error?.message ?? res.statusText;
+  return new UlvioError(code, message, { status: res.status, response: body });
+}
+var HttpClient = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  requirePlatform(method) {
+    const url = this.config.platformApiUrl;
+    const key = this.config.platformApiKey;
+    if (!url || !key) {
+      throw new UlvioError(
+        PLATFORM_NOT_CONFIGURED_CODE,
+        `${method} requires platformApiUrl and platformApiKey to be set on the Ulvio client`
+      );
+    }
+    return { url: trimSlash(url), key };
+  }
+  requireHtmlToPdf(method) {
+    const url = this.config.htmlToPdfApiUrl;
+    if (!url) {
+      throw new UlvioError(
+        HTML_TO_PDF_NOT_CONFIGURED_CODE,
+        `${method} requires htmlToPdfApiUrl to be set on the Ulvio client`
+      );
+    }
+    return trimSlash(url);
+  }
+  requireUtilities(method) {
+    const url = this.config.utilitiesApiUrl;
+    if (!url) {
+      throw new UlvioError(
+        UTILITIES_NOT_CONFIGURED_CODE,
+        `${method} requires utilitiesApiUrl to be set on the Ulvio client`
+      );
+    }
+    return trimSlash(url);
+  }
+  // ── Platform (authenticated) ──────────────────────────────────────────
+  async platformRequest(callerName, method, path, options = {}) {
+    const { url, key } = this.requirePlatform(callerName);
+    const res = await fetch(`${url}${path}`, {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${key}`
+      },
+      body: options.body !== void 0 ? JSON.stringify(options.body) : void 0
+    });
+    if (!res.ok) throw await parseError(res);
+    return await res.json();
+  }
+  async platformRequestRaw(callerName, method, path, options = {}) {
+    const { url, key } = this.requirePlatform(callerName);
+    const headers = { ...options.headers };
+    if (options.contentType) headers["Content-Type"] = options.contentType;
+    headers["Authorization"] = `Bearer ${key}`;
+    const res = await fetch(`${url}${path}`, {
+      method,
+      headers,
+      body: options.body
+    });
+    if (!res.ok) throw await parseError(res);
+    return res;
+  }
+  // ── HTML-to-PDF (unauthenticated) ─────────────────────────────────────
+  async htmlToPdfFetch(callerName, path, init) {
+    const url = this.requireHtmlToPdf(callerName);
+    return fetch(`${url}${path}`, init);
+  }
+  // ── Utilities (unauthenticated) ───────────────────────────────────────
+  async utilitiesRequest(callerName, method, path, options = {}) {
+    const url = this.requireUtilities(callerName);
+    const res = await fetch(`${url}${path}`, {
+      method,
+      headers: { "Content-Type": "application/json" },
+      body: options.body !== void 0 ? JSON.stringify(options.body) : void 0
+    });
+    const data = await res.json().catch(() => void 0);
+    if (!res.ok) {
+      const errBody = data;
+      throw new UlvioError(
+        errBody?.error?.code ?? "request_failed",
+        errBody?.error?.message ?? res.statusText,
+        { status: res.status, response: data }
+      );
+    }
+    return data;
+  }
+};
+
+// src/clients/mail.ts
+var MailClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  sendTransactional(params) {
+    return this.http.platformRequest(
+      "client.mail.sendTransactional()",
+      "POST",
+      "/v1/transactional-mail/send",
+      { body: params }
+    );
+  }
+};
+
+// src/clients/mailbox.ts
+var MailboxClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  send(params) {
+    return this.http.platformRequest(
+      "client.mailbox.send()",
+      "POST",
+      "/v1/mailbox/send",
+      { body: params }
+    );
+  }
+  list(limit) {
+    const qs = limit !== void 0 ? `?limit=${limit}` : "";
+    return this.http.platformRequest(
+      "client.mailbox.list()",
+      "GET",
+      `/v1/mailbox/messages${qs}`
+    );
+  }
+  get(id) {
+    return this.http.platformRequest(
+      "client.mailbox.get()",
+      "GET",
+      `/v1/mailbox/messages/${encodeURIComponent(id)}`
+    );
+  }
+  markProcessed(id) {
+    return this.http.platformRequest(
+      "client.mailbox.markProcessed()",
+      "POST",
+      `/v1/mailbox/messages/${encodeURIComponent(id)}/mark-processed`
+    );
+  }
+  /**
+   * Download a mailbox message attachment as a Buffer.
+   */
+  async getAttachment(messageId, attachmentId) {
+    const res = await this.http.platformRequestRaw(
+      "client.mailbox.getAttachment()",
+      "GET",
+      `/v1/mailbox/messages/${encodeURIComponent(messageId)}/attachments/${encodeURIComponent(attachmentId)}`
+    );
+    const arrayBuffer = await res.arrayBuffer();
+    return Buffer.from(arrayBuffer);
+  }
+  getConnectorStatus() {
+    return this.http.platformRequest(
+      "client.mailbox.getConnectorStatus()",
+      "GET",
+      "/v1/mailbox/connector-status"
+    );
+  }
+  /**
+   * Dev-only: toggle the mock connector's health state.
+   */
+  setConnectorStatus(healthy) {
+    return this.http.platformRequest(
+      "client.mailbox.setConnectorStatus()",
+      "PATCH",
+      "/v1/mailbox/connector-status",
+      { body: { healthy } }
+    );
+  }
+};
+
+// src/clients/sms.ts
+var SmsClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  send(params) {
+    return this.http.platformRequest(
+      "client.sms.send()",
+      "POST",
+      "/v1/sms/send",
+      { body: params }
+    );
+  }
+};
+
+// src/clients/whatsapp.ts
+var WhatsAppClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  send(params) {
+    return this.http.platformRequest(
+      "client.whatsapp.send()",
+      "POST",
+      "/v1/whatsapp/send",
+      { body: params }
+    );
+  }
+};
+
+// src/clients/voice.ts
+var VoiceClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  transcribe(params) {
+    return this.http.platformRequest(
+      "client.voice.transcribe()",
+      "POST",
+      "/v1/voice/send",
+      { body: params }
+    );
+  }
+};
+
+// src/clients/files.ts
+var FilesClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  async upload(key, file, contentType = "application/octet-stream") {
+    const res = await this.http.platformRequestRaw(
+      "client.files.upload()",
+      "PUT",
+      `/v1/files/${encodeURI(key)}`,
+      { body: file, contentType }
+    );
+    return await res.json();
+  }
+  /**
+   * Download a file. Returns the raw Response for streaming.
+   */
+  get(key) {
+    return this.http.platformRequestRaw(
+      "client.files.get()",
+      "GET",
+      `/v1/files/${encodeURI(key)}`
+    );
+  }
+  list(prefix, limit, cursor) {
+    const params = new URLSearchParams();
+    if (prefix) params.set("prefix", prefix);
+    if (limit !== void 0) params.set("limit", String(limit));
+    if (cursor) params.set("cursor", cursor);
+    const qs = params.toString();
+    return this.http.platformRequest(
+      "client.files.list()",
+      "GET",
+      `/v1/files${qs ? `?${qs}` : ""}`
+    );
+  }
+  delete(key) {
+    return this.http.platformRequest(
+      "client.files.delete()",
+      "DELETE",
+      `/v1/files/${encodeURI(key)}`
+    );
+  }
+  deleteMany(prefix) {
+    return this.http.platformRequest(
+      "client.files.deleteMany()",
+      "DELETE",
+      `/v1/files?prefix=${encodeURIComponent(prefix)}`
+    );
+  }
+  /**
+   * Generate a time-limited download URL for a file.
+   * @param expiresIn TTL in seconds (default 3600, min 60, max 86400)
+   */
+  presignedDownloadUrl(key, expiresIn) {
+    return this.http.platformRequest(
+      "client.files.presignedDownloadUrl()",
+      "POST",
+      "/v1/files/presigned-download",
+      { body: { key, expires_in: expiresIn } }
+    );
+  }
+  /**
+   * Generate a time-limited upload URL for a file.
+   * @param expiresIn TTL in seconds (default 3600, min 60, max 86400)
+   * @param maxSize Max file size in bytes (default 50MB)
+   */
+  presignedUploadUrl(key, contentType, expiresIn, maxSize) {
+    return this.http.platformRequest(
+      "client.files.presignedUploadUrl()",
+      "POST",
+      "/v1/files/presigned-upload",
+      {
+        body: { key, content_type: contentType, expires_in: expiresIn, max_size: maxSize }
+      }
+    );
+  }
+};
+
+// src/clients/ai.ts
+var import_zod = require("zod");
+function buildPayload(params) {
+  return {
+    model: params.model,
+    input: params.input,
+    schema: import_zod.z.toJSONSchema(params.schema)
+  };
+}
+function parseSseEvents(chunk) {
+  const events = [];
+  let currentEvent = "";
+  let currentData = "";
+  for (const line of chunk.split("\n")) {
+    if (line.startsWith("event: ")) {
+      currentEvent = line.slice(7);
+    } else if (line.startsWith("data: ")) {
+      currentData = line.slice(6);
+    } else if (line === "" && currentEvent) {
+      events.push({ event: currentEvent, data: currentData });
+      currentEvent = "";
+      currentData = "";
+    }
+  }
+  return events;
+}
+var AiClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  async parse(params) {
+    const wire = buildPayload(params);
+    const response = await this.http.platformRequest(
+      "client.ai.parse()",
+      "POST",
+      "/v1/ai/parse",
+      { body: wire }
+    );
+    return params.schema.parse(response.data);
+  }
+  async *stream(params) {
+    const wire = buildPayload(params);
+    const res = await this.http.platformRequestRaw(
+      "client.ai.stream()",
+      "POST",
+      "/v1/ai/stream",
+      {
+        body: JSON.stringify(wire),
+        contentType: "application/json",
+        headers: { Accept: "text/event-stream" }
+      }
+    );
+    if (!res.body) {
+      throw new UlvioError("stream_no_body", "AI stream returned no response body", {
+        status: res.status
+      });
+    }
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const events = parseSseEvents(buffer);
+      const lastBoundary = buffer.lastIndexOf("\n\n");
+      buffer = lastBoundary >= 0 ? buffer.slice(lastBoundary + 2) : buffer;
+      for (const { event, data } of events) {
+        switch (event) {
+          case "partial":
+            yield { type: "partial", data: JSON.parse(data) };
+            break;
+          case "complete": {
+            const parsed = params.schema.parse(JSON.parse(data));
+            yield { type: "complete", data: parsed };
+            return;
+          }
+          case "error": {
+            const errBody = JSON.parse(data);
+            throw new UlvioError(
+              "code" in errBody && errBody.code || "ai_stream_error",
+              errBody.message
+            );
+          }
+        }
+      }
+    }
+  }
+};
+
+// src/clients/html-to-pdf.ts
+function parseSseEvents2(chunk) {
+  const events = [];
+  let currentEvent = "";
+  let currentData = "";
+  for (const line of chunk.split("\n")) {
+    if (line.startsWith("event: ")) {
+      currentEvent = line.slice(7);
+    } else if (line.startsWith("data: ")) {
+      currentData = line.slice(6);
+    } else if (line === "" && currentEvent) {
+      events.push({ event: currentEvent, data: currentData });
+      currentEvent = "";
+      currentData = "";
+    }
+  }
+  return events;
+}
+var HtmlToPdfClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  async convert(params, callbacks) {
+    const res = await this.http.htmlToPdfFetch("client.htmlToPdf.convert()", "/api/html-to-pdf", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(params)
+    });
+    if (!res.ok) {
+      const data = await res.json().catch(() => void 0);
+      throw new UlvioError(
+        data?.error?.code ?? "html_to_pdf_failed",
+        data?.error?.message ?? res.statusText,
+        { status: res.status, response: data }
+      );
+    }
+    if (!res.body) {
+      throw new UlvioError("html_to_pdf_no_body", "html-to-pdf service returned no body", {
+        status: res.status
+      });
+    }
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const events = parseSseEvents2(buffer);
+      const lastBoundary = buffer.lastIndexOf("\n\n");
+      buffer = lastBoundary >= 0 ? buffer.slice(lastBoundary + 2) : buffer;
+      for (const { event, data } of events) {
+        switch (event) {
+          case "queued":
+            callbacks?.onQueued?.(JSON.parse(data));
+            break;
+          case "processing":
+            callbacks?.onProcessing?.(JSON.parse(data));
+            break;
+          case "complete":
+            return JSON.parse(data);
+          case "error": {
+            const errBody = JSON.parse(data);
+            throw new UlvioError(
+              errBody.code ?? "html_to_pdf_error",
+              errBody.message
+            );
+          }
+        }
+      }
+    }
+    throw new UlvioError(
+      "html_to_pdf_truncated",
+      "SSE stream ended without a complete event"
+    );
+  }
+};
+
+// src/clients/utilities.ts
+var UtilitiesClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  compileMjml(params) {
+    return this.http.utilitiesRequest(
+      "client.utilities.compileMjml()",
+      "POST",
+      "/api/mjml/compile",
+      { body: params }
+    );
+  }
+  renderLiquid(params) {
+    return this.http.utilitiesRequest(
+      "client.utilities.renderLiquid()",
+      "POST",
+      "/api/liquidjs/render",
+      { body: params }
+    );
+  }
+  extractLiquidVariables(params) {
+    return this.http.utilitiesRequest(
+      "client.utilities.extractLiquidVariables()",
+      "POST",
+      "/api/liquidjs/variables",
+      { body: params }
+    );
+  }
+  renderMarkdown(params) {
+    return this.http.utilitiesRequest(
+      "client.utilities.renderMarkdown()",
+      "POST",
+      "/api/markdown/render",
+      { body: params }
+    );
+  }
+  renderEmail(params) {
+    return this.http.utilitiesRequest(
+      "client.utilities.renderEmail()",
+      "POST",
+      "/api/render-email",
+      { body: params }
+    );
+  }
+};
+
+// src/index.ts
+var Ulvio = class {
+  mail;
+  mailbox;
+  sms;
+  whatsapp;
+  voice;
+  files;
+  ai;
+  htmlToPdf;
+  utilities;
+  constructor(config = {}) {
+    const http = new HttpClient(config);
+    this.mail = new MailClient(http);
+    this.mailbox = new MailboxClient(http);
+    this.sms = new SmsClient(http);
+    this.whatsapp = new WhatsAppClient(http);
+    this.voice = new VoiceClient(http);
+    this.files = new FilesClient(http);
+    this.ai = new AiClient(http);
+    this.htmlToPdf = new HtmlToPdfClient(http);
+    this.utilities = new UtilitiesClient(http);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AiClient,
+  CONNECTOR_UNHEALTHY_CODE,
+  FilesClient,
+  HTML_TO_PDF_NOT_CONFIGURED_CODE,
+  HtmlToPdfClient,
+  MailClient,
+  MailboxClient,
+  PLATFORM_NOT_CONFIGURED_CODE,
+  SmsClient,
+  UTILITIES_NOT_CONFIGURED_CODE,
+  Ulvio,
+  UlvioError,
+  UtilitiesClient,
+  VoiceClient,
+  WhatsAppClient,
+  isConnectorUnhealthyError
+});
+//# sourceMappingURL=index.cjs.map