@unboundcx/sdk 2.7.6 → 2.8.0

package/services/objects.js

@@ -26,55 +26,45 @@ export class ObjectsService {
    * Retrieve an object by ID
    *
    * Preferred usage (new signature):
-   * sdk.objects.byId({ id: 'someId', expandDetails: true })
+   * sdk.objects.byId({ id: 'someId', expandDetails: true, isAiPrompt: true })
    *
    * Legacy usage (deprecated, but supported):
    * sdk.objects.byId('someId', { 'select[]': ['field1', 'field2'] })
    *
    * @param {string|object} args - Either ID string or options object
+   * @param {boolean} [args.isAiPrompt] - Clean data for AI prompt usage (removes system fields)
    * @returns {Promise} Object data
    */
-  async byId(...args) {
-    // New signature: byId({ id, expandDetails })
-    if (
-      args.length === 1 &&
-      typeof args[0] === 'object' &&
-      !Array.isArray(args[0])
-    ) {
-      const { id, expandDetails = false } = args[0];
-
-      this.sdk.validateParams(
-        { id, expandDetails },
-        {
-          id: { type: 'string', required: true },
-          expandDetails: { type: 'boolean', required: false },
-        },
-      );
-
-      const query = {};
-      if (expandDetails) query.expandDetails = expandDetails;
-
-      const params = { query };
-      return await this.sdk._fetch(`/object/${id}`, 'GET', params);
+  async byId(arg1, arg2) {
+    let id;
+    let query = {};
+    if (typeof arg1 === 'string') {
+      id = arg1;
+      if (typeof arg2 === 'object') {
+        query = { ...arg2 };
+      }
+    } else if (typeof arg1 === 'object') {
+      id = arg1.id;
+      query = { ...arg1 };
+      if (query.id) {
+        delete query.id;
+      }
     }
 
-    // Old signature: byId(id, queryParams)
-    if (args.length >= 1 && typeof args[0] === 'string') {
-      const [id, queryParams = {}] = args;
-
-      this.sdk.validateParams(
-        { id },
-        {
-          id: { type: 'string', required: true },
-        },
-      );
-
-      const query = { ...queryParams };
-      const params = { query };
-      return await this.sdk._fetch(`/object/${id}`, 'GET', params);
+    if (Array.isArray(query.select)) {
+      query.select = query.select.join(',');
     }
 
-    throw new Error('Invalid arguments for byId method');
+    this.sdk.validateParams(
+      { id },
+      {
+        id: { type: 'string', required: true },
+      },
+    );
+
+    const params = { query };
+    const result = await this.sdk._fetch(`/object/${id}`, 'GET', params);
+    return result;
   }
 
   /**

package/services/recordTypes.js

@@ -4,6 +4,27 @@ export class RecordTypesService {
     this.user = new UserRecordTypeDefaultsService(sdk);
   }
 
+  /**
+   * Create a new recordType with permission rules
+   * @param {Object} recordType - RecordType configuration
+   * @param {string} recordType.name - RecordType name (required)
+   * @param {string} recordType.description - RecordType description (required)
+   * @param {Array|null} recordType.create - User IDs who can create (null = universal access)
+   * @param {Array|null} recordType.read - User IDs who can read (null = universal access)
+   * @param {Array|null} recordType.update - User IDs who can update (null = universal access)
+   * @param {Array|null} recordType.delete - User IDs who can delete (null = universal access)
+   * @returns {Promise<Object>} Created recordType information
+   * @example
+   * // Create a recordType with mixed permissions
+   * await sdk.recordTypes.create({
+   *   name: 'Sales - Private',
+   *   description: 'Sensitive sales data',
+   *   create: ['user1', 'user2'],  // Only specific users can create
+   *   read: null,                  // Everyone can read
+   *   update: ['admin1'],          // Only admin can update
+   *   delete: ['admin1']           // Only admin can delete
+   * });
+   */
   async create({
     name,
     description,
@@ -38,6 +59,35 @@ export class RecordTypesService {
     return result;
   }
 
+  /**
+   * Update an existing recordType using add/remove pattern for permissions
+   * @param {string} id - RecordType ID to update
+   * @param {Object} updates - Update configuration
+   * @param {string} updates.name - New name (optional)
+   * @param {string} updates.description - New description (optional)
+   * @param {Object} updates.add - Users to ADD to permissions
+   * @param {Array} updates.add.create - Add these users to create permission
+   * @param {Array} updates.add.read - Add these users to read permission
+   * @param {Array} updates.add.update - Add these users to update permission
+   * @param {Array} updates.add.delete - Add these users to delete permission
+   * @param {Object} updates.remove - Users to REMOVE from permissions
+   * @param {Array} updates.remove.create - Remove these users from create permission
+   * @param {Array} updates.remove.read - Remove these users from read permission
+   * @param {Array} updates.remove.update - Remove these users from update permission
+   * @param {Array} updates.remove.delete - Remove these users from delete permission
+   * @returns {Promise<Object>} Updated recordType information
+   * @example
+   * // Add new users to create permission, remove a user from update
+   * await sdk.recordTypes.update('recordTypeId', {
+   *   add: {
+   *     create: ['newUser1', 'newUser2'],
+   *     delete: ['manager1']
+   *   },
+   *   remove: {
+   *     update: ['oldUser1']
+   *   }
+   * });
+   */
   async update(id, { name, description, remove, add }) {
     this.sdk.validateParams(
       { id },
@@ -64,6 +114,13 @@ export class RecordTypesService {
     return result;
   }
 
+  /**
+   * Delete a recordType
+   * @param {string} id - RecordType ID to delete
+   * @returns {Promise<Object>} Deletion confirmation
+   * @example
+   * await sdk.recordTypes.delete('recordTypeId');
+   */
   async delete(id) {
     this.sdk.validateParams(
       { id },
@@ -76,7 +133,25 @@ export class RecordTypesService {
     return result;
   }
 
-  async get(id) {
+  /**
+   * Get detailed information about a specific recordType
+   * @param {string} id - RecordType ID
+   * @param {Object} options - Additional options
+   * @param {boolean} options.includeUsers - Include user default assignments (default: false)
+   * @returns {Promise<Object>} Detailed recordType with permissions and current user access
+   * @example
+   * // Get recordType with user assignments
+   * const recordType = await sdk.recordTypes.get('recordTypeId', {
+   *   includeUsers: true
+   * });
+   *
+   * // Check current user's permissions
+   * console.log(recordType.currentUserAccess.canCreate); // true/false
+   * console.log(recordType.permissions.read.type); // 'universal' or 'restricted'
+   */
+  async get(id, options = {}) {
+    const { includeUsers } = options;
+
     this.sdk.validateParams(
       { id },
       {
@@ -84,12 +159,73 @@ export class RecordTypesService {
       },
     );
 
-    const result = await this.sdk._fetch(`/recordTypes/${id}`, 'GET');
+    // Validate optional parameters
+    if ('includeUsers' in options) {
+      this.sdk.validateParams(
+        { includeUsers },
+        {
+          includeUsers: { type: 'boolean' },
+        },
+      );
+    }
+
+    const params = {
+      query: options,
+    };
+
+    const result = await this.sdk._fetch(`/recordTypes/${id}`, 'GET', params);
     return result;
   }
 
-  async list() {
-    const result = await this.sdk._fetch('/recordTypes/', 'GET');
+  /**
+   * List recordTypes with optional filtering and pagination
+   * @param {Object} options - Filter and pagination options
+   * @param {string} options.search - Search in name or description
+   * @param {boolean} options.isAccountDefault - Filter by account default status
+   * @param {number} options.page - Page number (default: 1)
+   * @param {number} options.limit - Items per page (default: 50, max: 100)
+   * @param {string} options.sortBy - Sort field: 'name', 'createdAt', 'updatedAt' (default: 'name')
+   * @param {string} options.sortOrder - Sort order: 'asc', 'desc' (default: 'asc')
+   * @returns {Promise<Object>} Object containing recordTypes, pagination, and summary
+   * @example
+   * // List with search and pagination
+   * const result = await sdk.recordTypes.list({
+   *   search: 'sales',
+   *   isAccountDefault: false,
+   *   page: 1,
+   *   limit: 25,
+   *   sortBy: 'name',
+   *   sortOrder: 'asc'
+   * });
+   *
+   * // Access results
+   * console.log(result.recordTypes); // Array of recordTypes
+   * console.log(result.pagination);  // Pagination info
+   * console.log(result.summary);     // Statistics
+   */
+  async list(options = {}) {
+    const { search, isAccountDefault, page, limit, sortBy, sortOrder } =
+      options;
+
+    // Validate optional parameters
+    const validationSchema = {};
+    if ('search' in options) validationSchema.search = { type: 'string' };
+    if ('isAccountDefault' in options)
+      validationSchema.isAccountDefault = { type: 'boolean' };
+    if ('page' in options) validationSchema.page = { type: 'number' };
+    if ('limit' in options) validationSchema.limit = { type: 'number' };
+    if ('sortBy' in options) validationSchema.sortBy = { type: 'string' };
+    if ('sortOrder' in options) validationSchema.sortOrder = { type: 'string' };
+
+    if (Object.keys(validationSchema).length > 0) {
+      this.sdk.validateParams(options, validationSchema);
+    }
+
+    const params = {
+      query: options,
+    };
+
+    const result = await this.sdk._fetch('/recordTypes/', 'GET', params);
     return result;
   }
 }
@@ -181,4 +317,91 @@ export class UserRecordTypeDefaultsService {
     const result = await this.sdk._fetch('/recordTypes/user/', 'GET', params);
     return result;
   }
+
+  /**
+   * Get all recordType defaults for a specific user
+   * Perfect for User Detail Page to show all user's recordType preferences
+   * @param {string} userId - User ID (optional - defaults to current user)
+   * @param {Object} options - Additional options
+   * @param {boolean} options.includeRecordTypeDetails - Include recordType name/description
+   * @returns {Promise<Object>} User's recordType defaults organized by object type
+   */
+  async getDefaults(userId, options = {}) {
+    const { includeRecordTypeDetails } = options;
+
+    // Validate optional parameters
+    if (userId) {
+      this.sdk.validateParams(
+        { userId },
+        {
+          userId: { type: 'string' },
+        },
+      );
+    }
+
+    if ('includeRecordTypeDetails' in options) {
+      this.sdk.validateParams(
+        { includeRecordTypeDetails },
+        {
+          includeRecordTypeDetails: { type: 'boolean' },
+        },
+      );
+    }
+
+    const params = {
+      query: options,
+    };
+
+    const url = userId
+      ? `/recordTypes/user/defaults/${userId}`
+      : '/recordTypes/user/defaults';
+
+    const result = await this.sdk._fetch(url, 'GET', params);
+    return result;
+  }
+
+  /**
+   * List users who have a specific recordType as their default
+   * Perfect for RecordType Detail Page to show who uses this recordType
+   * @param {string} recordTypeId - RecordType ID
+   * @param {Object} options - Filter and pagination options
+   * @param {string} options.object - Filter by specific object type
+   * @param {boolean} options.includeUserDetails - Include user name/email
+   * @param {number} options.page - Page number (default: 1)
+   * @param {number} options.limit - Items per page (default: 50, max: 100)
+   * @returns {Promise<Object>} Users organized by object type with statistics
+   */
+  async listUsersWithDefault(recordTypeId, options = {}) {
+    const { object, includeUserDetails, page, limit } = options;
+
+    this.sdk.validateParams(
+      { recordTypeId },
+      {
+        recordTypeId: { type: 'string', required: true },
+      },
+    );
+
+    // Validate optional parameters
+    const validationSchema = {};
+    if ('object' in options) validationSchema.object = { type: 'string' };
+    if ('includeUserDetails' in options)
+      validationSchema.includeUserDetails = { type: 'boolean' };
+    if ('page' in options) validationSchema.page = { type: 'number' };
+    if ('limit' in options) validationSchema.limit = { type: 'number' };
+
+    if (Object.keys(validationSchema).length > 0) {
+      this.sdk.validateParams(options, validationSchema);
+    }
+
+    const params = {
+      query: options,
+    };
+
+    const result = await this.sdk._fetch(
+      `/recordTypes/${recordTypeId}/users`,
+      'GET',
+      params,
+    );
+    return result;
+  }
 }

package/services/sipEndpoints.js

@@ -3,24 +3,24 @@ export class SipEndpointsService {
     this.sdk = sdk;
   }
 
-  async create({ username, password, domain, displayName, description }) {
+  async create({ recordTypeId, type, userId, name }) {
     this.sdk.validateParams(
-      { username, password, domain },
+      { recordTypeId, type, userId, name },
       {
-        username: { type: 'string', required: true },
-        password: { type: 'string', required: true },
-        domain: { type: 'string', required: true },
-        displayName: { type: 'string', required: false },
-        description: { type: 'string', required: false },
+        recordTypeId: { type: 'string', required: false },
+        type: { type: 'string', required: true },
+        userId: { type: 'string', required: false },
+        name: { type: 'string', required: false },
       },
     );
 
-    const endpointData = { username, password, domain };
-    if (displayName) endpointData.displayName = displayName;
-    if (description) endpointData.description = description;
-
     const params = {
-      body: endpointData,
+      body: {
+        recordTypeId,
+        type,
+        userId,
+        name,
+      },
     };
 
     const result = await this.sdk._fetch('/sipEndpoints', 'POST', params);

package/services/storage.js

@@ -212,6 +212,7 @@ export class StorageService {
     fileName,
     formFields,
     endpoint = '/storage/upload',
+    method = 'POST',
   ) {
     const isNode = typeof window === 'undefined';
     let formData, headers;
@@ -231,7 +232,7 @@ export class StorageService {
       headers,
     };
 
-    return await this.sdk._fetch(endpoint, 'POST', params, true);
+    return await this.sdk._fetch(endpoint, method, params, true);
   }
 
   async upload({
@@ -584,4 +585,228 @@ export class StorageService {
     );
     return result;
   }
+
+  /**
+   * List storage configurations with optional filtering
+   * @param {Object} options - Filter options
+   * @param {string} options.classification - Filter by classification
+   * @param {string} options.country - Filter by country
+   * @param {boolean} options.isSystem - Filter by system/custom configs
+   * @param {boolean} options.includeGlobal - Include global configurations (default: true)
+   * @returns {Promise<Object>} Object containing configurations and summary
+   */
+  async listStorageConfigurations(options = {}) {
+    const { classification, country, isSystem, includeGlobal } = options;
+
+    // Validate optional parameters
+    const validationSchema = {};
+    if ('classification' in options)
+      validationSchema.classification = { type: 'string' };
+    if ('country' in options) validationSchema.country = { type: 'string' };
+    if ('isSystem' in options) validationSchema.isSystem = { type: 'boolean' };
+    if ('includeGlobal' in options)
+      validationSchema.includeGlobal = { type: 'boolean' };
+
+    if (Object.keys(validationSchema).length > 0) {
+      this.sdk.validateParams(options, validationSchema);
+    }
+
+    const params = {
+      query: options,
+    };
+
+    const result = await this.sdk._fetch(
+      '/storage/configurations',
+      'GET',
+      params,
+    );
+    return result;
+  }
+
+  /**
+   * Create a new custom storage configuration
+   * @param {Object} config - Configuration data
+   * @param {string} config.classification - Configuration classification
+   * @param {string} config.country - Country code
+   * @param {Array} config.s3Regions - S3 regions array
+   * @param {Array} config.gccRegions - Google Cloud regions array
+   * @param {Array} config.azureRegions - Azure regions array
+   * @param {number} config.minimumProviders - Minimum number of providers (default: 1)
+   * @param {number} config.minimumRegionsS3 - Minimum S3 regions (default: 1)
+   * @param {number} config.minimumRegionsGCC - Minimum GCC regions (default: 1)
+   * @param {number} config.minimumRegionsAzure - Minimum Azure regions (default: 1)
+   * @returns {Promise<Object>} Created configuration object
+   */
+  async createStorageConfiguration(config) {
+    const {
+      classification,
+      country,
+      s3Regions,
+      gccRegions,
+      azureRegions,
+      minimumProviders,
+      minimumRegionsS3,
+      minimumRegionsGCC,
+      minimumRegionsAzure,
+    } = config;
+
+    this.sdk.validateParams(config, {
+      classification: { type: 'string', required: true },
+      country: { type: 'string', required: true },
+      s3Regions: { type: 'object', required: false },
+      gccRegions: { type: 'object', required: false },
+      azureRegions: { type: 'object', required: false },
+      minimumProviders: { type: 'number', required: false },
+      minimumRegionsS3: { type: 'number', required: false },
+      minimumRegionsGCC: { type: 'number', required: false },
+      minimumRegionsAzure: { type: 'number', required: false },
+    });
+
+    const params = {
+      body: config,
+    };
+
+    const result = await this.sdk._fetch(
+      '/storage/configurations',
+      'POST',
+      params,
+    );
+    return result;
+  }
+
+  /**
+   * Update an existing storage configuration
+   * System configurations have limited update capabilities (only regions and minimum levels)
+   * Custom configurations can update all fields
+   * @param {string} id - Configuration ID
+   * @param {Object} updates - Update data
+   * @returns {Promise<Object>} Updated configuration object
+   */
+  async updateStorageConfiguration(id, updates) {
+    this.sdk.validateParams(
+      { id, updates },
+      {
+        id: { type: 'string', required: true },
+        updates: { type: 'object', required: true },
+      },
+    );
+
+    const params = {
+      body: updates,
+    };
+
+    const result = await this.sdk._fetch(
+      `/storage/configurations/${id}`,
+      'PUT',
+      params,
+    );
+    return result;
+  }
+
+  /**
+   * Delete a custom storage configuration
+   * System configurations cannot be deleted
+   * @param {string} id - Configuration ID
+   * @returns {Promise<Object>} Deletion confirmation
+   */
+  async deleteStorageConfiguration(id) {
+    this.sdk.validateParams(
+      { id },
+      {
+        id: { type: 'string', required: true },
+      },
+    );
+
+    const result = await this.sdk._fetch(
+      `/storage/configurations/${id}`,
+      'DELETE',
+    );
+    return result;
+  }
+
+  /**
+   * Update file contents and metadata
+   * @param {string} storageId - Storage file ID (required)
+   * @param {Object} params - Update parameters
+   * @param {Object} [params.file] - New file content (Buffer, File, or binary data)
+   * @param {string} [params.fileName] - New file name
+   * @param {string} [params.classification] - New classification
+   * @param {string} [params.folder] - New folder path
+   * @param {boolean} [params.isPublic] - Public access setting
+   * @param {string} [params.country] - Country setting
+   * @param {string} [params.expireAfter] - Expiration setting
+   * @param {string} [params.relatedId] - Related record ID
+   * @returns {Promise<Object>} Updated file details
+   */
+  async updateFile(
+    storageId,
+    {
+      file,
+      fileName,
+      classification,
+      folder,
+      isPublic,
+      country,
+      expireAfter,
+      relatedId,
+    },
+  ) {
+    this.sdk.validateParams(
+      { storageId },
+      {
+        storageId: { type: 'string', required: true },
+        file: { type: 'object', required: false },
+        fileName: { type: 'string', required: false },
+        classification: { type: 'string', required: false },
+        folder: { type: 'string', required: false },
+        isPublic: { type: 'boolean', required: false },
+        country: { type: 'string', required: false },
+        expireAfter: { type: 'string', required: false },
+        relatedId: { type: 'string', required: false },
+      },
+    );
+
+    if (file) {
+      // If updating file content, use multipart form data
+      const formFields = [];
+      if (classification) formFields.push(['classification', classification]);
+      if (folder) formFields.push(['folder', folder]);
+      if (fileName) formFields.push(['fileName', fileName]);
+      if (isPublic !== undefined)
+        formFields.push(['isPublic', isPublic.toString()]);
+      if (country) formFields.push(['country', country]);
+      if (expireAfter) formFields.push(['expireAfter', expireAfter]);
+      if (relatedId) formFields.push(['relatedId', relatedId]);
+
+      return this._performUpload(
+        file,
+        fileName,
+        formFields,
+        `/storage/${storageId}`,
+        'PUT',
+      );
+    } else {
+      // If only updating metadata, use JSON request
+      const updateData = {};
+      if (fileName !== undefined) updateData.fileName = fileName;
+      if (classification !== undefined)
+        updateData.classification = classification;
+      if (folder !== undefined) updateData.folder = folder;
+      if (isPublic !== undefined) updateData.isPublic = isPublic;
+      if (country !== undefined) updateData.country = country;
+      if (expireAfter !== undefined) updateData.expireAfter = expireAfter;
+      if (relatedId !== undefined) updateData.relatedId = relatedId;
+
+      const options = {
+        body: updateData,
+      };
+
+      const result = await this.sdk._fetch(
+        `/storage/${storageId}`,
+        'PUT',
+        options,
+      );
+      return result;
+    }
+  }
 }