roboto-js 1.7.4 → 1.8.1

package/dist/rbt_object.js

@@ -408,47 +408,490 @@ var RbtObject = /*#__PURE__*/function () {
       }
       return save;
     }()
+    /**
+     * Grants access to this object for specific users and/or user groups.
+     * Updates the IAC (Identity and Access Control) permissions.
+     * 
+     * @param {Object} options - Access grant options
+     * @param {string[]} [options.userIds=[]] - Array of user IDs to grant read access
+     * @param {string[]} [options.groupIds=[]] - Array of user group IDs to grant read access
+     * @param {boolean} [options.write=false] - If true, grants write access instead of read access
+     * @param {boolean} [options.replace=false] - If true, replaces existing grants; if false, merges with existing
+     * @param {boolean} [options.save=true] - If true, automatically saves the object after updating permissions
+     * @returns {Promise<RbtObject>} - Returns this object (saved if options.save is true)
+     * 
+     * @example
+     * // Grant read access to specific users
+     * await myObject.grantAccess({ 
+     *   userIds: ['user123', 'user456'] 
+     * });
+     * 
+     * @example
+     * // Grant read access to user groups
+     * await myObject.grantAccess({ 
+     *   groupIds: ['grpRngAccount', 'grpAdmins'] 
+     * });
+     * 
+     * @example
+     * // Grant write access to users and groups
+     * await myObject.grantAccess({ 
+     *   userIds: ['user123'],
+     *   groupIds: ['grpAdmins'],
+     *   write: true 
+     * });
+     * 
+     * @example
+     * // Replace existing permissions instead of merging
+     * await myObject.grantAccess({ 
+     *   userIds: ['user123'],
+     *   replace: true 
+     * });
+     * 
+     * @example
+     * // Update permissions without auto-saving
+     * await myObject.grantAccess({ 
+     *   userIds: ['user123'],
+     *   save: false 
+     * });
+     * // ... make other changes ...
+     * await myObject.save();
+     */
+  }, {
+    key: "grantAccess",
+    value: (function () {
+      var _grantAccess = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee4() {
+        var options,
+          _options$userIds,
+          userIds,
+          _options$groupIds,
+          groupIds,
+          _options$write,
+          write,
+          _options$replace,
+          replace,
+          _options$save,
+          save,
+          iac,
+          grantType,
+          existingUsers,
+          mergedUsers,
+          existingGroups,
+          mergedGroups,
+          _args4 = arguments;
+        return _regenerator().w(function (_context4) {
+          while (1) switch (_context4.n) {
+            case 0:
+              options = _args4.length > 0 && _args4[0] !== undefined ? _args4[0] : {};
+              _options$userIds = options.userIds, userIds = _options$userIds === void 0 ? [] : _options$userIds, _options$groupIds = options.groupIds, groupIds = _options$groupIds === void 0 ? [] : _options$groupIds, _options$write = options.write, write = _options$write === void 0 ? false : _options$write, _options$replace = options.replace, replace = _options$replace === void 0 ? false : _options$replace, _options$save = options.save, save = _options$save === void 0 ? true : _options$save; // Validate inputs
+              if (Array.isArray(userIds)) {
+                _context4.n = 1;
+                break;
+              }
+              throw new Error('userIds must be an array');
+            case 1:
+              if (Array.isArray(groupIds)) {
+                _context4.n = 2;
+                break;
+              }
+              throw new Error('groupIds must be an array');
+            case 2:
+              // Get current IAC settings
+              iac = this.get('iac') || {}; // Determine which grant type to update (read or write)
+              grantType = write ? 'writeGrants' : 'readGrants'; // Initialize grants if they don't exist
+              if (!iac[grantType]) {
+                iac[grantType] = {};
+              }
+
+              // Handle users
+              if (userIds.length > 0) {
+                if (replace) {
+                  // Replace existing users
+                  iac[grantType].users = _toConsumableArray(userIds);
+                } else {
+                  // Merge with existing users (avoiding duplicates)
+                  existingUsers = iac[grantType].users || [];
+                  mergedUsers = _toConsumableArray(new Set([].concat(_toConsumableArray(existingUsers), _toConsumableArray(userIds))));
+                  iac[grantType].users = mergedUsers;
+                }
+              }
+
+              // Handle user groups
+              if (groupIds.length > 0) {
+                if (replace) {
+                  // Replace existing groups
+                  iac[grantType].userGroups = _toConsumableArray(groupIds);
+                } else {
+                  // Merge with existing groups (avoiding duplicates)
+                  existingGroups = iac[grantType].userGroups || [];
+                  mergedGroups = _toConsumableArray(new Set([].concat(_toConsumableArray(existingGroups), _toConsumableArray(groupIds))));
+                  iac[grantType].userGroups = mergedGroups;
+                }
+              }
+
+              // Update the object
+              this.set('iac', iac);
+
+              // Save if requested
+              if (!save) {
+                _context4.n = 4;
+                break;
+              }
+              _context4.n = 3;
+              return this.save();
+            case 3:
+              return _context4.a(2, _context4.v);
+            case 4:
+              return _context4.a(2, this);
+          }
+        }, _callee4, this);
+      }));
+      function grantAccess() {
+        return _grantAccess.apply(this, arguments);
+      }
+      return grantAccess;
+    }()
+    /**
+     * Publishes this object to make it publicly accessible (or unpublishes it).
+     * Adds or removes 'public_user' from the IAC read permissions.
+     * 
+     * @param {Object} options - Publishing options
+     * @param {boolean} [options.publish=true] - If true, publishes the object; if false, unpublishes it
+     * @param {boolean} [options.save=true] - If true, automatically saves the object after updating permissions
+     * @returns {Promise<RbtObject>} - Returns this object (saved if options.save is true)
+     * 
+     * @example
+     * // Publish an object (make it public)
+     * await myObject.publishObject();
+     * 
+     * @example
+     * // Unpublish an object (make it private)
+     * await myObject.publishObject({ publish: false });
+     * 
+     * @example
+     * // Publish without auto-saving
+     * await myObject.publishObject({ save: false });
+     * // ... make other changes ...
+     * await myObject.save();
+     */
+    )
+  }, {
+    key: "publishObject",
+    value: (function () {
+      var _publishObject = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee5() {
+        var options,
+          _options$publish,
+          publish,
+          _options$save2,
+          save,
+          iac,
+          _args5 = arguments;
+        return _regenerator().w(function (_context5) {
+          while (1) switch (_context5.n) {
+            case 0:
+              options = _args5.length > 0 && _args5[0] !== undefined ? _args5[0] : {};
+              _options$publish = options.publish, publish = _options$publish === void 0 ? true : _options$publish, _options$save2 = options.save, save = _options$save2 === void 0 ? true : _options$save2; // Get current IAC settings
+              iac = this.get('iac') || {}; // Initialize readGrants if it doesn't exist
+              if (!iac.readGrants) {
+                iac.readGrants = {};
+              }
+
+              // Initialize users array if it doesn't exist
+              if (!Array.isArray(iac.readGrants.users)) {
+                iac.readGrants.users = [];
+              }
+              if (publish) {
+                // Add public_user if not already present
+                if (!iac.readGrants.users.includes('public_user')) {
+                  iac.readGrants.users.push('public_user');
+                }
+              } else {
+                // Remove public_user
+                iac.readGrants.users = iac.readGrants.users.filter(function (userId) {
+                  return userId !== 'public_user';
+                });
+              }
+
+              // Update the object
+              this.set('iac', iac);
+
+              // Save if requested
+              if (!save) {
+                _context5.n = 2;
+                break;
+              }
+              _context5.n = 1;
+              return this.save();
+            case 1:
+              return _context5.a(2, _context5.v);
+            case 2:
+              return _context5.a(2, this);
+          }
+        }, _callee5, this);
+      }));
+      function publishObject() {
+        return _publishObject.apply(this, arguments);
+      }
+      return publishObject;
+    }()
+    /**
+     * Unpublishes this object to remove public access.
+     * Removes 'public_user' from the IAC read permissions.
+     * This is an alias for publishObject({ publish: false }) for better code clarity.
+     * 
+     * @param {Object} options - Unpublishing options
+     * @param {boolean} [options.save=true] - If true, automatically saves the object after updating permissions
+     * @returns {Promise<RbtObject>} - Returns this object (saved if options.save is true)
+     * 
+     * @example
+     * // Unpublish an object (remove public access)
+     * await myObject.unpublishObject();
+     * 
+     * @example
+     * // Unpublish without auto-saving
+     * await myObject.unpublishObject({ save: false });
+     * // ... make other changes ...
+     * await myObject.save();
+     */
+    )
+  }, {
+    key: "unpublishObject",
+    value: (function () {
+      var _unpublishObject = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee6() {
+        var options,
+          _args6 = arguments;
+        return _regenerator().w(function (_context6) {
+          while (1) switch (_context6.n) {
+            case 0:
+              options = _args6.length > 0 && _args6[0] !== undefined ? _args6[0] : {};
+              _context6.n = 1;
+              return this.publishObject({
+                publish: false,
+                save: options.save !== undefined ? options.save : true
+              });
+            case 1:
+              return _context6.a(2, _context6.v);
+          }
+        }, _callee6, this);
+      }));
+      function unpublishObject() {
+        return _unpublishObject.apply(this, arguments);
+      }
+      return unpublishObject;
+    }()
+    /**
+     * Revokes access from specific users and/or user groups.
+     * 
+     * @param {Object} options - Access revocation options
+     * @param {string[]} [options.userIds=[]] - Array of user IDs to remove from read or write access
+     * @param {string[]} [options.groupIds=[]] - Array of group IDs to remove from read or write access
+     * @param {boolean} [options.write=false] - If true, removes write access; if false, removes read access
+     * @param {boolean} [options.save=true] - If true, automatically saves the object after updating permissions
+     * @returns {Promise<RbtObject>} - Returns this object (saved if options.save is true)
+     * 
+     * @example
+     * // Revoke read access from specific users
+     * await myObject.revokeAccess({ 
+     *   userIds: ['user_123', 'user_456'] 
+     * });
+     * 
+     * @example
+     * // Revoke write access from specific groups
+     * await myObject.revokeAccess({ 
+     *   groupIds: ['grpEditors'],
+     *   write: true 
+     * });
+     * 
+     * @example
+     * // Revoke access from users and groups
+     * await myObject.revokeAccess({ 
+     *   userIds: ['user_123'],
+     *   groupIds: ['grpViewers']
+     * });
+     * 
+     * @example
+     * // Revoke without auto-saving
+     * await myObject.revokeAccess({ 
+     *   userIds: ['user_123'],
+     *   save: false 
+     * });
+     */
+    )
+  }, {
+    key: "revokeAccess",
+    value: (function () {
+      var _revokeAccess = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee7() {
+        var options,
+          _options$userIds2,
+          userIds,
+          _options$groupIds2,
+          groupIds,
+          _options$write2,
+          write,
+          _options$save3,
+          save,
+          iac,
+          grantType,
+          _args7 = arguments;
+        return _regenerator().w(function (_context7) {
+          while (1) switch (_context7.n) {
+            case 0:
+              options = _args7.length > 0 && _args7[0] !== undefined ? _args7[0] : {};
+              _options$userIds2 = options.userIds, userIds = _options$userIds2 === void 0 ? [] : _options$userIds2, _options$groupIds2 = options.groupIds, groupIds = _options$groupIds2 === void 0 ? [] : _options$groupIds2, _options$write2 = options.write, write = _options$write2 === void 0 ? false : _options$write2, _options$save3 = options.save, save = _options$save3 === void 0 ? true : _options$save3; // Validate inputs
+              if (Array.isArray(userIds)) {
+                _context7.n = 1;
+                break;
+              }
+              throw new Error('userIds must be an array');
+            case 1:
+              if (Array.isArray(groupIds)) {
+                _context7.n = 2;
+                break;
+              }
+              throw new Error('groupIds must be an array');
+            case 2:
+              // Get current IAC settings
+              iac = this.get('iac') || {}; // Determine which grant type to update (read or write)
+              grantType = write ? 'writeGrants' : 'readGrants'; // Initialize grants if they don't exist
+              if (!iac[grantType]) {
+                iac[grantType] = {};
+              }
+
+              // Remove specified users
+              if (userIds.length > 0 && Array.isArray(iac[grantType].users)) {
+                iac[grantType].users = iac[grantType].users.filter(function (userId) {
+                  return !userIds.includes(userId);
+                });
+              }
+
+              // Remove specified groups
+              if (groupIds.length > 0 && Array.isArray(iac[grantType].userGroups)) {
+                iac[grantType].userGroups = iac[grantType].userGroups.filter(function (groupId) {
+                  return !groupIds.includes(groupId);
+                });
+              }
+
+              // Update the object
+              this.set('iac', iac);
+
+              // Save if requested
+              if (!save) {
+                _context7.n = 4;
+                break;
+              }
+              _context7.n = 3;
+              return this.save();
+            case 3:
+              return _context7.a(2, _context7.v);
+            case 4:
+              return _context7.a(2, this);
+          }
+        }, _callee7, this);
+      }));
+      function revokeAccess() {
+        return _revokeAccess.apply(this, arguments);
+      }
+      return revokeAccess;
+    }()
+    /**
+     * Checks if this object is currently published (publicly accessible).
+     * 
+     * @returns {boolean} - True if 'public_user' is in the read grants, false otherwise
+     * 
+     * @example
+     * if (myObject.isPublished()) {
+     *   console.log('Object is public');
+     * }
+     */
+    )
+  }, {
+    key: "isPublished",
+    value: function isPublished() {
+      var iac = this.get('iac');
+      if (!iac || !iac.readGrants || !Array.isArray(iac.readGrants.users)) {
+        return false;
+      }
+      return iac.readGrants.users.includes('public_user');
+    }
+
+    /**
+     * Gets the current sharing permissions for this object.
+     * 
+     * @returns {Object} - Object containing read and write grants
+     * @returns {Object} returns.readGrants - Read access grants
+     * @returns {string[]} returns.readGrants.users - Array of user IDs with read access
+     * @returns {string[]} returns.readGrants.userGroups - Array of group IDs with read access
+     * @returns {string[]} returns.readGrants.organizations - Array of organization IDs with read access
+     * @returns {Object} returns.writeGrants - Write access grants
+     * @returns {string[]} returns.writeGrants.users - Array of user IDs with write access
+     * @returns {string[]} returns.writeGrants.userGroups - Array of group IDs with write access
+     * @returns {string[]} returns.writeGrants.organizations - Array of organization IDs with write access
+     * 
+     * @example
+     * const permissions = myObject.getSharing();
+     * console.log('Read users:', permissions.readGrants.users);
+     * console.log('Read groups:', permissions.readGrants.userGroups);
+     */
+  }, {
+    key: "getSharing",
+    value: function getSharing() {
+      var _iac$readGrants, _iac$readGrants2, _iac$readGrants3, _iac$readGrants4, _iac$writeGrants, _iac$writeGrants2, _iac$writeGrants3, _iac$writeGrants4;
+      var iac = this.get('iac') || {};
+      return {
+        readGrants: {
+          users: ((_iac$readGrants = iac.readGrants) === null || _iac$readGrants === void 0 ? void 0 : _iac$readGrants.users) || [],
+          userGroups: ((_iac$readGrants2 = iac.readGrants) === null || _iac$readGrants2 === void 0 ? void 0 : _iac$readGrants2.userGroups) || [],
+          organizations: ((_iac$readGrants3 = iac.readGrants) === null || _iac$readGrants3 === void 0 ? void 0 : _iac$readGrants3.organizations) || [],
+          userSegments: ((_iac$readGrants4 = iac.readGrants) === null || _iac$readGrants4 === void 0 ? void 0 : _iac$readGrants4.userSegments) || []
+        },
+        writeGrants: {
+          users: ((_iac$writeGrants = iac.writeGrants) === null || _iac$writeGrants === void 0 ? void 0 : _iac$writeGrants.users) || [],
+          userGroups: ((_iac$writeGrants2 = iac.writeGrants) === null || _iac$writeGrants2 === void 0 ? void 0 : _iac$writeGrants2.userGroups) || [],
+          organizations: ((_iac$writeGrants3 = iac.writeGrants) === null || _iac$writeGrants3 === void 0 ? void 0 : _iac$writeGrants3.organizations) || [],
+          userSegments: ((_iac$writeGrants4 = iac.writeGrants) === null || _iac$writeGrants4 === void 0 ? void 0 : _iac$writeGrants4.userSegments) || []
+        }
+      };
+    }
   }, {
     key: "delete",
     value: function () {
-      var _delete2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee4() {
+      var _delete2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee8() {
         var record, response, _t2;
-        return _regenerator().w(function (_context4) {
-          while (1) switch (_context4.p = _context4.n) {
+        return _regenerator().w(function (_context8) {
+          while (1) switch (_context8.p = _context8.n) {
             case 0:
               if (this._internalData.type) {
-                _context4.n = 1;
+                _context8.n = 1;
                 break;
               }
               throw new Error('Cannot delete object without type');
             case 1:
-              _context4.p = 1;
+              _context8.p = 1;
               record = this.toRecord();
-              _context4.n = 2;
+              _context8.n = 2;
               return this._axios.post('/object_service/deleteObject', {
                 id: record.id,
                 type: record.type
               });
             case 2:
-              response = _context4.v;
+              response = _context8.v;
               if (!(response.data.ok === false)) {
-                _context4.n = 3;
+                _context8.n = 3;
                 break;
               }
               throw new Error(response.data.message);
             case 3:
               this._internalData = response.data;
-              return _context4.a(2, this);
+              return _context8.a(2, this);
             case 4:
-              _context4.p = 4;
-              _t2 = _context4.v;
+              _context8.p = 4;
+              _t2 = _context8.v;
               console.log('RbtObject.delete.error:');
               console.log(_t2.response.data);
               throw _t2;
             case 5:
-              return _context4.a(2);
+              return _context8.a(2);
           }
-        }, _callee4, this, [[1, 4]]);
+        }, _callee8, this, [[1, 4]]);
       }));
       function _delete() {
         return _delete2.apply(this, arguments);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roboto-js",
-  "version": "1.7.4",
+  "version": "1.8.1",
   "type": "module",
   "description": "",
   "main": "dist/cjs/index.cjs",

package/src/rbt_api.js

@@ -693,6 +693,10 @@ export default class RbtApi {
    * - limit: An object to control the pagination of results. It includes:
    *    - offset: The starting point from where to fetch the results.
    *    - results: The maximum number of results to return.
+   * - requestAttrs: An array of attribute paths to include in the response (e.g., ['id', 'configs.title', 'configs.description']).
+   *                 If not provided, all attributes are returned.
+   * - excludeAttrs: An array of attribute paths to exclude from the response (e.g., ['details.log', 'internalData']).
+   *                 Excludes the specified paths and all their subpaths.
    * - resolveReferences: An array of attribute names whose references should be resolved in the returned objects.
    * - timeout: A numerical value in milliseconds to set a maximum time limit for the query execution.
    *
@@ -701,6 +705,8 @@ export default class RbtApi {
    *     where: 'email="tom@pospa.com"',
    *     orderBy: { column: 'timeCreated', direction: 'DESC' },
    *     limit: { offset: 0, results: 50 },
+   *     requestAttrs: ['id', 'configs.title'],
+   *     excludeAttrs: ['details.log'],
    *     resolveReferences: ['translatableContent']
    *   });
    *
@@ -712,6 +718,19 @@ export default class RbtApi {
     let paramsKey;
     try {
       //console.log('RBTAPI.query INIT', type, params);
+      
+      // Validate parameters - reject invalid parameter names
+      const validParams = ['type', 'where', 'orderBy', 'limit', 'resolveReferences', 'requestAttrs', 'excludeAttrs', 'timeout', 'enableRealtime'];
+      const invalidParams = Object.keys(params).filter(key => !validParams.includes(key));
+      if (invalidParams.length > 0) {
+        throw new Error(`Invalid query parameter(s): ${invalidParams.join(', ')}. Valid parameters are: ${validParams.join(', ')}`);
+      }
+      
+      // Warn if enableRealtime is passed to query() - it should only be used by load()
+      if (params.enableRealtime) {
+        console.warn('[roboto-js] enableRealtime should not be passed to query(), only to load(). This parameter will be ignored.');
+      }
+      
       params.type = type;
 
       // Default ordering and pagination
@@ -843,7 +862,9 @@ export default class RbtApi {
             this._loggedCacheEvents.add(bulkMissLogKey);
           }
           
-          mergedParams = { ...params, where: `id IN ("${missingIds.join(`","`)}")` };
+          // Remove load-specific params that shouldn't be passed to query
+          const { enableRealtime, ...queryParams } = params;
+          mergedParams = { ...queryParams, where: `id IN ("${missingIds.join(`","`)}")` };
           loadedObjects = await this.query(type, mergedParams);
           
           // Cache the newly loaded objects
@@ -913,7 +934,9 @@ export default class RbtApi {
         // Create the loading promise and store it to prevent duplicate requests
         const loadPromise = (async () => {
           try {
-            mergedParams = { ...params, where: `id="${ids}"` };
+            // Remove load-specific params that shouldn't be passed to query
+            const { enableRealtime, ...queryParams } = params;
+            mergedParams = { ...queryParams, where: `id="${ids}"` };
             let res = await this.query(type, mergedParams);
             const obj = res[0];