@stack0/sdk 0.5.7 → 0.5.9

package/dist/cdn/index.js

@@ -182,6 +182,27 @@ var CDN = class {
     }
     return this.confirmUpload(assetId);
   }
+  /**
+   * Upload a file from a remote URL (server-side fetch).
+   * The server streams the file directly from the source URL into storage,
+   * so the client never touches the bytes. Ideal for serverless environments
+   * with tight memory limits.
+   *
+   * @example
+   * ```typescript
+   * const asset = await cdn.uploadFromUrl({
+   *   projectSlug: 'my-project',
+   *   sourceUrl: 'https://replicate.delivery/output/video.mp4',
+   *   filename: 'video.mp4',
+   *   mimeType: 'video/mp4',
+   * });
+   * console.log(asset.cdnUrl);
+   * ```
+   */
+  async uploadFromUrl(request) {
+    const response = await this.http.post("/cdn/upload-from-url", request);
+    return this.convertAssetDates(response);
+  }
   /**
    * Get an asset by ID
    *
@@ -558,6 +579,80 @@ var CDN = class {
   async extractAudio(request) {
     return this.http.post("/cdn/video/extract-audio", request);
   }
+  // ============================================================================
+  // GIF Generation Methods
+  // ============================================================================
+  /**
+   * Generate an animated GIF from a video segment
+   *
+   * Creates an optimized GIF from a portion of the video. Uses two-pass
+   * palette generation by default for smaller file sizes with better quality.
+   *
+   * @example
+   * ```typescript
+   * const gif = await cdn.generateGif({
+   *   projectSlug: 'my-project',
+   *   assetId: 'video-asset-id',
+   *   startTime: 5,      // Start at 5 seconds
+   *   duration: 3,       // 3 second GIF
+   *   width: 480,        // 480px wide
+   *   fps: 10,           // 10 frames per second
+   * });
+   *
+   * // Poll for completion
+   * let result = await cdn.getGif(gif.id);
+   * while (result?.status === 'pending' || result?.status === 'processing') {
+   *   await new Promise(r => setTimeout(r, 1000));
+   *   result = await cdn.getGif(gif.id);
+   * }
+   *
+   * console.log(`GIF URL: ${result?.url}`);
+   * ```
+   */
+  async generateGif(request) {
+    const response = await this.http.post("/cdn/video/gif", request);
+    return this.convertGifDates(response);
+  }
+  /**
+   * Get a specific GIF by ID
+   *
+   * @example
+   * ```typescript
+   * const gif = await cdn.getGif('gif-id');
+   * if (gif?.status === 'completed') {
+   *   console.log(`GIF URL: ${gif.url}`);
+   *   console.log(`Size: ${gif.sizeBytes} bytes`);
+   * }
+   * ```
+   */
+  async getGif(gifId) {
+    const response = await this.http.get(`/cdn/video/gif/${gifId}`);
+    return response ? this.convertGifDates(response) : null;
+  }
+  /**
+   * List all GIFs generated for a video asset
+   *
+   * @example
+   * ```typescript
+   * const gifs = await cdn.listGifs({ assetId: 'video-asset-id' });
+   * for (const gif of gifs) {
+   *   console.log(`GIF at ${gif.startTime}s: ${gif.url}`);
+   * }
+   * ```
+   */
+  async listGifs(request) {
+    const response = await this.http.get(`/cdn/video/${request.assetId}/gifs`);
+    return response.map((gif) => this.convertGifDates(gif));
+  }
+  convertGifDates(gif) {
+    if (typeof gif.createdAt === "string") {
+      gif.createdAt = new Date(gif.createdAt);
+    }
+    if (gif.completedAt && typeof gif.completedAt === "string") {
+      gif.completedAt = new Date(gif.completedAt);
+    }
+    return gif;
+  }
   convertJobDates(job) {
     if (typeof job.createdAt === "string") {
       job.createdAt = new Date(job.createdAt);
@@ -1160,6 +1255,204 @@ var CDN = class {
   convertMergeJobWithOutputDates(job) {
     return this.convertMergeJobDates(job);
   }
+  // ============================================================================
+  // S3 Import Methods
+  // ============================================================================
+  /**
+   * Create an S3 import job to bulk import files from an external S3 bucket.
+   * Requires Pro plan or higher.
+   *
+   * @example
+   * ```typescript
+   * // Using IAM credentials
+   * const job = await cdn.createImport({
+   *   projectSlug: 'my-project',
+   *   sourceBucket: 'my-external-bucket',
+   *   sourceRegion: 'us-east-1',
+   *   sourcePrefix: 'images/',
+   *   authType: 'iam_credentials',
+   *   accessKeyId: 'AKIA...',
+   *   secretAccessKey: 'secret...',
+   *   pathMode: 'flatten',
+   *   notifyEmail: 'admin@example.com',
+   * });
+   *
+   * // Using role assumption
+   * const job = await cdn.createImport({
+   *   projectSlug: 'my-project',
+   *   sourceBucket: 'partner-bucket',
+   *   sourceRegion: 'eu-west-1',
+   *   authType: 'role_assumption',
+   *   roleArn: 'arn:aws:iam::123456789012:role/Stack0ImportRole',
+   *   externalId: 'optional-external-id',
+   *   pathMode: 'preserve',
+   *   targetFolder: '/imported',
+   * });
+   *
+   * console.log(`Import job started: ${job.importId}`);
+   * ```
+   */
+  async createImport(request) {
+    const response = await this.http.post("/cdn/imports", request);
+    return this.convertCreateImportDates(response);
+  }
+  /**
+   * Get an import job by ID
+   *
+   * @example
+   * ```typescript
+   * const job = await cdn.getImport('import-id');
+   * console.log(`Status: ${job.status}`);
+   * console.log(`Progress: ${job.processedFiles}/${job.totalFiles} files`);
+   * console.log(`Bytes: ${job.processedBytes}/${job.totalBytes}`);
+   * ```
+   */
+  async getImport(importId) {
+    const response = await this.http.get(`/cdn/imports/${importId}`);
+    return response ? this.convertImportJobDates(response) : null;
+  }
+  /**
+   * List import jobs with pagination and filters
+   *
+   * @example
+   * ```typescript
+   * const { imports, total, hasMore } = await cdn.listImports({
+   *   projectSlug: 'my-project',
+   *   status: 'importing',
+   *   limit: 20,
+   * });
+   *
+   * for (const job of imports) {
+   *   console.log(`${job.sourceBucket}: ${job.processedFiles}/${job.totalFiles}`);
+   * }
+   * ```
+   */
+  async listImports(request) {
+    const params = new URLSearchParams();
+    params.set("projectSlug", request.projectSlug);
+    if (request.environment) params.set("environment", request.environment);
+    if (request.status) params.set("status", request.status);
+    if (request.sortBy) params.set("sortBy", request.sortBy);
+    if (request.sortOrder) params.set("sortOrder", request.sortOrder);
+    if (request.limit) params.set("limit", request.limit.toString());
+    if (request.offset) params.set("offset", request.offset.toString());
+    const response = await this.http.get(`/cdn/imports?${params.toString()}`);
+    return {
+      ...response,
+      imports: response.imports.map((job) => this.convertImportJobSummaryDates(job))
+    };
+  }
+  /**
+   * Cancel a running import job
+   *
+   * Files already imported will remain. Only pending/validating/importing jobs can be cancelled.
+   *
+   * @example
+   * ```typescript
+   * const result = await cdn.cancelImport('import-id');
+   * console.log(`Cancelled: ${result.success}`);
+   * ```
+   */
+  async cancelImport(importId) {
+    return this.http.post(`/cdn/imports/${importId}/cancel`, {});
+  }
+  /**
+   * Retry failed files in a completed or failed import job
+   *
+   * This resets failed files to pending and re-queues the import for processing.
+   *
+   * @example
+   * ```typescript
+   * const result = await cdn.retryImport('import-id');
+   * console.log(`Retrying ${result.retriedCount} files`);
+   * ```
+   */
+  async retryImport(importId) {
+    return this.http.post(`/cdn/imports/${importId}/retry`, {});
+  }
+  /**
+   * List files in an import job with optional status filter
+   *
+   * @example
+   * ```typescript
+   * // List all files
+   * const { files, total } = await cdn.listImportFiles({
+   *   importId: 'import-id',
+   *   limit: 100,
+   * });
+   *
+   * // List only failed files
+   * const { files: failedFiles } = await cdn.listImportFiles({
+   *   importId: 'import-id',
+   *   status: 'failed',
+   * });
+   *
+   * for (const file of failedFiles) {
+   *   console.log(`${file.sourceKey}: ${file.errorMessage}`);
+   * }
+   * ```
+   */
+  async listImportFiles(request) {
+    const params = new URLSearchParams();
+    if (request.status) params.set("status", request.status);
+    if (request.sortBy) params.set("sortBy", request.sortBy);
+    if (request.sortOrder) params.set("sortOrder", request.sortOrder);
+    if (request.limit) params.set("limit", request.limit.toString());
+    if (request.offset) params.set("offset", request.offset.toString());
+    const query = params.toString();
+    const response = await this.http.get(
+      `/cdn/imports/${request.importId}/files${query ? `?${query}` : ""}`
+    );
+    return {
+      ...response,
+      files: response.files.map((file) => this.convertImportFileDates(file))
+    };
+  }
+  convertCreateImportDates(response) {
+    if (typeof response.createdAt === "string") {
+      response.createdAt = new Date(response.createdAt);
+    }
+    return response;
+  }
+  convertImportJobDates(job) {
+    if (typeof job.createdAt === "string") {
+      job.createdAt = new Date(job.createdAt);
+    }
+    if (job.updatedAt && typeof job.updatedAt === "string") {
+      job.updatedAt = new Date(job.updatedAt);
+    }
+    if (job.startedAt && typeof job.startedAt === "string") {
+      job.startedAt = new Date(job.startedAt);
+    }
+    if (job.completedAt && typeof job.completedAt === "string") {
+      job.completedAt = new Date(job.completedAt);
+    }
+    return job;
+  }
+  convertImportJobSummaryDates(job) {
+    if (typeof job.createdAt === "string") {
+      job.createdAt = new Date(job.createdAt);
+    }
+    if (job.startedAt && typeof job.startedAt === "string") {
+      job.startedAt = new Date(job.startedAt);
+    }
+    if (job.completedAt && typeof job.completedAt === "string") {
+      job.completedAt = new Date(job.completedAt);
+    }
+    return job;
+  }
+  convertImportFileDates(file) {
+    if (typeof file.createdAt === "string") {
+      file.createdAt = new Date(file.createdAt);
+    }
+    if (file.completedAt && typeof file.completedAt === "string") {
+      file.completedAt = new Date(file.completedAt);
+    }
+    if (file.lastAttemptAt && typeof file.lastAttemptAt === "string") {
+      file.lastAttemptAt = new Date(file.lastAttemptAt);
+    }
+    return file;
+  }
 };
 
 exports.CDN = CDN;