@aviaryhq/cloudglue-js 0.3.1 → 0.3.3

package/dist/src/client.js

@@ -1,6 +1,40 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CloudGlue = exports.CloudGlueError = void 0;
+exports.convertFileToBase64 = convertFileToBase64;
 const Files_1 = require("../generated/Files");
 const Collections_1 = require("../generated/Collections");
 const Chat_1 = require("../generated/Chat");
@@ -10,6 +44,11 @@ const Segmentations_1 = require("../generated/Segmentations");
 const Search_1 = require("../generated/Search");
 const Describe_1 = require("../generated/Describe");
 const Segments_1 = require("../generated/Segments");
+const Webhooks_1 = require("../generated/Webhooks");
+const Frames_1 = require("../generated/Frames");
+const Face_Detection_1 = require("../generated/Face_Detection");
+const Face_Match_1 = require("../generated/Face_Match");
+const fs = __importStar(require("fs"));
 class CloudGlueError extends Error {
     constructor(message, statusCode, data, headers, responseData) {
         super(message);
@@ -17,9 +56,43 @@ class CloudGlueError extends Error {
         this.data = data;
         this.headers = headers;
         this.responseData = responseData;
+        this.name = "CloudGlueError";
     }
 }
 exports.CloudGlueError = CloudGlueError;
+/**
+ * Helper function to convert a local file path to base64 encoded string
+ * Only supports JPG and PNG image formats
+ * @param filePath - Path to the local image file (must be .jpg, .jpeg, or .png)
+ * @returns Promise<string> - Base64 encoded string with data URL prefix
+ */
+async function convertFileToBase64(filePath) {
+    try {
+        const fileBuffer = await fs.promises.readFile(filePath);
+        const base64String = fileBuffer.toString('base64');
+        // Determine MIME type based on file extension (only JPG and PNG supported)
+        const extension = filePath.toLowerCase().split('.').pop();
+        let mimeType;
+        switch (extension) {
+            case 'png':
+                mimeType = 'image/png';
+                break;
+            case 'jpg':
+            case 'jpeg':
+                mimeType = 'image/jpeg';
+                break;
+            default:
+                throw new CloudGlueError(`Unsupported file format: ${extension}. Only JPG and PNG files are supported.`);
+        }
+        return `data:${mimeType};base64,${base64String}`;
+    }
+    catch (error) {
+        if (error instanceof CloudGlueError) {
+            throw error;
+        }
+        throw new CloudGlueError(`Failed to read file at path "${filePath}": ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
 // Enhanced API client classes
 class EnhancedFilesApi {
     constructor(api) {
@@ -61,7 +134,7 @@ class EnhancedFilesApi {
             formData.append("enable_segment_thumbnails", params.enable_segment_thumbnails.toString());
         }
         // Use axios directly to bypass Zodios validation
-        return this.api.axios({
+        const response = await this.api.axios({
             method: "post",
             url: "/files",
             data: formData,
@@ -69,6 +142,7 @@ class EnhancedFilesApi {
                 "Content-Type": "multipart/form-data",
             },
         });
+        return response.data;
     }
     async getFile(fileId) {
         return this.api.getFile({ params: { file_id: fileId } });
@@ -109,6 +183,11 @@ class EnhancedFilesApi {
             body: params,
         });
     }
+    async createFileFrameExtraction(fileId, params) {
+        return this.api.createFileFrameExtraction(params, {
+            params: { file_id: fileId }
+        });
+    }
     /**
      * Waits for a file to finish processing by polling the getFile endpoint until the file
      * reaches a terminal state (completed, failed, or not_applicable) or until maxAttempts is reached.
@@ -155,6 +234,9 @@ class EnhancedCollectionsApi {
     async deleteCollection(collectionId) {
         return this.api.deleteCollection(undefined, { params: { collection_id: collectionId } });
     }
+    async updateCollection(collectionId, params) {
+        return this.api.updateCollection(params, { params: { collection_id: collectionId } });
+    }
     async addVideoByUrl({ collectionId, url, params }) {
         return this.api.addVideo({ url, ...params }, { params: { collection_id: collectionId, ...params } });
     }
@@ -175,9 +257,10 @@ class EnhancedCollectionsApi {
     async deleteVideo(collectionId, fileId) {
         return this.api.deleteVideo(undefined, { params: { collection_id: collectionId, file_id: fileId } });
     }
-    async getEntities(collectionId, fileId) {
+    async getEntities(collectionId, fileId, params = {}) {
         return this.api.getEntities({
-            params: { collection_id: collectionId, file_id: fileId }
+            params: { collection_id: collectionId, file_id: fileId },
+            queries: params
         });
     }
     async getTranscripts(collectionId, fileId, limit, offset, response_format) {
@@ -440,6 +523,9 @@ class EnhancedSegmentsApi {
     async createSegmentJob(params) {
         return this.api.createSegments(params);
     }
+    async deleteSegmentJob(jobId) {
+        return this.api.deleteSegments(undefined, { params: { job_id: jobId } });
+    }
     async waitForReady(jobId, options = {}) {
         const { pollingInterval = 5000, maxAttempts = 36, } = options;
         let attempts = 0;
@@ -459,6 +545,136 @@ class EnhancedSegmentsApi {
         throw new CloudGlueError(`Timeout waiting for segment job ${jobId} to process after ${maxAttempts} attempts`);
     }
 }
+class EnhancedWebhooksApi {
+    constructor(api) {
+        this.api = api;
+    }
+    async listWebhooks(params = {}) {
+        return this.api.listWebhooks({ queries: params });
+    }
+    async getWebhook(webhookId) {
+        return this.api.getWebhookById({ params: { webhook_id: webhookId } });
+    }
+    async createWebhook(params) {
+        return this.api.createWebhook(params);
+    }
+    async updateWebhook(webhookId, params) {
+        return this.api.updateWebhook(params, { params: { webhook_id: webhookId, } });
+    }
+    async deleteWebhook(webhookId) {
+        return this.api.deleteWebhook(undefined, { params: { webhook_id: webhookId } });
+    }
+}
+class EnhancedFramesApi {
+    constructor(api) {
+        this.api = api;
+    }
+    async getFrameExtraction(frameExtractionId, params = {}) {
+        return this.api.getFrameExtraction({
+            params: { frame_extraction_id: frameExtractionId },
+            queries: params
+        });
+    }
+    async deleteFrameExtraction(frameExtractionId) {
+        return this.api.deleteFrameExtraction(undefined, { params: { frame_extraction_id: frameExtractionId } });
+    }
+    async waitForReady(frameExtractionId, options = {}) {
+        const { pollingInterval = 5000, maxAttempts = 36 } = options;
+        let attempts = 0;
+        while (attempts < maxAttempts) {
+            const job = await this.getFrameExtraction(frameExtractionId);
+            if (["completed", "failed"].includes(job.status)) {
+                if (job.status === "failed") {
+                    throw new CloudGlueError(`Frame extraction job failed: ${frameExtractionId}`);
+                }
+                return job;
+            }
+            await new Promise(resolve => setTimeout(resolve, pollingInterval));
+            attempts++;
+        }
+        throw new CloudGlueError(`Frame extraction job did not complete within ${maxAttempts * pollingInterval / 1000} seconds: ${frameExtractionId}`);
+    }
+}
+class EnhancedFaceDetectionApi {
+    constructor(api) {
+        this.api = api;
+    }
+    async createFaceDetection(params) {
+        return this.api.createFaceDetection(params);
+    }
+    async getFaceDetection(faceDetectionId, params = {}) {
+        const { limit, offset } = params;
+        return this.api.getFaceDetection({
+            params: { face_detection_id: faceDetectionId },
+            queries: { limit, offset }
+        });
+    }
+    async deleteFaceDetection(faceDetectionId) {
+        return this.api.deleteFaceDetection(undefined, { params: { face_detection_id: faceDetectionId } });
+    }
+    async waitForReady(faceDetectionId, options = {}) {
+        const { pollingInterval = 5000, maxAttempts = 36 } = options;
+        let attempts = 0;
+        while (attempts < maxAttempts) {
+            const job = await this.getFaceDetection(faceDetectionId);
+            if (["completed", "failed"].includes(job.status)) {
+                if (job.status === "failed") {
+                    throw new CloudGlueError(`Face detection job failed: ${faceDetectionId}`);
+                }
+                return job;
+            }
+            await new Promise(resolve => setTimeout(resolve, pollingInterval));
+            attempts++;
+        }
+        throw new CloudGlueError(`Face detection job did not complete within ${maxAttempts * pollingInterval / 1000} seconds: ${faceDetectionId}`);
+    }
+}
+class EnhancedFaceMatchApi {
+    constructor(api) {
+        this.api = api;
+    }
+    async createFaceMatch(params) {
+        // Handle local file path by converting to base64
+        if (params.source_image.file_path) {
+            const base64Image = await convertFileToBase64(params.source_image.file_path);
+            const { file_path, ...restSourceImage } = params.source_image;
+            return this.api.createFaceMatch({
+                ...params,
+                source_image: {
+                    ...restSourceImage,
+                    base64_image: base64Image
+                }
+            });
+        }
+        return this.api.createFaceMatch(params);
+    }
+    async getFaceMatch(faceMatchId, params = {}) {
+        const { limit, offset } = params;
+        return this.api.getFaceMatch({
+            params: { face_match_id: faceMatchId },
+            queries: { limit, offset }
+        });
+    }
+    async deleteFaceMatch(faceMatchId) {
+        return this.api.deleteFaceMatch(undefined, { params: { face_match_id: faceMatchId } });
+    }
+    async waitForReady(faceMatchId, options = {}) {
+        const { pollingInterval = 5000, maxAttempts = 36 } = options;
+        let attempts = 0;
+        while (attempts < maxAttempts) {
+            const job = await this.getFaceMatch(faceMatchId);
+            if (["completed", "failed"].includes(job.status)) {
+                if (job.status === "failed") {
+                    throw new CloudGlueError(`Face match job failed: ${faceMatchId}`);
+                }
+                return job;
+            }
+            await new Promise(resolve => setTimeout(resolve, pollingInterval));
+            attempts++;
+        }
+        throw new CloudGlueError(`Face match job did not complete within ${maxAttempts * pollingInterval / 1000} seconds: ${faceMatchId}`);
+    }
+}
 /**
  * Main CloudGlue client class that provides access to all API functionality
  * through enhanced, user-friendly interfaces
@@ -475,7 +691,7 @@ class CloudGlue {
             headers: {
                 Authorization: `Bearer ${this.apiKey}`,
                 'x-sdk-client': 'cloudglue-js',
-                'x-sdk-version': '0.3.1',
+                'x-sdk-version': '0.3.3',
             },
             baseURL: this.baseUrl,
             timeout: this.timeout,
@@ -496,8 +712,12 @@ class CloudGlue {
         const searchApi = (0, Search_1.createApiClient)(this.baseUrl, sharedConfig);
         const describeApi = (0, Describe_1.createApiClient)(this.baseUrl, sharedConfig);
         const segmentsApi = (0, Segments_1.createApiClient)(this.baseUrl, sharedConfig);
+        const framesApi = (0, Frames_1.createApiClient)(this.baseUrl, sharedConfig);
+        const faceDetectionApi = (0, Face_Detection_1.createApiClient)(this.baseUrl, sharedConfig);
+        const faceMatchApi = (0, Face_Match_1.createApiClient)(this.baseUrl, sharedConfig);
+        const webhooksApi = (0, Webhooks_1.createApiClient)(this.baseUrl, sharedConfig);
         // Configure base URL and axios config for all clients
-        [filesApi, collectionsApi, chatApi, transcribeApi, extractApi, segmentationsApi, searchApi, describeApi, segmentsApi].forEach((client) => {
+        [filesApi, collectionsApi, chatApi, transcribeApi, extractApi, segmentationsApi, searchApi, describeApi, segmentsApi, framesApi, faceDetectionApi, faceMatchApi, webhooksApi].forEach((client) => {
             Object.assign(client.axios.defaults, axiosConfig);
             client.axios.interceptors.response.use((response) => {
                 return response;
@@ -522,6 +742,10 @@ class CloudGlue {
         this.search = new EnhancedSearchApi(searchApi);
         this.describe = new EnhancedDescribeApi(describeApi);
         this.segments = new EnhancedSegmentsApi(segmentsApi);
+        this.frames = new EnhancedFramesApi(framesApi);
+        this.faceDetection = new EnhancedFaceDetectionApi(faceDetectionApi);
+        this.faceMatch = new EnhancedFaceMatchApi(faceMatchApi);
+        this.webhooks = new EnhancedWebhooksApi(webhooksApi);
     }
 }
 exports.CloudGlue = CloudGlue;

package/dist/src/types.d.ts

@@ -7,6 +7,10 @@ import { schemas as searchSchemas } from '../generated/Search';
 import { schemas as describeSchemas } from '../generated/Describe';
 import { schemas as segmentsSchemas } from '../generated/Segments';
 import { SegmentationUniformConfig as SegmentationUniformConfigType, SegmentationShotDetectorConfig as SegmentationShotDetectorConfigType, SegmentationConfig as SegmentationConfigType } from '../generated/common';
+import { schemas as webhooksSchemas } from '../generated/Webhooks';
+import { FrameExtraction } from '../generated/common';
+import { schemas as faceDetectionSchemas } from '../generated/Face_Detection';
+import { schemas as faceMatchSchemas } from '../generated/Face_Match';
 /**
  * Represents a video file in the Cloudglue system
  * Contains metadata about the file including its status, size, and video information
@@ -148,3 +152,48 @@ export type CollectionMediaDescription = z.infer<typeof collectionsSchemas.Media
 export type CollectionMediaDescriptionsList = z.infer<typeof collectionsSchemas.CollectionMediaDescriptionsList>;
 export type NarrativeConfig = z.infer<typeof segmentsSchemas.NarrativeConfig>;
 export type ShotConfig = z.infer<typeof segmentsSchemas.ShotConfig>;
+export type WebhookEvents = z.infer<typeof webhooksSchemas['WebhookEvents']>;
+/**
+ * Represents a frame extraction job
+ */
+export type { FrameExtraction };
+/**
+ * Configuration for frame extraction
+ */
+export type { FrameExtractionConfig, FrameExtractionUniformConfig, FrameExtractionThumbnailsConfig } from '../generated/common';
+/**
+ * Represents a face detection job
+ */
+export type FaceDetection = z.infer<typeof faceDetectionSchemas.FaceDetection>;
+/**
+ * Represents a face detection request
+ */
+export type FaceDetectionRequest = z.infer<typeof faceDetectionSchemas.FaceDetectionRequest>;
+/**
+ * Represents a detected face
+ */
+export type DetectedFace = z.infer<typeof faceDetectionSchemas.DetectedFace>;
+/**
+ * Represents a face match job
+ */
+export type FaceMatch = z.infer<typeof faceMatchSchemas.FaceMatch>;
+/**
+ * Represents a face match request
+ */
+export type FaceMatchRequest = z.infer<typeof faceMatchSchemas.FaceMatchRequest>;
+/**
+ * Represents a face match result
+ */
+export type FaceMatchResult = z.infer<typeof faceMatchSchemas.FaceMatchResult>;
+/**
+ * Represents a source image for face matching
+ */
+export type SourceImage = z.infer<typeof faceMatchSchemas.SourceImage>;
+/**
+ * Enhanced source image type that supports local file paths
+ */
+export type EnhancedSourceImage = {
+    url?: string;
+    base64_image?: string;
+    file_path?: string;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aviaryhq/cloudglue-js",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "Cloudglue API client for Node.js",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",