@veroai/transcribe 1.0.0

package/dist/index.js

@@ -0,0 +1,510 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  VeroAPIError: () => VeroAPIError,
+  VeroTranscribe: () => VeroTranscribe,
+  createWebhookVerifier: () => createWebhookVerifier,
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types.ts
+var VeroAPIError = class extends Error {
+  constructor(message, code, status) {
+    super(message);
+    this.name = "VeroAPIError";
+    this.code = code;
+    this.status = status;
+  }
+};
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.verotranscribe.com";
+var DEFAULT_TIMEOUT = 3e4;
+var HttpClient = class {
+  constructor(config) {
+    if (!config.apiKey) {
+      throw new Error("API key is required");
+    }
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.baseUrl || DEFAULT_BASE_URL;
+    this.timeout = config.timeout || DEFAULT_TIMEOUT;
+  }
+  async request(method, path, body) {
+    const url = `${this.baseUrl}${path}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        method,
+        headers: {
+          Authorization: `Bearer ${this.apiKey}`,
+          "Content-Type": "application/json"
+        },
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        let errorData;
+        try {
+          errorData = await response.json();
+        } catch {
+          throw new VeroAPIError("An unknown error occurred", "unknown_error", response.status);
+        }
+        throw new VeroAPIError(errorData.error.message, errorData.error.code, response.status);
+      }
+      return response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof VeroAPIError) {
+        throw error;
+      }
+      if (error instanceof Error) {
+        if (error.name === "AbortError") {
+          throw new VeroAPIError("Request timed out", "timeout", 408);
+        }
+        throw new VeroAPIError(error.message, "network_error", 0);
+      }
+      throw new VeroAPIError("An unknown error occurred", "unknown_error", 0);
+    }
+  }
+  async get(path) {
+    return this.request("GET", path);
+  }
+  async post(path, body) {
+    return this.request("POST", path, body);
+  }
+  async patch(path, body) {
+    return this.request("PATCH", path, body);
+  }
+  async delete(path) {
+    return this.request("DELETE", path);
+  }
+  async postFormData(path, formData) {
+    const url = `${this.baseUrl}${path}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${this.apiKey}`
+        },
+        body: formData,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        let errorData;
+        try {
+          errorData = await response.json();
+        } catch {
+          throw new VeroAPIError("An unknown error occurred", "unknown_error", response.status);
+        }
+        throw new VeroAPIError(errorData.error.message, errorData.error.code, response.status);
+      }
+      return response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof VeroAPIError) {
+        throw error;
+      }
+      if (error instanceof Error) {
+        if (error.name === "AbortError") {
+          throw new VeroAPIError("Request timed out", "timeout", 408);
+        }
+        throw new VeroAPIError(error.message, "network_error", 0);
+      }
+      throw new VeroAPIError("An unknown error occurred", "unknown_error", 0);
+    }
+  }
+};
+
+// src/resources/transcriptions.ts
+var DEFAULT_POLL_INTERVAL = 2e3;
+var DEFAULT_MAX_WAIT_TIME = 3e5;
+var TranscriptionsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Create a new transcription.
+   * If audioUrl is provided, transcription starts immediately.
+   * Otherwise, use upload() to provide the audio file.
+   */
+  async create(params) {
+    return this.client.post("/v1/transcriptions", params);
+  }
+  /**
+   * Get a transcription by ID
+   */
+  async get(id) {
+    return this.client.get(`/v1/transcriptions/${id}`);
+  }
+  /**
+   * List all transcriptions
+   */
+  async list(params) {
+    const query = new URLSearchParams();
+    if (params?.limit) query.set("limit", String(params.limit));
+    if (params?.offset) query.set("offset", String(params.offset));
+    if (params?.status) query.set("status", params.status);
+    if (params?.aiAnalysis) query.set("aiAnalysis", params.aiAnalysis);
+    if (params?.from) {
+      const fromDate = params.from instanceof Date ? params.from.toISOString() : params.from;
+      query.set("from", fromDate);
+    }
+    if (params?.to) {
+      const toDate = params.to instanceof Date ? params.to.toISOString() : params.to;
+      query.set("to", toDate);
+    }
+    const queryString = query.toString();
+    const path = queryString ? `/v1/transcriptions?${queryString}` : "/v1/transcriptions";
+    return this.client.get(path);
+  }
+  /**
+   * Delete a transcription
+   */
+  async delete(id) {
+    return this.client.delete(`/v1/transcriptions/${id}`);
+  }
+  /**
+   * Upload an audio file for an existing transcription
+   * This enqueues the transcription for processing
+   */
+  async upload(id, audio, params) {
+    const formData = new FormData();
+    formData.append("audio", audio);
+    const query = params?.provider ? `?provider=${params.provider}` : "";
+    return this.client.postFormData(
+      `/v1/transcriptions/${id}/upload${query}`,
+      formData
+    );
+  }
+  /**
+   * Create a transcription, upload audio, and wait for completion
+   * Convenience method that combines create(), upload(), and waitForCompletion()
+   */
+  async transcribeFile(audio, params, options) {
+    const { provider, ...createParams } = params || {};
+    const transcription = await this.create(createParams);
+    await this.upload(transcription.id, audio, { provider });
+    return this.waitForCompletion(transcription.id, options);
+  }
+  /**
+   * Wait for a transcription to complete
+   * Polls the API at regular intervals until the transcription is completed or failed
+   */
+  async waitForCompletion(id, options) {
+    const pollInterval = options?.pollInterval || DEFAULT_POLL_INTERVAL;
+    const maxWaitTime = options?.maxWaitTime || DEFAULT_MAX_WAIT_TIME;
+    const startTime = Date.now();
+    while (true) {
+      const transcription = await this.get(id);
+      if (options?.onProgress) {
+        options.onProgress(transcription);
+      }
+      if (transcription.status === "completed") {
+        return transcription;
+      }
+      if (transcription.status === "failed") {
+        throw new Error(transcription.errorMessage || "Transcription failed");
+      }
+      if (Date.now() - startTime > maxWaitTime) {
+        throw new Error("Timeout waiting for transcription to complete");
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+  }
+  /**
+   * Create a transcription from a URL and wait for it to complete.
+   * When audioUrl is provided, transcription starts immediately.
+   *
+   * @example
+   * ```ts
+   * const result = await vero.transcriptions.transcribe({
+   *   audioUrl: 'https://example.com/audio.mp3',
+   *   language: 'en',
+   * })
+   * ```
+   */
+  async transcribe(params, options) {
+    const transcription = await this.create(params);
+    return this.waitForCompletion(transcription.id, options);
+  }
+  /**
+   * Upload multiple audio files for transcription in a single batch.
+   * Returns immediately after files are queued for processing.
+   *
+   * @example
+   * ```ts
+   * const result = await vero.transcriptions.bulkUpload(
+   *   [file1, file2, file3],
+   *   { language: 'en', aiAnalysis: 'basic' }
+   * )
+   * console.log(`Queued ${result.summary.queued} files`)
+   * ```
+   */
+  async bulkUpload(files, params) {
+    const formData = new FormData();
+    if (params) {
+      formData.append("options", JSON.stringify(params));
+    }
+    for (const item of files) {
+      if (item instanceof File || item instanceof Blob) {
+        formData.append("audio[]", item);
+      } else {
+        const blob = item.file;
+        const name = item.name || (blob instanceof File ? blob.name : "audio.mp3");
+        formData.append("audio[]", blob, name);
+      }
+    }
+    return this.client.postFormData("/v1/transcriptions/bulk", formData);
+  }
+  /**
+   * Upload multiple files and wait for all to complete.
+   * Handles partial failures gracefully - returns both completed and failed transcriptions.
+   *
+   * @example
+   * ```ts
+   * const result = await vero.transcriptions.bulkTranscribe(
+   *   [file1, file2, file3],
+   *   { language: 'en' },
+   *   {
+   *     onBatchProgress: (completed, total) => {
+   *       console.log(`Progress: ${completed}/${total}`)
+   *     }
+   *   }
+   * )
+   * console.log(`Completed: ${result.completed.length}, Failed: ${result.failed.length}`)
+   * ```
+   */
+  async bulkTranscribe(files, params, options) {
+    const uploadResult = await this.bulkUpload(files, params);
+    const queuedItems = uploadResult.results.filter((r) => r.status === "queued" && r.transcriptionId);
+    const results = await this.waitForBatch(
+      queuedItems.map((item) => ({
+        id: item.transcriptionId,
+        filename: item.filename
+      })),
+      options
+    );
+    const completed = [];
+    const failed = [];
+    for (const item of uploadResult.results) {
+      if (item.status === "failed") {
+        failed.push({
+          filename: item.filename,
+          error: new Error(item.error?.message || "Upload failed")
+        });
+      }
+    }
+    for (const [id, result] of results) {
+      const item = queuedItems.find((q) => q.transcriptionId === id);
+      if (result instanceof Error) {
+        failed.push({
+          filename: item?.filename || "unknown",
+          transcriptionId: id,
+          error: result
+        });
+      } else {
+        completed.push(result);
+      }
+    }
+    return {
+      batchId: uploadResult.batchId,
+      completed,
+      failed
+    };
+  }
+  /**
+   * Wait for multiple transcriptions to complete.
+   * Polls in parallel with configurable concurrency.
+   */
+  async waitForBatch(items, options) {
+    const pollInterval = options?.pollInterval || DEFAULT_POLL_INTERVAL;
+    const maxWaitTime = options?.maxWaitTime || DEFAULT_MAX_WAIT_TIME;
+    const concurrency = options?.concurrency || 5;
+    const results = /* @__PURE__ */ new Map();
+    const pending = new Set(items.map((item) => item.id));
+    const idToFilename = new Map(items.map((item) => [item.id, item.filename || "unknown"]));
+    const startTime = Date.now();
+    while (pending.size > 0) {
+      if (Date.now() - startTime > maxWaitTime) {
+        for (const id of pending) {
+          results.set(id, new Error("Timeout waiting for transcription to complete"));
+        }
+        break;
+      }
+      const batch = Array.from(pending).slice(0, concurrency);
+      const promises = batch.map(async (id) => {
+        try {
+          const transcription = await this.get(id);
+          if (options?.onFileProgress) {
+            options.onFileProgress(idToFilename.get(id) || "unknown", transcription);
+          }
+          if (transcription.status === "completed") {
+            results.set(id, transcription);
+            pending.delete(id);
+          } else if (transcription.status === "failed") {
+            results.set(id, new Error(transcription.errorMessage || "Transcription failed"));
+            pending.delete(id);
+          }
+        } catch (error) {
+          results.set(id, error instanceof Error ? error : new Error("Unknown error"));
+          pending.delete(id);
+        }
+      });
+      await Promise.all(promises);
+      if (options?.onBatchProgress) {
+        options.onBatchProgress(results.size, items.length, results);
+      }
+      if (pending.size > 0) {
+        await new Promise((resolve) => setTimeout(resolve, pollInterval));
+      }
+    }
+    return results;
+  }
+};
+
+// src/resources/webhooks.ts
+var WebhooksResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Create a new webhook endpoint
+   */
+  async create(params) {
+    return this.client.post("/v1/webhooks", params);
+  }
+  /**
+   * Get a webhook by ID
+   */
+  async get(id) {
+    return this.client.get(`/v1/webhooks/${id}`);
+  }
+  /**
+   * List all webhooks
+   */
+  async list() {
+    return this.client.get("/v1/webhooks");
+  }
+  /**
+   * Update a webhook
+   */
+  async update(id, params) {
+    return this.client.patch(`/v1/webhooks/${id}`, params);
+  }
+  /**
+   * Delete a webhook
+   */
+  async delete(id) {
+    return this.client.delete(`/v1/webhooks/${id}`);
+  }
+  /**
+   * Get delivery history for a webhook (last 10)
+   */
+  async deliveries(id) {
+    return this.client.get(`/v1/webhooks/${id}/deliveries`);
+  }
+};
+function createWebhookVerifier(secret) {
+  return {
+    verify: async (body, signature, timestamp) => {
+      const crypto = await import("crypto");
+      const expected = crypto.createHmac("sha256", secret).update(`${timestamp}.${body}`).digest("hex");
+      return `sha256=${expected}` === signature;
+    }
+  };
+}
+
+// src/resources/usage.ts
+var UsageResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Get usage statistics for the current billing period
+   */
+  async get() {
+    return this.client.get("/v1/usage");
+  }
+  /**
+   * Get usage history (daily breakdown)
+   * @param params.days - Number of days to look back (default: 30)
+   */
+  async history(params) {
+    const query = params?.days ? `?days=${params.days}` : "";
+    return this.client.get(`/v1/usage/history${query}`);
+  }
+};
+
+// src/index.ts
+var VeroTranscribe = class {
+  /**
+   * Create a new VeroTranscribe client
+   *
+   * @param config - Configuration options
+   * @param config.apiKey - Your VeroTranscribe API key (required)
+   * @param config.baseUrl - Custom API base URL (optional, defaults to https://verotranscribe-api.siply.workers.dev)
+   * @param config.timeout - Request timeout in milliseconds (optional, defaults to 30000)
+   *
+   * @example
+   * ```typescript
+   * const client = new VeroTranscribe({
+   *   apiKey: process.env.VERO_API_KEY,
+   * });
+   *
+   * const transcription = await client.transcriptions.create({
+   *   language: 'en',
+   *   aiAnalysis: 'basic',
+   * });
+   *
+   * await client.transcriptions.upload(transcription.id, audioFile);
+   * ```
+   */
+  constructor(config) {
+    const client = new HttpClient(config);
+    this.transcriptions = new TranscriptionsResource(client);
+    this.webhooks = new WebhooksResource(client);
+    this.usage = new UsageResource(client);
+  }
+};
+var index_default = VeroTranscribe;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  VeroAPIError,
+  VeroTranscribe,
+  createWebhookVerifier
+});