@unboundcx/sdk 2.8.6 → 2.8.8

package/services/storage.js

@@ -213,8 +213,25 @@ export class StorageService {
     formFields,
     endpoint = '/storage/upload',
     method = 'POST',
+    onProgress = null,
+    skipClamscan = false,
   ) {
     const isNode = typeof window === 'undefined';
+
+    // In browser with progress callback: Use XMLHttpRequest
+    if (!isNode && onProgress && typeof onProgress === 'function') {
+      return this._performUploadWithProgress(
+        file,
+        fileName,
+        formFields,
+        endpoint,
+        method,
+        onProgress,
+        skipClamscan,
+      );
+    }
+
+    // Default behavior: Use fetch via sdk._fetch
     let formData, headers;
 
     if (isNode) {
@@ -227,6 +244,15 @@ export class StorageService {
       headers = result.headers;
     }
 
+    if (process?.env?.AUTH_V3_TOKEN_TYPE_OVERRIDE) {
+      headers['x-token-type-override'] =
+        process.env.AUTH_V3_TOKEN_TYPE_OVERRIDE;
+    }
+
+    if (skipClamscan && process?.env?.CLAMSCAN_OVERRIDE_KEY) {
+      headers['x-clamscan-override-key'] = process.env.CLAMSCAN_OVERRIDE_KEY;
+    }
+
     const params = {
       body: formData,
       headers,
@@ -235,6 +261,145 @@ export class StorageService {
     return await this.sdk._fetch(endpoint, method, params, true);
   }
 
+  // Upload with progress tracking using XMLHttpRequest
+  async _performUploadWithProgress(
+    file,
+    fileName,
+    formFields,
+    endpoint,
+    method,
+    onProgress,
+    skipClamscan = false,
+  ) {
+    const { formData } = this._createBrowserFormData(
+      file,
+      fileName,
+      formFields,
+    );
+
+    return new Promise((resolve, reject) => {
+      const xhr = new XMLHttpRequest();
+
+      const startTime = Date.now();
+
+      // Progress tracking
+      xhr.upload.onprogress = (event) => {
+        if (event.lengthComputable) {
+          const percentComplete = (event.loaded / event.total) * 100;
+          const elapsed = (Date.now() - startTime) / 1000; // seconds
+          const speed = event.loaded / elapsed; // bytes per second
+
+          onProgress({
+            loaded: event.loaded,
+            total: event.total,
+            percentage: percentComplete,
+            speed: speed, // bytes/sec
+          });
+        }
+      };
+
+      xhr.onload = () => {
+        if (xhr.status >= 200 && xhr.status < 300) {
+          try {
+            const response = JSON.parse(xhr.responseText);
+            resolve(response);
+          } catch (e) {
+            reject(new Error('Invalid JSON response'));
+          }
+        } else {
+          try {
+            const errorResponse = JSON.parse(xhr.responseText);
+            reject(errorResponse);
+          } catch (e) {
+            reject(new Error(`Upload failed with status ${xhr.status}`));
+          }
+        }
+      };
+
+      xhr.onerror = () => reject(new Error('Network error during upload'));
+      xhr.onabort = () => reject(new Error('Upload aborted'));
+
+      // Build URL with auth headers
+      const url = `${this.sdk.fullUrl}${endpoint}`;
+      xhr.open(method, url, true);
+
+      // IMPORTANT: Include credentials (cookies) for authentication
+      xhr.withCredentials = true;
+
+      // Add auth headers
+      if (this.sdk.token) {
+        xhr.setRequestHeader('Authorization', `Bearer ${this.sdk.token}`);
+      }
+      if (this.sdk.fwRequestId) {
+        xhr.setRequestHeader('x-request-id-fw', this.sdk.fwRequestId);
+      }
+      if (this.sdk.callId) {
+        xhr.setRequestHeader('x-call-id', this.sdk.callId);
+      }
+
+      // Add environment variable override headers
+      if (process?.env?.AUTH_V3_TOKEN_TYPE_OVERRIDE) {
+        xhr.setRequestHeader(
+          'x-token-type-override',
+          process.env.AUTH_V3_TOKEN_TYPE_OVERRIDE,
+        );
+      }
+      if (skipClamscan && process?.env?.CLAMSCAN_OVERRIDE_KEY) {
+        xhr.setRequestHeader(
+          'x-clamscan-override-key',
+          process.env.CLAMSCAN_OVERRIDE_KEY,
+        );
+      }
+
+      xhr.send(formData);
+    });
+  }
+  /*
+
+
+Response:
+{
+    "uploaded": [
+        {
+            "id": "017d0120251229hvdxjod4486582468133095",
+            "fileName": "sip-messages-20251223T195443.txt",
+            "fileSize": 18979,
+            "url": "https://masterc.api.dev-d01.app1svc.com/storage/017d0120251229hvdxjod4486582468133095.txt",
+            "mimeType": "text/plain",
+            "s3Regions": [
+                "d01",
+                "d03"
+            ],
+            "isPublic": false
+        }
+    ],
+    "viruses": [],
+    "errors": []
+}
+
+*/
+  /**
+   * Upload a file to storage with optional format conversion
+   * @param {Object} config - Configuration object
+   * @param {Object} config.file - File content (Buffer or File) - REQUIRED
+   * @param {string} [config.classification='generic'] - File classification (e.g., 'fax', 'files', 'generic')
+   * @param {string} [config.folder] - Folder path for organizing files
+   * @param {string} [config.fileName] - Original file name
+   * @param {boolean} [config.isPublic=false] - Whether file is publicly accessible
+   * @param {string} [config.country='US'] - Country code for region selection
+   * @param {string} [config.expireAfter] - Expiration time
+   * @param {string} [config.relatedId] - Related object ID
+   * @param {boolean} [config.createAccessKey=false] - Generate an access key for the file
+   * @param {number} [config.accessKeyExpiresIn] - Access key expiration in seconds
+   * @param {string} [config.convertTo] - Convert uploaded file to this format before storing. Supported: 'pdf', 'tiff'. Input must be PDF, DOC, or DOCX.
+   * @param {Object} [config.convertOptions] - Options for file conversion (used with convertTo)
+   * @param {('fine'|'normal')} [config.convertOptions.resolution='fine'] - Fax resolution: 'fine' (204x196) or 'normal' (204x98)
+   * @param {('letter'|'a4')} [config.convertOptions.paperSize='letter'] - Paper size for conversion
+   * @param {('g4'|'g3')} [config.convertOptions.compression='g4'] - TIFF compression: 'g4' (default) or 'g3' for older fax machines
+   * @param {Function} [config.onProgress] - Progress callback for browser uploads
+   * @param {Object} [config._options] - Internal options
+   * @returns {Promise<Object>} Upload result with uploaded files, viruses, and errors
+   */
   async upload({
     classification = 'generic',
     folder,
@@ -246,6 +411,10 @@ export class StorageService {
     relatedId,
     createAccessKey = false,
     accessKeyExpiresIn,
+    convertTo,
+    convertOptions,
+    onProgress,
+    _options,
   }) {
     this.sdk.validateParams(
       {
@@ -259,6 +428,8 @@ export class StorageService {
         relatedId,
         createAccessKey,
         accessKeyExpiresIn,
+        convertTo,
+        convertOptions,
       },
       {
         classification: { type: 'string', required: false },
@@ -270,7 +441,9 @@ export class StorageService {
         expireAfter: { type: 'string', required: false },
         relatedId: { type: 'string', required: false },
         createAccessKey: { type: 'boolean', required: false },
-        accessKeyExpiresIn: { type: 'string', required: false },
+        accessKeyExpiresIn: { type: 'number', required: false },
+        convertTo: { type: 'string', required: false },
+        convertOptions: { type: 'object', required: false },
       },
     );
 
@@ -287,12 +460,24 @@ export class StorageService {
       formFields.push(['createAccessKey', createAccessKey.toString()]);
     if (accessKeyExpiresIn)
       formFields.push(['accessKeyExpiresIn', accessKeyExpiresIn]);
+    if (convertTo) formFields.push(['convertTo', convertTo]);
+    if (convertOptions)
+      formFields.push(['convertOptions', JSON.stringify(convertOptions)]);
 
-    return this._performUpload(file, fileName, formFields);
+    return this._performUpload(
+      file,
+      fileName,
+      formFields,
+      '/storage/upload',
+      'POST',
+      onProgress,
+      _options?.skipScan,
+    );
   }
 
   async uploadFiles(files, options = {}) {
-    const { classification, expireAfter, isPublic, metadata } = options;
+    const { classification, expireAfter, isPublic, metadata, _options } =
+      options;
 
     // Validate files parameter
     if (!files) {
@@ -392,6 +577,10 @@ export class StorageService {
       if (metadata) formData.append('metadata', JSON.stringify(metadata));
     }
 
+    if (_options?.skipScan && process?.env?.CLAMSCAN_OVERRIDE_KEY) {
+      headers['x-clamscan-override-key'] = process.env.CLAMSCAN_OVERRIDE_KEY;
+    }
+
     const params = {
       body: formData,
       headers,
@@ -467,13 +656,19 @@ export class StorageService {
     return result;
   }
 
-  async uploadProfileImage({ file, classification = 'user_images', fileName }) {
+  async uploadProfileImage({
+    file,
+    classification = 'user_images',
+    fileName,
+    userId,
+  }) {
     this.sdk.validateParams(
-      { file, classification },
+      { file, classification, userId },
       {
         file: { type: 'object', required: true },
         classification: { type: 'string', required: true },
         fileName: { type: 'string', required: false },
+        userId: { type: 'string', required: false },
       },
     );
 
@@ -488,6 +683,7 @@ export class StorageService {
     // Build form fields exactly like the regular upload but only include classification
     const formFields = [];
     formFields.push(['classification', classification]);
+    formFields.push(['userId', userId]);
 
     // Use the correct profile image endpoint with proper FormData
     return this._performUpload(
@@ -535,12 +731,14 @@ export class StorageService {
   }
 
   async listFiles(options = {}) {
-    const { classification, limit, offset, orderBy, orderDirection } = options;
+    const { classification, folder, limit, offset, orderBy, orderDirection } =
+      options;
 
     // Validate optional parameters
     const validationSchema = {};
     if ('classification' in options)
       validationSchema.classification = { type: 'string' };
+    if ('folder' in options) validationSchema.folder = { type: 'string' };
     if ('limit' in options) validationSchema.limit = { type: 'number' };
     if ('offset' in options) validationSchema.offset = { type: 'number' };
     if ('orderBy' in options) validationSchema.orderBy = { type: 'string' };
@@ -724,6 +922,109 @@ export class StorageService {
     return result;
   }
 
+  /**
+   * Convert an existing stored file to a different format and save it as a new storage record.
+   * The original file remains unchanged. Supported source formats: PDF, DOC, DOCX.
+   * Supported output formats: 'pdf', 'tiff'.
+   *
+   * Fields not provided in the request (classification, folder, relatedId, isPublic)
+   * are inherited from the source file. If expireAfter is not provided, the expireAt
+   * timestamp is copied directly from the source file.
+   *
+   * @param {string} storageId - ID of the existing storage file to convert (required)
+   * @param {Object} config - Conversion options
+   * @param {string} config.convertTo - Target format: 'pdf' or 'tiff' (required)
+   * @param {Object} [config.convertOptions] - Options controlling the conversion output
+   * @param {('fine'|'normal')} [config.convertOptions.resolution='fine'] - Fax resolution: 'fine' (204x196 DPI) or 'normal' (204x98 DPI)
+   * @param {('letter'|'a4')} [config.convertOptions.paperSize='letter'] - Paper size for conversion
+   * @param {('g4'|'g3')} [config.convertOptions.compression='g4'] - TIFF compression: 'g4' (modern, default) or 'g3' (legacy fax machines)
+   * @param {string} [config.classification] - Storage classification for the new file. Defaults to source file's classification.
+   * @param {string} [config.folder] - Folder path for the new file. Defaults to source file's folder.
+   * @param {string} [config.relatedId] - Related object ID for the new file. Defaults to source file's relatedId.
+   * @param {boolean} [config.isPublic] - Whether the new file is publicly accessible. Defaults to source file's isPublic.
+   * @param {string} [config.expireAfter] - Expiration duration for the new file (e.g., '7d', '1h'). If omitted, copies expireAt from source.
+   * @param {boolean} [config.createAccessKey=false] - Generate a temporary access key for the new file
+   * @param {string} [config.accessKeyExpiresIn] - Access key expiration duration (e.g., '7d')
+   * @returns {Promise<Object>} The newly created storage record for the converted file
+   * @returns {string} result.id - Storage ID of the converted file
+   * @returns {string} result.sourceStorageId - Storage ID of the original source file
+   * @returns {string} result.fileName - File name of the converted file
+   * @returns {number} result.fileSize - Size in bytes of the converted file
+   * @returns {string} result.url - URL to access the converted file
+   * @returns {string} result.mimeType - MIME type of the converted file
+   * @returns {string[]} result.s3Regions - Regions where the converted file is stored
+   * @returns {boolean} result.isPublic - Whether the converted file is public
+   * @returns {string} [result.expireAt] - Expiration timestamp if set
+   * @returns {string} [result.accessKey] - Access key if createAccessKey was true
+   *
+   * @example
+   * // Convert a stored PDF to TIFF for fax transmission
+   * const result = await sdk.storage.convertFile('017d01...', {
+   *   convertTo: 'tiff',
+   *   convertOptions: {
+   *     resolution: 'fine',
+   *     paperSize: 'letter',
+   *     compression: 'g4',
+   *   },
+   * });
+   * console.log(result.id);           // new storage ID for the TIFF
+   * console.log(result.sourceStorageId); // original PDF storage ID
+   *
+   * @example
+   * // Convert a DOCX to PDF, overriding the classification and folder
+   * const result = await sdk.storage.convertFile('017d02...', {
+   *   convertTo: 'pdf',
+   *   classification: 'fax',
+   *   folder: 'outbound/2026',
+   * });
+   */
+  async convertFile(
+    storageId,
+    {
+      convertTo,
+      convertOptions,
+      classification,
+      folder,
+      relatedId,
+      isPublic,
+      expireAfter,
+      createAccessKey,
+      accessKeyExpiresIn,
+    } = {},
+  ) {
+    this.sdk.validateParams(
+      { storageId, convertTo },
+      {
+        storageId: { type: 'string', required: true },
+        convertTo: { type: 'string', required: true },
+        convertOptions: { type: 'object', required: false },
+        classification: { type: 'string', required: false },
+        folder: { type: 'string', required: false },
+        relatedId: { type: 'string', required: false },
+        isPublic: { type: 'boolean', required: false },
+        expireAfter: { type: 'string', required: false },
+        createAccessKey: { type: 'boolean', required: false },
+        accessKeyExpiresIn: { type: 'string', required: false },
+      },
+    );
+
+    const body = { convertTo };
+    if (convertOptions !== undefined)
+      body.convertOptions = convertOptions;
+    if (classification !== undefined) body.classification = classification;
+    if (folder !== undefined) body.folder = folder;
+    if (relatedId !== undefined) body.relatedId = relatedId;
+    if (isPublic !== undefined) body.isPublic = isPublic;
+    if (expireAfter !== undefined) body.expireAfter = expireAfter;
+    if (createAccessKey !== undefined) body.createAccessKey = createAccessKey;
+    if (accessKeyExpiresIn !== undefined)
+      body.accessKeyExpiresIn = accessKeyExpiresIn;
+
+    const params = { body };
+
+    return await this.sdk._fetch(`/storage/${storageId}/convert`, 'POST', params);
+  }
+
   /**
    * Update file contents and metadata
    * @param {string} storageId - Storage file ID (required)
@@ -749,6 +1050,7 @@ export class StorageService {
       country,
       expireAfter,
       relatedId,
+      _options,
     },
   ) {
     this.sdk.validateParams(
@@ -784,6 +1086,8 @@ export class StorageService {
         formFields,
         `/storage/${storageId}`,
         'PUT',
+        null,
+        _options?.skipScan,
       );
     } else {
       // If only updating metadata, use JSON request

package/services/taskRouter/MetricsService.js

@@ -0,0 +1,111 @@
+export class MetricsService {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+
+  /**
+   * Get current task router metrics
+   * Retrieves real-time metrics for task router queues, tasks, and workers.
+   * This provides insights into queue performance, wait times, task counts, and worker activity.
+   *
+   * @param {Object} params - Metric parameters
+   * @param {string} [params.period] - Time period for metrics calculation. Options: '5min', '15min', '30min', '1hour', '24hour'
+   * @param {string} [params.queueId] - Specific queue ID to filter metrics. If not provided, returns metrics for all queues
+   * @param {string} [params.metricType] - Type of metrics to retrieve: 'queue', 'task', 'worker', or 'all' (default: 'all')
+   * @param {number} [params.limit=100] - Maximum number of metric records to return (default: 100)
+   * @returns {Promise<Object>} Object containing the requested metrics
+   * @returns {Object} result.metrics - The metrics data organized by type
+   * @returns {Object} [result.metrics.queue] - Queue-level metrics (if metricType is 'queue' or 'all')
+   * @returns {number} result.metrics.queue.tasksWaiting - Number of tasks currently waiting in queue
+   * @returns {number} result.metrics.queue.tasksAssigned - Number of tasks currently assigned to workers
+   * @returns {number} result.metrics.queue.tasksConnected - Number of tasks currently connected/active
+   * @returns {number} result.metrics.queue.avgWaitTime - Average wait time in seconds for tasks in this period
+   * @returns {number} result.metrics.queue.longestWaitTime - Longest current wait time in seconds
+   * @returns {Object} [result.metrics.task] - Task-level metrics (if metricType is 'task' or 'all')
+   * @returns {number} result.metrics.task.created - Number of tasks created in this period
+   * @returns {number} result.metrics.task.completed - Number of tasks completed in this period
+   * @returns {number} result.metrics.task.abandoned - Number of tasks abandoned in this period
+   * @returns {Object} [result.metrics.worker] - Worker-level metrics (if metricType is 'worker' or 'all')
+   * @returns {number} result.metrics.worker.available - Number of workers currently available
+   * @returns {number} result.metrics.worker.busy - Number of workers currently busy with tasks
+   * @returns {number} result.metrics.worker.offline - Number of workers currently offline
+   * @returns {string} result.period - The time period used for calculations
+   * @returns {string} [result.queueId] - The queue ID if filtered to a specific queue
+   *
+   * @example
+   * // Get all current metrics for all queues
+   * const metrics = await sdk.taskRouter.metrics.getCurrent({
+   *   period: '15min',
+   *   metricType: 'all'
+   * });
+   * console.log(metrics.metrics.queue.tasksWaiting); // 5
+   * console.log(metrics.metrics.worker.available); // 12
+   *
+   * @example
+   * // Get queue-specific metrics for last 5 minutes
+   * const queueMetrics = await sdk.taskRouter.metrics.getCurrent({
+   *   period: '5min',
+   *   queueId: 'queue456',
+   *   metricType: 'queue',
+   *   limit: 50
+   * });
+   * console.log(queueMetrics.metrics.queue.avgWaitTime); // 45.3
+   *
+   * @example
+   * // Get worker metrics for last hour
+   * const workerMetrics = await sdk.taskRouter.metrics.getCurrent({
+   *   period: '1hour',
+   *   metricType: 'worker'
+   * });
+   * console.log(workerMetrics.metrics.worker.available); // 8
+   * console.log(workerMetrics.metrics.worker.busy); // 4
+   *
+   * @example
+   * // Get task completion metrics for last 24 hours
+   * const taskMetrics = await sdk.taskRouter.metrics.getCurrent({
+   *   period: '24hour',
+   *   metricType: 'task',
+   *   limit: 200
+   * });
+   * console.log(taskMetrics.metrics.task.created); // 150
+   * console.log(taskMetrics.metrics.task.completed); // 142
+   */
+  async getCurrent(accountId, params = {}) {
+    const { period, queueId, metricType, limit = 100 } = params;
+
+    this.sdk.validateParams(
+      { period, queueId, metricType, limit },
+      {
+        period: { type: 'string', required: false },
+        queueId: { type: 'string', required: false },
+        metricType: { type: 'string', required: false },
+        limit: { type: 'number', required: false },
+      },
+    );
+
+    const requestParams = {
+      body: {
+        limit,
+      },
+    };
+
+    if (period !== undefined) {
+      requestParams.body.period = period;
+    }
+
+    if (queueId !== undefined) {
+      requestParams.body.queueId = queueId;
+    }
+
+    if (metricType !== undefined) {
+      requestParams.body.metricType = metricType;
+    }
+
+    const result = await this.sdk._fetch(
+      '/taskRouter/metrics/current',
+      'GET',
+      requestParams,
+    );
+    return result;
+  }
+}

package/services/taskRouter/TaskRouterService.js

@@ -0,0 +1,12 @@
+import { WorkerService } from './WorkerService.js';
+import { TaskService } from './TaskService.js';
+import { MetricsService } from './MetricsService.js';
+
+export class TaskRouterService {
+  constructor(sdk) {
+    this.sdk = sdk;
+    this.worker = new WorkerService(sdk);
+    this.task = new TaskService(sdk);
+    this.metrics = new MetricsService(sdk);
+  }
+}