@renderingvideo/sdk 1.0.0

package/dist/index.cjs

@@ -0,0 +1,612 @@
+"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, {
+  AlreadyRenderingError: () => AlreadyRenderingError,
+  AuthenticationError: () => AuthenticationError,
+  CreditsClient: () => CreditsClient,
+  FileClient: () => FileClient,
+  InsufficientCreditsError: () => InsufficientCreditsError,
+  InvalidApiKeyError: () => InvalidApiKeyError,
+  NotFoundError: () => NotFoundError,
+  PreviewClient: () => PreviewClient,
+  RateLimitError: () => RateLimitError,
+  RemoteError: () => RemoteError,
+  RenderingVideo: () => RenderingVideo,
+  RenderingVideoError: () => RenderingVideoError,
+  StorageLimitError: () => StorageLimitError,
+  UploadError: () => UploadError,
+  ValidationError: () => ValidationError,
+  VideoClient: () => VideoClient,
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var RenderingVideoError = class extends Error {
+  code;
+  details;
+  constructor(message, code, details = {}) {
+    super(message);
+    this.name = "RenderingVideoError";
+    this.code = code;
+    this.details = details;
+  }
+};
+var AuthenticationError = class extends RenderingVideoError {
+  constructor(message, details = {}) {
+    super(message, "AUTHENTICATION_ERROR", details);
+    this.name = "AuthenticationError";
+  }
+};
+var InvalidApiKeyError = class extends RenderingVideoError {
+  constructor(message, details = {}) {
+    super(message, "INVALID_API_KEY", details);
+    this.name = "InvalidApiKeyError";
+  }
+};
+var InsufficientCreditsError = class extends RenderingVideoError {
+  constructor(message, details = {}) {
+    super(message, "INSUFFICIENT_CREDITS", details);
+    this.name = "InsufficientCreditsError";
+  }
+};
+var ValidationError = class extends RenderingVideoError {
+  constructor(message, details = {}) {
+    super(message, "VALIDATION_ERROR", details);
+    this.name = "ValidationError";
+  }
+};
+var NotFoundError = class extends RenderingVideoError {
+  constructor(message, details = {}) {
+    super(message, "NOT_FOUND", details);
+    this.name = "NotFoundError";
+  }
+};
+var RateLimitError = class extends RenderingVideoError {
+  constructor(message, details = {}) {
+    super(message, "RATE_LIMITED", details);
+    this.name = "RateLimitError";
+  }
+};
+var AlreadyRenderingError = class extends RenderingVideoError {
+  constructor(message, details = {}) {
+    super(message, "ALREADY_RENDERING", details);
+    this.name = "AlreadyRenderingError";
+  }
+};
+var UploadError = class extends RenderingVideoError {
+  constructor(message, details = {}) {
+    super(message, "UPLOAD_FAILED", details);
+    this.name = "UploadError";
+  }
+};
+var StorageLimitError = class extends RenderingVideoError {
+  constructor(message, details = {}) {
+    super(message, "STORAGE_LIMIT_EXCEEDED", details);
+    this.name = "StorageLimitError";
+  }
+};
+var RemoteError = class extends RenderingVideoError {
+  constructor(message, details = {}) {
+    super(message, "REMOTE_ERROR", details);
+    this.name = "RemoteError";
+  }
+};
+function handleApiError(statusCode, message, code, details = {}) {
+  switch (code) {
+    case "MISSING_API_KEY":
+    case "INVALID_API_KEY":
+    case "INVALID_API_KEY_FORMAT":
+    case "API_KEY_INACTIVE":
+    case "USER_NOT_FOUND":
+      return new AuthenticationError(message, { ...details, code, statusCode });
+    case "INSUFFICIENT_CREDITS":
+      return new InsufficientCreditsError(message, { ...details, code, statusCode });
+    case "INVALID_REQUEST":
+    case "INVALID_CONFIG":
+    case "NO_FILES":
+    case "UNSUPPORTED_FILE_TYPE":
+      return new ValidationError(message, { ...details, code, statusCode });
+    case "NOT_FOUND":
+      return new NotFoundError(message, { ...details, code, statusCode });
+    case "ALREADY_RENDERING":
+      return new AlreadyRenderingError(message, { ...details, code, statusCode });
+    case "STORAGE_LIMIT_EXCEEDED":
+      return new StorageLimitError(message, { ...details, code, statusCode });
+    case "UPLOAD_FAILED":
+      return new UploadError(message, { ...details, code, statusCode });
+    case "REMOTE_ERROR":
+    case "RENDER_TRIGGER_FAILED":
+      return new RemoteError(message, { ...details, code, statusCode });
+  }
+  switch (statusCode) {
+    case 401:
+      return new AuthenticationError(message, { ...details, code, statusCode });
+    case 402:
+      return new InsufficientCreditsError(message, { ...details, code, statusCode });
+    case 400:
+      return new ValidationError(message, { ...details, code, statusCode });
+    case 404:
+      return new NotFoundError(message, { ...details, code, statusCode });
+    case 429:
+      return new RateLimitError(message, { ...details, code, statusCode });
+    default:
+      return new RenderingVideoError(message, code, { ...details, statusCode });
+  }
+}
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://renderingvideo.com";
+var DEFAULT_TIMEOUT = 3e4;
+async function request(baseUrl, apiKey, timeout, method, endpoint, body, params) {
+  const url = new URL(`${baseUrl}${endpoint}`);
+  if (params) {
+    Object.entries(params).forEach(([key, value]) => {
+      if (value !== void 0) {
+        url.searchParams.append(key, String(value));
+      }
+    });
+  }
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+  try {
+    const response = await fetch(url.toString(), {
+      method,
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: body ? JSON.stringify(body) : void 0,
+      signal: controller.signal
+    });
+    const data = await response.json();
+    if (!response.ok) {
+      throw handleApiError(
+        response.status,
+        data.error || "Unknown error",
+        data.code || "UNKNOWN_ERROR",
+        data.details || data
+      );
+    }
+    return data;
+  } catch (error) {
+    if (error instanceof RenderingVideoError) {
+      throw error;
+    }
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new Error(`Request timed out after ${timeout}ms`);
+    }
+    throw error;
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+var VideoClient = class {
+  constructor(baseUrl, apiKey, timeout) {
+    this.baseUrl = baseUrl;
+    this.apiKey = apiKey;
+    this.timeout = timeout;
+  }
+  async request(method, endpoint, body, params) {
+    return request(this.baseUrl, this.apiKey, this.timeout, method, endpoint, body, params);
+  }
+  /**
+   * Create a new video task (does not start rendering)
+   * @example
+   * ```typescript
+   * const task = await client.video.create({
+   *   config: {
+   *     meta: { version: '2.0.0', width: 1920, height: 1080, fps: 30 },
+   *     tracks: [{ clips: [{ type: 'text', text: 'Hello World', start: 0, duration: 5 }] }]
+   *   },
+   *   metadata: { projectId: 'proj_123' }
+   * });
+   * ```
+   */
+  async create(options) {
+    const body = { config: options.config };
+    if (options.metadata) body.metadata = options.metadata;
+    return this.request("POST", "/api/v1/video", body);
+  }
+  /**
+   * List video tasks
+   * @example
+   * ```typescript
+   * const { tasks, pagination } = await client.video.list({ page: 1, limit: 20, status: 'completed' });
+   * ```
+   */
+  async list(options) {
+    return this.request("GET", "/api/v1/video", void 0, {
+      page: options?.page,
+      limit: options?.limit,
+      status: options?.status
+    });
+  }
+  /**
+   * Get task details by ID
+   * @example
+   * ```typescript
+   * const task = await client.video.get('abc123def456');
+   * console.log(task.status, task.videoUrl);
+   * ```
+   */
+  async get(taskId) {
+    return this.request("GET", `/api/v1/video/${taskId}`);
+  }
+  /**
+   * Delete a video task permanently
+   * @example
+   * ```typescript
+   * const result = await client.video.delete('abc123def456');
+   * console.log(result.deleted, result.remoteDeleted);
+   * ```
+   */
+  async delete(taskId) {
+    return this.request("DELETE", `/api/v1/video/${taskId}`);
+  }
+  /**
+   * Trigger rendering for a task
+   * @example
+   * ```typescript
+   * const result = await client.video.render('abc123def456', {
+   *   webhookUrl: 'https://example.com/webhook',
+   *   numWorkers: 5
+   * });
+   * ```
+   */
+  async render(taskId, options) {
+    const body = {};
+    if (options?.webhookUrl) body.webhook_url = options.webhookUrl;
+    if (options?.numWorkers) body.num_workers = options.numWorkers;
+    return this.request("POST", `/api/v1/video/${taskId}/render`, body);
+  }
+  /**
+   * Create task and immediately start rendering (convenience method)
+   * @example
+   * ```typescript
+   * const task = await client.video.createAndRender({
+   *   config: { ... },
+   *   webhookUrl: 'https://example.com/webhook'
+   * });
+   * ```
+   */
+  async createAndRender(options) {
+    const task = await this.create(options);
+    return this.render(task.taskId, { webhookUrl: options.webhookUrl, numWorkers: options.numWorkers });
+  }
+};
+var FileClient = class {
+  constructor(baseUrl, apiKey, timeout) {
+    this.baseUrl = baseUrl;
+    this.apiKey = apiKey;
+    this.timeout = timeout;
+  }
+  async request(method, endpoint, body, params) {
+    return request(this.baseUrl, this.apiKey, this.timeout, method, endpoint, body, params);
+  }
+  /**
+   * Upload files (images, videos, audio)
+   * @example
+   * ```typescript
+   * // In Node.js with FormData
+   * const formData = new FormData();
+   * formData.append('file', fileBlob, 'image.png');
+   * const result = await client.files.upload(formData);
+   *
+   * // Multiple files
+   * formData.append('files', file1Blob, 'video.mp4');
+   * formData.append('files', file2Blob, 'audio.mp3');
+   * const result = await client.files.upload(formData);
+   * ```
+   */
+  async upload(formData) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(`${this.baseUrl}/api/v1/upload`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${this.apiKey}`
+        },
+        body: formData,
+        signal: controller.signal
+      });
+      const data = await response.json();
+      if (!response.ok) {
+        throw handleApiError(
+          response.status,
+          data.error || "Unknown error",
+          data.code || "UNKNOWN_ERROR",
+          data.details || data
+        );
+      }
+      return data;
+    } catch (error) {
+      if (error instanceof RenderingVideoError) {
+        throw error;
+      }
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new Error(`Upload timed out after ${this.timeout}ms`);
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * Upload a single file from buffer (Node.js)
+   * @example
+   * ```typescript
+   * const buffer = fs.readFileSync('./image.png');
+   * const result = await client.files.uploadBuffer(buffer, 'image.png', 'image/png');
+   * ```
+   */
+  async uploadBuffer(buffer, filename, mimeType) {
+    const formData = new FormData();
+    const blob = new Blob([buffer], { type: mimeType });
+    formData.append("file", blob, filename);
+    return this.upload(formData);
+  }
+  /**
+   * Upload a single file from Blob/File
+   * @example
+   * ```typescript
+   * const blob = new Blob([data], { type: 'image/png' });
+   * const result = await client.files.uploadFile(blob, 'image.png');
+   * ```
+   */
+  async uploadFile(file, filename) {
+    const formData = new FormData();
+    formData.append("file", file, filename || (file instanceof File ? file.name : "file"));
+    return this.upload(formData);
+  }
+  /**
+   * List uploaded files
+   * @example
+   * ```typescript
+   * const { files, pagination } = await client.files.list({ type: 'image', limit: 50 });
+   * ```
+   */
+  async list(options) {
+    return this.request("GET", "/api/v1/files", void 0, {
+      page: options?.page,
+      limit: options?.limit,
+      type: options?.type
+    });
+  }
+  /**
+   * Delete a file
+   * @example
+   * ```typescript
+   * const result = await client.files.delete('asset_001');
+   * ```
+   */
+  async delete(fileId) {
+    return this.request("DELETE", `/api/v1/files/${fileId}`);
+  }
+  /**
+   * Get file by ID (convenience method - searches through list)
+   * @example
+   * ```typescript
+   * const file = await client.files.get('asset_001');
+   * ```
+   */
+  async get(fileId) {
+    const { files } = await this.list({ limit: 100 });
+    return files.find((f) => f.id === fileId) || null;
+  }
+};
+var PreviewClient = class {
+  constructor(baseUrl, apiKey, timeout) {
+    this.baseUrl = baseUrl;
+    this.apiKey = apiKey;
+    this.timeout = timeout;
+  }
+  async request(method, endpoint, body, params) {
+    return request(this.baseUrl, this.apiKey, this.timeout, method, endpoint, body, params);
+  }
+  /**
+   * Create a temporary preview link (7 days validity, no credits consumed)
+   * @example
+   * ```typescript
+   * const preview = await client.preview.create({
+   *   meta: { version: '2.0.0', width: 1920, height: 1080 },
+   *   tracks: [{ clips: [{ type: 'text', text: 'Preview', start: 0, duration: 5 }] }]
+   * });
+   * console.log(preview.previewUrl, preview.tempId);
+   * ```
+   */
+  async create(config) {
+    return this.request("POST", "/api/v1/preview", { config });
+  }
+  /**
+   * Get preview configuration
+   * @example
+   * ```typescript
+   * const { config } = await client.preview.get('temp_abc123');
+   * ```
+   */
+  async get(tempId) {
+    return this.request("GET", `/api/v1/preview/${tempId}`);
+  }
+  /**
+   * Delete a preview link
+   * @example
+   * ```typescript
+   * const result = await client.preview.delete('temp_abc123');
+   * ```
+   */
+  async delete(tempId) {
+    return this.request("DELETE", `/api/v1/preview/${tempId}`);
+  }
+  /**
+   * Convert preview to permanent task (does not start rendering)
+   * @example
+   * ```typescript
+   * const result = await client.preview.convert('temp_abc123', { category: 'marketing' });
+   * console.log(result.taskId);
+   * ```
+   */
+  async convert(tempId, options) {
+    const body = {};
+    if (options?.category) body.category = options.category;
+    return this.request("POST", `/api/v1/preview/${tempId}/convert`, body);
+  }
+  /**
+   * Convert preview to permanent task and immediately start rendering
+   * @example
+   * ```typescript
+   * const result = await client.preview.render('temp_abc123', {
+   *   webhookUrl: 'https://example.com/webhook'
+   * });
+   * console.log(result.taskId, result.status);
+   * ```
+   */
+  async render(tempId, options) {
+    const body = {};
+    if (options?.category) body.category = options.category;
+    if (options?.webhookUrl) body.webhook_url = options.webhookUrl;
+    if (options?.numWorkers) body.num_workers = options.numWorkers;
+    return this.request("POST", `/api/v1/preview/${tempId}/render`, body);
+  }
+};
+var RenderingVideo = class {
+  apiKey;
+  baseUrl;
+  timeout;
+  _video = null;
+  _files = null;
+  _preview = null;
+  constructor(apiKeyOrOptions, options) {
+    if (typeof apiKeyOrOptions === "string") {
+      this.apiKey = apiKeyOrOptions;
+      this.baseUrl = options?.baseUrl ?? DEFAULT_BASE_URL;
+      this.timeout = options?.timeout ?? DEFAULT_TIMEOUT;
+    } else {
+      this.apiKey = apiKeyOrOptions.apiKey;
+      this.baseUrl = apiKeyOrOptions.baseUrl ?? DEFAULT_BASE_URL;
+      this.timeout = apiKeyOrOptions.timeout ?? DEFAULT_TIMEOUT;
+    }
+    if (!this.apiKey) {
+      throw new Error("API key is required");
+    }
+    if (!this.apiKey.startsWith("sk-")) {
+      throw new Error('Invalid API key. API key should start with "sk-"');
+    }
+  }
+  /**
+   * Video API operations
+   */
+  get video() {
+    if (!this._video) {
+      this._video = new VideoClient(this.baseUrl, this.apiKey, this.timeout);
+    }
+    return this._video;
+  }
+  /**
+   * File API operations (upload, list, delete)
+   */
+  get files() {
+    if (!this._files) {
+      this._files = new FileClient(this.baseUrl, this.apiKey, this.timeout);
+    }
+    return this._files;
+  }
+  /**
+   * Preview API operations
+   */
+  get preview() {
+    if (!this._preview) {
+      this._preview = new PreviewClient(this.baseUrl, this.apiKey, this.timeout);
+    }
+    return this._preview;
+  }
+  /**
+   * Credits API operations
+   */
+  get credits() {
+    return new CreditsClient(this.baseUrl, this.apiKey, this.timeout);
+  }
+  /**
+   * Get masked API key for logging
+   */
+  get apiKeyPreview() {
+    return this.apiKey.length > 12 ? `${this.apiKey.slice(0, 8)}...${this.apiKey.slice(-4)}` : "***";
+  }
+  /**
+   * Get the base URL being used
+   */
+  get baseURL() {
+    return this.baseUrl;
+  }
+};
+var CreditsClient = class {
+  constructor(baseUrl, apiKey, timeout) {
+    this.baseUrl = baseUrl;
+    this.apiKey = apiKey;
+    this.timeout = timeout;
+  }
+  /**
+   * Get current credit balance
+   * @example
+   * ```typescript
+   * const { credits } = await client.credits.get();
+   * console.log(`You have ${credits} credits remaining`);
+   * ```
+   */
+  async get() {
+    return request(this.baseUrl, this.apiKey, this.timeout, "GET", "/api/v1/credits");
+  }
+  /**
+   * Check if user has enough credits for a render
+   * @example
+   * ```typescript
+   * const hasCredits = await client.credits.hasEnough(100);
+   * ```
+   */
+  async hasEnough(required) {
+    const { credits } = await this.get();
+    return credits >= required;
+  }
+};
+
+// src/index.ts
+var index_default = RenderingVideo;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AlreadyRenderingError,
+  AuthenticationError,
+  CreditsClient,
+  FileClient,
+  InsufficientCreditsError,
+  InvalidApiKeyError,
+  NotFoundError,
+  PreviewClient,
+  RateLimitError,
+  RemoteError,
+  RenderingVideo,
+  RenderingVideoError,
+  StorageLimitError,
+  UploadError,
+  ValidationError,
+  VideoClient
+});