@unboundcx/sdk 4.9.3 → 4.10.1

package/index.js

@@ -20,6 +20,7 @@ import { PortalsService } from './services/portals.js';
 import { SipEndpointsService } from './services/sipEndpoints.js';
 import { ExternalOAuthService } from './services/externalOAuth.js';
 import { GoogleCalendarService } from './services/googleCalendar.js';
+import { DriveService } from './services/drive.js';
 import { EnrollService } from './services/enroll.js';
 import { PhoneNumbersService } from './services/phoneNumbers.js';
 import { RecordTypesService } from './services/recordTypes.js';
@@ -97,6 +98,7 @@ class UnboundSDK extends BaseSDK {
     this.sipEndpoints = new SipEndpointsService(this);
     this.externalOAuth = new ExternalOAuthService(this);
     this.googleCalendar = new GoogleCalendarService(this);
+    this.drive = new DriveService(this);
     this.enroll = new EnrollService(this);
     this.phoneNumbers = new PhoneNumbersService(this);
     this.recordTypes = new RecordTypesService(this);
@@ -278,6 +280,7 @@ export { PortalsService } from './services/portals.js';
 export { SipEndpointsService } from './services/sipEndpoints.js';
 export { ExternalOAuthService } from './services/externalOAuth.js';
 export { GoogleCalendarService } from './services/googleCalendar.js';
+export { DriveService } from './services/drive.js';
 export { EnrollService } from './services/enroll.js';
 export {
   PhoneNumbersService,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unboundcx/sdk",
-  "version": "4.9.3",
+  "version": "4.10.1",
   "description": "Official JavaScript SDK for the Unbound API - A comprehensive toolkit for integrating with Unbound's communication, AI, and data management services",
   "main": "index.js",
   "type": "module",

package/services/chat.js

@@ -825,7 +825,9 @@ export class ChatService {
 
   /**
    * Admin: get account-level chat settings.
-   * @returns {Promise<Object>} `{allowReports, reportReasons}`
+   * @returns {Promise<Object>} `{allowReports, reportReasons, reportNotifications}`
+   *   `reportNotifications[]` items are `{channelId, channelName, channelKind, reasons}` —
+   *   `reasons` is `null` when the rule notifies for every reason.
    */
   async adminGetSettings() {
     return internalRequest(this.sdk, "/chat/admin/settings", "GET");
@@ -836,18 +838,26 @@ export class ChatService {
    * @param {Object} params
    * @param {boolean} params.allowReports
    * @param {string[]} [params.reportReasons]
-   * @returns {Promise<Object>} `{allowReports, reportReasons}`
+   * @param {Object[]} [params.reportNotifications] - Channels to post a
+   *   "message reported" card to. Each item: `{channelId: string, reasons:
+   *   string[]|null}` — `reasons` null/empty means "notify for every
+   *   reason"; channel must be a non-archived public/private channel.
+   * @returns {Promise<Object>} `{allowReports, reportReasons, reportNotifications}`
    */
-  async adminPutSettings({ allowReports, reportReasons } = {}) {
+  async adminPutSettings({ allowReports, reportReasons, reportNotifications } = {}) {
     this.sdk.validateParams(
-      { allowReports, reportReasons },
+      { allowReports, reportReasons, reportNotifications },
       {
         allowReports: { type: "boolean", required: true },
         reportReasons: { type: "array", required: false },
+        reportNotifications: { type: "array", required: false },
       },
     );
     const body = { allowReports };
     if (reportReasons !== undefined) body.reportReasons = reportReasons;
+    if (reportNotifications !== undefined) {
+      body.reportNotifications = reportNotifications;
+    }
     return internalRequest(this.sdk, "/chat/admin/settings", "PUT", {
       body,
     });

package/services/drive.js

@@ -0,0 +1,234 @@
+import { internalRequest } from '../base.js';
+import { StorageService } from './storage.js';
+
+export class DriveService {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+
+  async status() {
+    const result = await internalRequest(this.sdk, '/drive/status', 'GET');
+    return result;
+  }
+
+  /**
+   * List Google Drive files and folders.
+   * @param {Object} [options]
+   * @param {string} [options.folderId]
+   * @param {string} [options.search]
+   * @param {number} [options.page]
+   * @param {number} [options.pageSize]
+   * @returns {Promise<Object>}
+   */
+  async listFiles({ folderId, search, page, pageSize } = {}) {
+    this.sdk.validateParams(
+      { folderId, search, page, pageSize },
+      {
+        folderId: { type: 'string', required: false },
+        search: { type: 'string', required: false },
+        page: { type: 'number', required: false },
+        pageSize: { type: 'number', required: false },
+      },
+    );
+
+    const query = {};
+    if (folderId !== undefined) query.folderId = folderId;
+    if (search !== undefined) query.search = search;
+    if (page !== undefined) query.page = page;
+    if (pageSize !== undefined) query.pageSize = pageSize;
+
+    const result = await internalRequest(this.sdk, '/drive/files', 'GET', {
+      query,
+    });
+    return result;
+  }
+
+  /**
+   * Create a Google Drive folder.
+   * @param {Object} options
+   * @param {string} options.name
+   * @param {string} [options.parentId]
+   * @returns {Promise<Object>}
+   */
+  async createFolder({ name, parentId } = {}) {
+    this.sdk.validateParams(
+      { name, parentId },
+      {
+        name: { type: 'string', required: true },
+        parentId: { type: 'string', required: false },
+      },
+    );
+
+    const body = { name };
+    if (parentId !== undefined) body.parentId = parentId;
+
+    const result = await internalRequest(this.sdk, '/drive/folders', 'POST', {
+      body,
+    });
+    return result;
+  }
+
+  /**
+   * Rename and/or move a Google Drive folder.
+   * @param {string} id
+   * @param {Object} [updates]
+   * @param {string} [updates.name]
+   * @param {string} [updates.parentId]
+   * @returns {Promise<Object>}
+   */
+  async updateFolder(id, { name, parentId } = {}) {
+    this.sdk.validateParams(
+      { id, name, parentId },
+      {
+        id: { type: 'string', required: true },
+        name: { type: 'string', required: false },
+        parentId: { type: 'string', required: false },
+      },
+    );
+
+    const body = {};
+    if (name !== undefined) body.name = name;
+    if (parentId !== undefined) body.parentId = parentId;
+
+    const result = await internalRequest(
+      this.sdk,
+      `/drive/folders/${id}`,
+      'PATCH',
+      { body },
+      true,
+    );
+    return result;
+  }
+
+  async deleteFolder(id) {
+    this.sdk.validateParams(
+      { id },
+      {
+        id: { type: 'string', required: true },
+      },
+    );
+
+    const result = await internalRequest(
+      this.sdk,
+      `/drive/folders/${id}`,
+      'DELETE',
+    );
+    return result;
+  }
+
+  /**
+   * Rename a Google Drive file.
+   * @param {string} id
+   * @param {Object} [updates]
+   * @param {string} [updates.name]
+   * @returns {Promise<Object>}
+   */
+  async updateFile(id, { name } = {}) {
+    this.sdk.validateParams(
+      { id, name },
+      {
+        id: { type: 'string', required: true },
+        name: { type: 'string', required: false },
+      },
+    );
+
+    const body = {};
+    if (name !== undefined) body.name = name;
+
+    const result = await internalRequest(
+      this.sdk,
+      `/drive/files/${id}`,
+      'PATCH',
+      { body },
+      true,
+    );
+    return result;
+  }
+
+  /**
+   * Move Drive files into a folder.
+   * @param {Object} options
+   * @param {string[]} options.ids
+   * @param {string} [options.folderId]
+   * @returns {Promise<Object>}
+   */
+  async moveFiles({ ids, folderId } = {}) {
+    this.sdk.validateParams(
+      { ids, folderId },
+      {
+        ids: { type: 'array', required: true },
+        folderId: { type: 'string', required: false },
+      },
+    );
+
+    const body = { ids };
+    if (folderId !== undefined) body.folderId = folderId;
+
+    const result = await internalRequest(
+      this.sdk,
+      '/drive/files/move',
+      'PATCH',
+      { body },
+      true,
+    );
+    return result;
+  }
+
+  async deleteFile(id) {
+    this.sdk.validateParams(
+      { id },
+      {
+        id: { type: 'string', required: true },
+      },
+    );
+
+    const result = await internalRequest(
+      this.sdk,
+      `/drive/files/${id}`,
+      'DELETE',
+    );
+    return result;
+  }
+
+  /**
+   * Upload a file to Google Drive.
+   * @param {Object} config
+   * @param {Object} config.file - Buffer, File, or stream
+   * @param {string} [config.fileName]
+   * @param {string} [config.parentId]
+   * @param {Function} [config.onProgress]
+   * @returns {Promise<Object>}
+   */
+  async upload({ file, fileName, parentId, onProgress } = {}) {
+    this.sdk.validateParams(
+      { file, fileName, parentId },
+      {
+        file: { type: 'object', required: true },
+        fileName: { type: 'string', required: false },
+        parentId: { type: 'string', required: false },
+      },
+    );
+
+    const formFields = [];
+    if (parentId) formFields.push(['parentId', parentId]);
+
+    const storage = new StorageService(this.sdk);
+    return storage._performUpload(
+      file,
+      fileName,
+      formFields,
+      '/drive/upload',
+      'POST',
+      onProgress,
+    );
+  }
+
+  async browserToken() {
+    const result = await internalRequest(
+      this.sdk,
+      '/drive/browserToken',
+      'POST',
+    );
+    return result;
+  }
+}

package/services/storage.js

@@ -459,6 +459,7 @@ Response:
    * @param {string} [config.country='US'] - Country code for region selection
    * @param {string} [config.expireAfter] - Expiration time
    * @param {string} [config.relatedId] - Related object ID
+   * @param {string} [config.folderId] - Storage folder 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.
@@ -479,6 +480,7 @@ Response:
     country = 'US',
     expireAfter,
     relatedId,
+    folderId,
     createAccessKey = false,
     accessKeyExpiresIn,
     convertTo,
@@ -496,6 +498,7 @@ Response:
         country,
         expireAfter,
         relatedId,
+        folderId,
         createAccessKey,
         accessKeyExpiresIn,
         convertTo,
@@ -510,6 +513,7 @@ Response:
         country: { type: 'string', required: false },
         expireAfter: { type: 'string', required: false },
         relatedId: { type: 'string', required: false },
+        folderId: { type: 'string', required: false },
         createAccessKey: { type: 'boolean', required: false },
         accessKeyExpiresIn: { type: 'number', required: false },
         convertTo: { type: 'string', required: false },
@@ -526,6 +530,7 @@ Response:
     if (country) formFields.push(['country', country]);
     if (expireAfter) formFields.push(['expireAfter', expireAfter]);
     if (relatedId) formFields.push(['relatedId', relatedId]);
+    if (folderId) formFields.push(['folderId', folderId]);
     if (createAccessKey !== undefined)
       formFields.push(['createAccessKey', createAccessKey.toString()]);
     if (accessKeyExpiresIn)
@@ -779,41 +784,84 @@ Response:
     return result;
   }
 
-  async updateFileMetadata(storageId, metadata) {
+  /**
+   * Update file metadata (rename and/or move). Does not re-upload the file.
+   * @param {string} id - Storage file id
+   * @param {Object} [updates]
+   * @param {string} [updates.fileName]
+   * @param {string} [updates.folderId]
+   * @param {string} [updates.relatedId]
+   * @returns {Promise<Object>}
+   */
+  async updateFileMetadata(id, { fileName, folderId, relatedId } = {}) {
     this.sdk.validateParams(
-      { storageId, metadata },
+      { id, fileName, folderId, relatedId },
       {
-        storageId: { type: 'string', required: true },
-        metadata: { type: 'object', required: true },
+        id: { type: 'string', required: true },
+        fileName: { type: 'string', required: false },
+        folderId: { type: 'string', required: false },
+        relatedId: { type: 'string', required: false },
       },
     );
 
-    const params = {
-      body: { metadata },
-    };
+    const body = {};
+    if (fileName !== undefined) body.fileName = fileName;
+    if (folderId !== undefined) body.folderId = folderId;
+    if (relatedId !== undefined) body.relatedId = relatedId;
 
-    const result = await internalRequest(this.sdk, 
-      `/storage/file/${storageId}/metadata`,
-      'PUT',
-      params,
+    const result = await internalRequest(
+      this.sdk,
+      `/storage/files/${id}`,
+      'PATCH',
+      { body },
+      true,
     );
     return result;
   }
 
+  /**
+   * List storage files.
+   * @param {Object} [options]
+   * @param {string} [options.relatedId]
+   * @param {string} [options.folderId]
+   * @param {string} [options.folder]
+   * @param {string} [options.classification]
+   * @param {string} [options.search]
+   * @param {string} [options.view]
+   * @param {number} [options.page]
+   * @param {number} [options.limit]
+   * @param {string} [options.sortBy]
+   * @param {string} [options.sortOrder]
+   * @param {string} [options.fileType]
+   * @param {boolean} [options.isPublic]
+   * @param {number} [options.offset] - Legacy; still forwarded if provided
+   * @param {string} [options.orderBy] - Legacy; still forwarded if provided
+   * @param {string} [options.orderDirection] - Legacy; still forwarded if provided
+   * @returns {Promise<Object>}
+   */
   async listFiles(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' };
-    if ('orderDirection' in options)
-      validationSchema.orderDirection = { type: 'string' };
+    const optionalTypes = {
+      relatedId: 'string',
+      folderId: 'string',
+      folder: 'string',
+      classification: 'string',
+      search: 'string',
+      view: 'string',
+      page: 'number',
+      limit: 'number',
+      sortBy: 'string',
+      sortOrder: 'string',
+      fileType: 'string',
+      isPublic: 'boolean',
+      offset: 'number',
+      orderBy: 'string',
+      orderDirection: 'string',
+    };
+
+    for (const [key, type] of Object.entries(optionalTypes)) {
+      if (key in options) validationSchema[key] = { type };
+    }
 
     if (Object.keys(validationSchema).length > 0) {
       this.sdk.validateParams(options, validationSchema);
@@ -827,6 +875,152 @@ Response:
     return result;
   }
 
+  /**
+   * List storage folders for a related record.
+   * @param {Object} options
+   * @param {string} options.relatedId
+   * @param {string} [options.parentId]
+   * @param {string} [options.search]
+   * @returns {Promise<Object>}
+   */
+  async listFolders({ relatedId, parentId, search } = {}) {
+    this.sdk.validateParams(
+      { relatedId, parentId, search },
+      {
+        relatedId: { type: 'string', required: true },
+        parentId: { type: 'string', required: false },
+        search: { type: 'string', required: false },
+      },
+    );
+
+    const query = { relatedId };
+    if (parentId !== undefined) query.parentId = parentId;
+    if (search !== undefined) query.search = search;
+
+    const result = await internalRequest(this.sdk, '/storage/folders', 'GET', {
+      query,
+    });
+    return result;
+  }
+
+  /**
+   * Create a storage folder.
+   * @param {Object} options
+   * @param {string} options.relatedId
+   * @param {string} [options.parentId]
+   * @param {string} options.name
+   * @returns {Promise<Object>}
+   */
+  async createFolder({ relatedId, parentId, name } = {}) {
+    this.sdk.validateParams(
+      { relatedId, parentId, name },
+      {
+        relatedId: { type: 'string', required: true },
+        parentId: { type: 'string', required: false },
+        name: { type: 'string', required: true },
+      },
+    );
+
+    const body = { relatedId, name };
+    if (parentId !== undefined) body.parentId = parentId;
+
+    const result = await internalRequest(this.sdk, '/storage/folders', 'POST', {
+      body,
+    });
+    return result;
+  }
+
+  /**
+   * Rename and/or move a storage folder.
+   * @param {string} id
+   * @param {Object} [updates]
+   * @param {string} [updates.relatedId]
+   * @param {string} [updates.name]
+   * @param {string} [updates.parentId]
+   * @returns {Promise<Object>}
+   */
+  async updateFolder(id, { relatedId, name, parentId } = {}) {
+    this.sdk.validateParams(
+      { id, relatedId, name, parentId },
+      {
+        id: { type: 'string', required: true },
+        relatedId: { type: 'string', required: false },
+        name: { type: 'string', required: false },
+        parentId: { type: 'string', required: false },
+      },
+    );
+
+    const body = {};
+    if (relatedId !== undefined) body.relatedId = relatedId;
+    if (name !== undefined) body.name = name;
+    if (parentId !== undefined) body.parentId = parentId;
+
+    const result = await internalRequest(
+      this.sdk,
+      `/storage/folders/${id}`,
+      'PATCH',
+      { body },
+      true,
+    );
+    return result;
+  }
+
+  /**
+   * Soft-delete a storage folder (cascades to children).
+   * @param {string} id
+   * @param {Object} options
+   * @param {string} options.relatedId
+   * @returns {Promise<Object>}
+   */
+  async deleteFolder(id, { relatedId } = {}) {
+    this.sdk.validateParams(
+      { id, relatedId },
+      {
+        id: { type: 'string', required: true },
+        relatedId: { type: 'string', required: true },
+      },
+    );
+
+    const result = await internalRequest(
+      this.sdk,
+      `/storage/folders/${id}`,
+      'DELETE',
+      { query: { relatedId } },
+    );
+    return result;
+  }
+
+  /**
+   * Move files into a folder (DB folderId only).
+   * @param {Object} options
+   * @param {string[]} options.ids
+   * @param {string} [options.folderId]
+   * @param {string} options.relatedId
+   * @returns {Promise<Object>}
+   */
+  async moveFiles({ ids, folderId, relatedId } = {}) {
+    this.sdk.validateParams(
+      { ids, folderId, relatedId },
+      {
+        ids: { type: 'array', required: true },
+        folderId: { type: 'string', required: false },
+        relatedId: { type: 'string', required: true },
+      },
+    );
+
+    const body = { ids, relatedId };
+    if (folderId !== undefined) body.folderId = folderId;
+
+    const result = await internalRequest(
+      this.sdk,
+      '/storage/files/move',
+      'PATCH',
+      { body },
+      true,
+    );
+    return result;
+  }
+
   /**
    * Generate an access key for an existing storage file
    * @param {string} fileId - The storage file ID

package/test-backwards-compatibility.js

@@ -39,6 +39,7 @@ async function testBasicSDKFunctionality() {
     'sipEndpoints',
     'externalOAuth',
     'googleCalendar',
+    'drive',
     'enroll',
   ];
 

package/test-complete-coverage.js

@@ -37,6 +37,7 @@ async function testPublicSDKCompleteness() {
     // Additional services found in analysis
     'externalOAuth',
     'googleCalendar',
+    'drive',
     'enroll',
     'phoneNumbers',
     'recordTypes',

package/test-constructor-patterns.js

@@ -115,6 +115,7 @@ const services = [
   'sipEndpoints',
   'externalOAuth',
   'googleCalendar',
+  'drive',
   'enroll',
   'phoneNumbers',
   'recordTypes',