@audialize/sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,648 @@
+'use strict';
+
+// src/http/errors.ts
+var AudiolizeError = class extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.name = this.constructor.name;
+    this.code = code;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var AudiolizeApiError = class extends AudiolizeError {
+  statusCode;
+  requestId;
+  constructor(message, code, statusCode, requestId) {
+    super(message, code);
+    this.statusCode = statusCode;
+    this.requestId = requestId;
+  }
+};
+var AuthenticationError = class extends AudiolizeApiError {
+  constructor(message, requestId) {
+    super(message, "AUTHENTICATION_ERROR", 401, requestId);
+  }
+};
+var AuthorizationError = class extends AudiolizeApiError {
+  constructor(message, requestId) {
+    super(message, "AUTHORIZATION_ERROR", 403, requestId);
+  }
+};
+var NotFoundError = class extends AudiolizeApiError {
+  constructor(message, requestId) {
+    super(message, "NOT_FOUND_ERROR", 404, requestId);
+  }
+};
+var RateLimitError = class extends AudiolizeApiError {
+  retryAfter;
+  constructor(message, retryAfter, requestId) {
+    super(message, "RATE_LIMIT_ERROR", 429, requestId);
+    this.retryAfter = retryAfter;
+  }
+};
+var PaywallError = class extends AudiolizeApiError {
+  constructor(message, requestId) {
+    super(message, "PAYWALL_ERROR", 402, requestId);
+  }
+};
+var ServerError = class extends AudiolizeApiError {
+  constructor(message, statusCode, requestId) {
+    super(message, "SERVER_ERROR", statusCode, requestId);
+  }
+};
+var AudiolizeUploadError = class extends AudiolizeError {
+  constructor(message) {
+    super(message, "UPLOAD_ERROR");
+  }
+};
+var AudiolizeTimeoutError = class extends AudiolizeError {
+  constructor(message) {
+    super(message, "TIMEOUT_ERROR");
+  }
+};
+var AudiolizeValidationError = class extends AudiolizeError {
+  constructor(message) {
+    super(message, "VALIDATION_ERROR");
+  }
+};
+
+// src/http/HttpClient.ts
+var HttpClient = class {
+  apiKey;
+  baseUrl;
+  timeout;
+  maxRetries;
+  fetchImpl;
+  constructor(options) {
+    if (!options.apiKey) {
+      throw new Error("API key is required");
+    }
+    this.apiKey = options.apiKey;
+    this.baseUrl = options.baseUrl || "https://api.audialize.com";
+    this.timeout = options.timeout || 3e4;
+    this.maxRetries = options.maxRetries ?? 3;
+    this.fetchImpl = options.fetch || globalThis.fetch.bind(globalThis);
+  }
+  async request(path, options = {}) {
+    const url = new URL(path, this.baseUrl).toString();
+    const headers = new Headers(options.headers);
+    headers.set("Authorization", `Bearer ${this.apiKey}`);
+    if (!headers.has("Content-Type") && options.body && typeof options.body === "string") {
+      headers.set("Content-Type", "application/json");
+    }
+    let attempt = 0;
+    while (attempt <= this.maxRetries) {
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        const response = await this.fetchImpl(url, {
+          ...options,
+          headers,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (response.ok) {
+          if (response.status === 204) {
+            return {};
+          }
+          return await response.json();
+        }
+        await this.handleErrorResponse(response);
+      } catch (error) {
+        if (error instanceof AudiolizeApiError) {
+          if (error instanceof RateLimitError && attempt < this.maxRetries) {
+            const delayMs = error.retryAfter ? error.retryAfter * 1e3 : this.getBackoffDelay(attempt);
+            await this.delay(delayMs);
+            attempt++;
+            continue;
+          }
+          if (error.statusCode >= 500 && attempt < this.maxRetries) {
+            await this.delay(this.getBackoffDelay(attempt));
+            attempt++;
+            continue;
+          }
+          throw error;
+        }
+        if (error instanceof Error && error.name === "AbortError") {
+          if (attempt < this.maxRetries) {
+            await this.delay(this.getBackoffDelay(attempt));
+            attempt++;
+            continue;
+          }
+          throw new AudiolizeTimeoutError(`Request timeout after ${this.timeout}ms`);
+        }
+        if (attempt < this.maxRetries) {
+          await this.delay(this.getBackoffDelay(attempt));
+          attempt++;
+          continue;
+        }
+        throw error;
+      }
+    }
+    throw new Error("Max retries exceeded");
+  }
+  async handleErrorResponse(response) {
+    let errorData = {};
+    try {
+      const parsed = await response.json();
+      if (isRecord(parsed)) {
+        errorData = parsed;
+      }
+    } catch {
+    }
+    const errorMessage = typeof errorData.error === "string" ? errorData.error : void 0;
+    const fallbackMessage = typeof errorData.message === "string" ? errorData.message : void 0;
+    const message = errorMessage || fallbackMessage || response.statusText;
+    const requestId = response.headers.get("x-request-id") || void 0;
+    switch (response.status) {
+      case 401:
+        throw new AuthenticationError(message, requestId);
+      case 402:
+        throw new PaywallError(message, requestId);
+      case 403:
+        throw new AuthorizationError(message, requestId);
+      case 404:
+        throw new NotFoundError(message, requestId);
+      case 429: {
+        const retryAfterHeader = response.headers.get("retry-after");
+        const retryAfter = retryAfterHeader ? parseInt(retryAfterHeader, 10) : void 0;
+        throw new RateLimitError(message, retryAfter, requestId);
+      }
+      default:
+        if (response.status >= 500) {
+          throw new ServerError(message, response.status, requestId);
+        }
+        throw new AudiolizeApiError(message, "API_ERROR", response.status, requestId);
+    }
+  }
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  getBackoffDelay(attempt) {
+    const baseDelay = 1e3;
+    const maxDelay = 6e4;
+    const delay2 = Math.min(baseDelay * Math.pow(2, attempt), maxDelay);
+    return delay2 * (0.5 + Math.random() * 0.5);
+  }
+};
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/workflows/JobPoller.ts
+var JobPoller = class {
+  jobId;
+  jobsResource;
+  options;
+  currentInterval;
+  unchangedStepCount = 0;
+  lastStep = null;
+  isPolling = false;
+  listeners = {};
+  constructor(jobId, jobsResource, options) {
+    this.jobId = jobId;
+    this.jobsResource = jobsResource;
+    this.options = {
+      interval: options?.interval ?? 3e3,
+      maxInterval: options?.maxInterval ?? 15e3,
+      timeout: options?.timeout ?? 6e5,
+      backoff: options?.backoff ?? true
+    };
+    this.currentInterval = this.options.interval;
+  }
+  on(event, listener) {
+    if (!this.listeners[event]) {
+      this.listeners[event] = [];
+    }
+    this.listeners[event].push(listener);
+    return this;
+  }
+  emit(event, payload) {
+    if (event === "progress") {
+      const eventListeners2 = this.listeners.progress ?? [];
+      for (const listener of eventListeners2) {
+        listener(payload);
+      }
+      return;
+    }
+    if (event === "completed") {
+      const eventListeners2 = this.listeners.completed ?? [];
+      for (const listener of eventListeners2) {
+        listener(payload);
+      }
+      return;
+    }
+    const eventListeners = this.listeners.failed ?? [];
+    for (const listener of eventListeners) {
+      listener(payload);
+    }
+  }
+  async start() {
+    if (this.isPolling) {
+      throw new Error("Polling is already in progress");
+    }
+    this.isPolling = true;
+    const startTime = Date.now();
+    while (this.isPolling) {
+      if (Date.now() - startTime > this.options.timeout) {
+        this.isPolling = false;
+        const error = new AudiolizeTimeoutError(`Job ${this.jobId} timed out after ${this.options.timeout}ms`);
+        this.emit("failed", error);
+        throw error;
+      }
+      try {
+        const job = await this.jobsResource.get(this.jobId);
+        if (job.status === "completed") {
+          this.isPolling = false;
+          this.emit("completed", job);
+          return job;
+        }
+        if (job.status === "failed") {
+          this.isPolling = false;
+          const error = new Error(job.error || "Job failed");
+          this.emit("failed", error);
+          throw error;
+        }
+        this.emit("progress", { step: job.currentStep, progress: job.progress });
+        if (this.options.backoff) {
+          if (job.currentStep === this.lastStep) {
+            this.unchangedStepCount++;
+            if (this.unchangedStepCount >= 3) {
+              this.currentInterval = Math.min(this.currentInterval * 2, this.options.maxInterval);
+            }
+          } else {
+            this.unchangedStepCount = 0;
+            this.currentInterval = this.options.interval;
+            this.lastStep = job.currentStep;
+          }
+        }
+        await new Promise((resolve) => setTimeout(resolve, this.currentInterval));
+      } catch (error) {
+        this.isPolling = false;
+        const err = error instanceof Error ? error : new Error(String(error));
+        this.emit("failed", err);
+        throw err;
+      }
+    }
+    throw new Error("Polling stopped unexpectedly");
+  }
+  stop() {
+    this.isPolling = false;
+  }
+};
+
+// src/resources/jobs.ts
+var JobsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async get(jobId) {
+    return this.client.request(`/jobs/${jobId}/status`);
+  }
+  async list(options) {
+    const query = new URLSearchParams();
+    if (options?.limit) query.set("limit", options.limit.toString());
+    if (options?.pageToken) query.set("pageToken", options.pageToken);
+    const path = `/jobs${query.toString() ? `?${query.toString()}` : ""}`;
+    return this.client.request(path);
+  }
+  /**
+   * Polls until the job reaches `completed` or `failed`, then returns the final job.
+   * Throws `AudiolizeTimeoutError` if the job does not complete within `options.timeout`.
+   */
+  waitForCompletion(jobId, options) {
+    const pollConfig = {};
+    if (options?.interval !== void 0) pollConfig.interval = options.interval;
+    if (options?.maxInterval !== void 0) pollConfig.maxInterval = options.maxInterval;
+    if (options?.timeout !== void 0) pollConfig.timeout = options.timeout;
+    if (options?.backoff !== void 0) pollConfig.backoff = options.backoff;
+    const poller = new JobPoller(jobId, this, pollConfig);
+    if (options?.onProgress) {
+      poller.on("progress", ({ step, progress }) => {
+        options.onProgress(step, progress);
+      });
+    }
+    return poller.start();
+  }
+  /**
+   * Returns a `JobPoller` instance for event-driven polling.
+   * Call `.start()` to begin, or listen to `progress`, `completed`, `failed` events.
+   */
+  poll(jobId, options) {
+    return new JobPoller(jobId, this, options);
+  }
+};
+
+// src/resources/languages.ts
+var LanguagesResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list() {
+    return this.client.request("/supported-languages");
+  }
+};
+
+// src/resources/subtitles.ts
+var SubtitlesResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async download(jobId, language, format) {
+    const response = await this.client.request("/presigned-url", {
+      method: "POST",
+      body: JSON.stringify({
+        type: "download",
+        jobId,
+        language,
+        format
+      })
+    });
+    const downloadResponse = await fetch(response.url);
+    if (!downloadResponse.ok) {
+      throw new Error(`Failed to download subtitles: ${downloadResponse.statusText}`);
+    }
+    if (format === "json") {
+      return downloadResponse.json();
+    }
+    return downloadResponse.text();
+  }
+};
+
+// src/utils/retry.ts
+function getBackoffDelay(attempt, baseDelay = 1e3, maxDelay = 6e4) {
+  const exponential = Math.min(baseDelay * Math.pow(2, attempt), maxDelay);
+  const jitter = 0.5 + Math.random() * 0.5;
+  return Math.floor(exponential * jitter);
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function withRetry(fn, options = {}) {
+  const { maxRetries = 3, baseDelay = 1e3, maxDelay = 6e4, shouldRetry } = options;
+  let attempt = 0;
+  while (true) {
+    try {
+      return await fn();
+    } catch (error) {
+      const isRetryable = shouldRetry ? shouldRetry(error, attempt) : true;
+      if (!isRetryable || attempt >= maxRetries) {
+        throw error;
+      }
+      await delay(getBackoffDelay(attempt, baseDelay, maxDelay));
+      attempt++;
+    }
+  }
+}
+
+// src/utils/multipart.ts
+function splitIntoChunks(file, partUrls) {
+  const totalSize = file instanceof Blob ? file.size : file.length;
+  const partCount = partUrls.length;
+  const chunkSize = Math.ceil(totalSize / partCount);
+  const chunks = [];
+  for (let i = 0; i < partCount; i++) {
+    const start = i * chunkSize;
+    const end = Math.min(start + chunkSize, totalSize);
+    let data;
+    if (file instanceof Blob) {
+      data = file.slice(start, end);
+    } else {
+      data = file.subarray(start, end);
+    }
+    chunks.push({
+      partNumber: i + 1,
+      url: partUrls[i],
+      data,
+      size: end - start
+    });
+  }
+  return Promise.resolve(chunks);
+}
+async function uploadPart(chunk) {
+  const response = await withRetry(
+    () => fetch(chunk.url, {
+      method: "PUT",
+      body: chunk.data,
+      headers: {
+        "Content-Length": chunk.size.toString()
+      }
+    }),
+    { maxRetries: 3 }
+  );
+  if (!response.ok) {
+    throw new AudiolizeUploadError(
+      `Failed to upload part ${chunk.partNumber}: ${response.statusText}`
+    );
+  }
+  const etag = response.headers.get("etag");
+  if (!etag) {
+    throw new AudiolizeUploadError(`No ETag returned for part ${chunk.partNumber}`);
+  }
+  return { partNumber: chunk.partNumber, etag };
+}
+async function uploadAllParts(chunks, concurrency = 4, onProgress) {
+  const totalBytes = chunks.reduce((sum, c) => sum + c.size, 0);
+  let uploadedBytes = 0;
+  const results = [];
+  for (let i = 0; i < chunks.length; i += concurrency) {
+    const batch = chunks.slice(i, i + concurrency);
+    const batchResults = await Promise.all(
+      batch.map(async (chunk) => {
+        const part = await uploadPart(chunk);
+        uploadedBytes += chunk.size;
+        onProgress?.(uploadedBytes, totalBytes);
+        return { part, index: chunk.partNumber - 1 };
+      })
+    );
+    for (const { part, index } of batchResults) {
+      results[index] = part;
+    }
+  }
+  return results;
+}
+
+// src/resources/files.ts
+var DEFAULT_MULTIPART_THRESHOLD = 100 * 1024 * 1024;
+var FilesResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async upload(file, options) {
+    const response = await this.client.request("/presigned-url", {
+      method: "POST",
+      body: JSON.stringify({
+        type: "upload",
+        fileName: options.fileName,
+        languages: options.languages,
+        sourceLanguage: options.sourceLanguage,
+        transcriptionOptions: options.transcriptionOptions,
+        context: options.context,
+        estimatedMinutes: options.estimatedMinutes,
+        enableDubbing: options.enableDubbing,
+        enableSdh: options.enableSdh
+      })
+    });
+    const body = await resolveBody(file);
+    const uploadResponse = await withRetry(
+      () => fetch(response.uploadUrl, {
+        method: "PUT",
+        body,
+        headers: {
+          "Content-Type": options.contentType || "application/octet-stream"
+        }
+      }),
+      { maxRetries: 3 }
+    );
+    if (!uploadResponse.ok) {
+      throw new AudiolizeUploadError(`Failed to upload file: ${uploadResponse.statusText}`);
+    }
+    options.onUploadProgress?.(100);
+    return { jobId: response.jobId };
+  }
+  async uploadMultipart(file, options) {
+    const fileSize = file instanceof Blob ? file.size : file.length;
+    if (fileSize === 0) {
+      throw new AudiolizeValidationError("Cannot multipart-upload an empty file.");
+    }
+    const presigned = await this.client.request("/presigned-url", {
+      method: "POST",
+      body: JSON.stringify({
+        type: "upload",
+        multipart: true,
+        fileSize,
+        fileName: options.fileName,
+        languages: options.languages,
+        sourceLanguage: options.sourceLanguage,
+        transcriptionOptions: options.transcriptionOptions,
+        context: options.context,
+        estimatedMinutes: options.estimatedMinutes,
+        enableDubbing: options.enableDubbing,
+        enableSdh: options.enableSdh
+      })
+    });
+    const chunks = await splitIntoChunks(file, presigned.partUrls);
+    const progressCallback = options.onUploadProgress;
+    const onProgress = progressCallback ? (uploaded, total) => progressCallback(Math.round(uploaded / total * 100)) : void 0;
+    const parts = await uploadAllParts(chunks, options.concurrency ?? 4, onProgress);
+    const completion = await this.client.request("/presigned-url", {
+      method: "POST",
+      body: JSON.stringify({
+        type: "complete-multipart",
+        uploadId: presigned.uploadId,
+        uploadKey: presigned.uploadKey,
+        parts
+      })
+    });
+    if (!completion.success) {
+      throw new AudiolizeUploadError("Multipart upload completion reported failure.");
+    }
+    return { jobId: presigned.jobId };
+  }
+};
+async function resolveBody(file) {
+  if (typeof file === "string") {
+    const { readFile } = await import('fs/promises');
+    return readFile(file);
+  }
+  return file;
+}
+
+// src/workflows/localize.ts
+async function localize(client, options) {
+  const multipartThreshold = options.multipartThreshold ?? DEFAULT_MULTIPART_THRESHOLD;
+  const uploadOptions = {
+    fileName: options.fileName ?? (typeof options.file === "string" ? options.file.split("/").pop() ?? "upload" : "upload"),
+    languages: options.languages,
+    ...options.sourceLanguage !== void 0 && { sourceLanguage: options.sourceLanguage },
+    ...options.transcriptionOptions !== void 0 && { transcriptionOptions: options.transcriptionOptions },
+    ...options.context !== void 0 && { context: options.context },
+    ...options.estimatedMinutes !== void 0 && { estimatedMinutes: options.estimatedMinutes },
+    ...options.enableDubbing !== void 0 && { enableDubbing: options.enableDubbing },
+    ...options.enableSdh !== void 0 && { enableSdh: options.enableSdh },
+    ...options.onUploadProgress !== void 0 && { onUploadProgress: options.onUploadProgress }
+  };
+  const fileSize = getFileSize(options.file);
+  let jobId;
+  if (fileSize !== null && fileSize >= multipartThreshold && typeof options.file !== "string") {
+    const result = await client.files.uploadMultipart(options.file, {
+      ...uploadOptions,
+      concurrency: 4
+    });
+    jobId = result.jobId;
+  } else {
+    const result = await client.files.upload(options.file, uploadOptions);
+    jobId = result.jobId;
+  }
+  const poller = new JobPoller(jobId, client.jobs, options.pollOptions);
+  const progressCallback = options.onProgress;
+  if (progressCallback) {
+    poller.on("progress", ({ step, progress }) => {
+      progressCallback(step, progress);
+    });
+  }
+  return poller.start();
+}
+function getFileSize(file) {
+  if (file instanceof Blob) return file.size;
+  if (Buffer.isBuffer(file)) return file.length;
+  return null;
+}
+
+// src/client.ts
+var AudiolizeClient = class {
+  http;
+  jobs;
+  languages;
+  subtitles;
+  files;
+  constructor(options) {
+    if (!options.apiKey) {
+      throw new Error("API key is required");
+    }
+    const httpOptions = {
+      apiKey: options.apiKey,
+      baseUrl: options.baseUrl || "https://api.audialize.com/v1"
+    };
+    if (options.timeout !== void 0) httpOptions.timeout = options.timeout;
+    if (options.maxRetries !== void 0) httpOptions.maxRetries = options.maxRetries;
+    this.http = new HttpClient(httpOptions);
+    this.jobs = new JobsResource(this.http);
+    this.languages = new LanguagesResource(this.http);
+    this.subtitles = new SubtitlesResource(this.http);
+    this.files = new FilesResource(this.http);
+  }
+  /**
+   * High-level workflow to upload a file, create a job, and poll until completion.
+   * @param options LocalizeOptions
+   * @returns Promise<Job>
+   */
+  async localize(options) {
+    return localize(this, options);
+  }
+};
+
+exports.AudiolizeApiError = AudiolizeApiError;
+exports.AudiolizeClient = AudiolizeClient;
+exports.AudiolizeError = AudiolizeError;
+exports.AudiolizeTimeoutError = AudiolizeTimeoutError;
+exports.AudiolizeUploadError = AudiolizeUploadError;
+exports.AudiolizeValidationError = AudiolizeValidationError;
+exports.AuthenticationError = AuthenticationError;
+exports.AuthorizationError = AuthorizationError;
+exports.DEFAULT_MULTIPART_THRESHOLD = DEFAULT_MULTIPART_THRESHOLD;
+exports.FilesResource = FilesResource;
+exports.JobPoller = JobPoller;
+exports.JobsResource = JobsResource;
+exports.LanguagesResource = LanguagesResource;
+exports.NotFoundError = NotFoundError;
+exports.PaywallError = PaywallError;
+exports.RateLimitError = RateLimitError;
+exports.ServerError = ServerError;
+exports.SubtitlesResource = SubtitlesResource;
+exports.getBackoffDelay = getBackoffDelay;
+exports.localize = localize;
+exports.withRetry = withRetry;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map