@nocobase/acl 0.7.0-alpha.4 → 0.7.0-alpha.56

package/lib/acl-available-action.js

@@ -1,11 +1,18 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.AclAvailableAction = void 0;
+
 class AclAvailableAction {
-    constructor(name, options) {
-        this.name = name;
-        this.options = options;
-    }
+  constructor(name, options) {
+    this.name = void 0;
+    this.options = void 0;
+    this.name = name;
+    this.options = options;
+  }
+
 }
-exports.AclAvailableAction = AclAvailableAction;
-//# sourceMappingURL=acl-available-action.js.map
+
+exports.AclAvailableAction = AclAvailableAction;

package/lib/acl-available-strategy.js

@@ -1,68 +1,117 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ACLAvailableStrategy = exports.predicate = exports.strategyValueMatched = void 0;
-const lodash_1 = __importDefault(require("lodash"));
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.predicate = exports.ACLAvailableStrategy = void 0;
+exports.strategyValueMatched = strategyValueMatched;
+
+function _lodash() {
+  const data = _interopRequireDefault(require("lodash"));
+
+  _lodash = function _lodash() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
 function strategyValueMatched(strategy, value) {
-    if (strategy === '*') {
-        return true;
-    }
-    if (lodash_1.default.isString(strategy) && strategy === value) {
-        return true;
-    }
-    if (lodash_1.default.isArray(strategy) && strategy.includes(value)) {
-        return true;
-    }
-    return false;
+  if (strategy === '*') {
+    return true;
+  }
+
+  if (_lodash().default.isString(strategy) && strategy === value) {
+    return true;
+  }
+
+  if (_lodash().default.isArray(strategy) && strategy.includes(value)) {
+    return true;
+  }
+
+  return false;
 }
-exports.strategyValueMatched = strategyValueMatched;
-exports.predicate = {
-    own: {
-        filter: {
-            createdById: '{{ ctx.state.currentUser.id }}',
-        },
-    },
-    all: {},
+
+const predicate = {
+  own: {
+    filter: {
+      createdById: '{{ ctx.state.currentUser.id }}'
+    }
+  },
+  all: {}
 };
+exports.predicate = predicate;
+
 class ACLAvailableStrategy {
-    constructor(acl, options) {
-        this.acl = acl;
-        this.options = options;
-        this.allowConfigure = options.allowConfigure;
-        let actions = this.options.actions;
-        if (lodash_1.default.isString(actions) && actions != '*') {
-            actions = [actions];
-        }
-        if (lodash_1.default.isArray(actions)) {
-            this.actionsAsObject = actions.reduce((carry, action) => {
-                const [actionName, predicate] = action.split(':');
-                carry[actionName] = predicate;
-                return carry;
-            }, {});
-        }
+  constructor(acl, options) {
+    this.acl = void 0;
+    this.options = void 0;
+    this.actionsAsObject = void 0;
+    this.allowConfigure = void 0;
+    this.acl = acl;
+    this.options = options;
+    this.allowConfigure = options.allowConfigure;
+    let actions = this.options.actions;
+
+    if (_lodash().default.isString(actions) && actions != '*') {
+      actions = [actions];
     }
-    matchAction(actionName) {
-        var _a;
-        if (this.options.actions == '*') {
-            return true;
-        }
-        if ((_a = this.actionsAsObject) === null || _a === void 0 ? void 0 : _a.hasOwnProperty(actionName)) {
-            const predicateName = this.actionsAsObject[actionName];
-            if (predicateName) {
-                return exports.predicate[predicateName];
-            }
-            return true;
-        }
-        return false;
+
+    if (_lodash().default.isArray(actions)) {
+      this.actionsAsObject = actions.reduce((carry, action) => {
+        const _action$split = action.split(':'),
+              _action$split2 = _slicedToArray(_action$split, 2),
+              actionName = _action$split2[0],
+              predicate = _action$split2[1];
+
+        carry[actionName] = predicate;
+        return carry;
+      }, {});
     }
-    allow(resourceName, actionName) {
-        if (this.acl.isConfigResource(resourceName) && this.allowConfigure) {
-            return true;
-        }
-        return this.matchAction(this.acl.resolveActionAlias(actionName));
+  }
+
+  matchAction(actionName) {
+    var _this$actionsAsObject;
+
+    if (this.options.actions == '*') {
+      return true;
+    }
+
+    if ((_this$actionsAsObject = this.actionsAsObject) === null || _this$actionsAsObject === void 0 ? void 0 : _this$actionsAsObject.hasOwnProperty(actionName)) {
+      const predicateName = this.actionsAsObject[actionName];
+
+      if (predicateName) {
+        return predicate[predicateName];
+      }
+
+      return true;
+    }
+
+    return false;
+  }
+
+  allow(resourceName, actionName) {
+    if (this.acl.isConfigResource(resourceName) && this.allowConfigure) {
+      return true;
     }
+
+    return this.matchAction(this.acl.resolveActionAlias(actionName));
+  }
+
 }
-exports.ACLAvailableStrategy = ACLAvailableStrategy;
-//# sourceMappingURL=acl-available-strategy.js.map
+
+exports.ACLAvailableStrategy = ACLAvailableStrategy;

package/lib/acl-resource.js

@@ -1,46 +1,62 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.ACLResource = void 0;
+
 class ACLResource {
-    constructor(options) {
-        this.actions = new Map();
-        this.acl = options.role.acl;
-        this.role = options.role;
-        this.name = options.name;
-        const actionsOption = options.actions || {};
-        for (const actionName of Object.keys(actionsOption)) {
-            this.actions.set(actionName, actionsOption[actionName]);
-        }
+  constructor(options) {
+    this.actions = new Map();
+    this.acl = void 0;
+    this.role = void 0;
+    this.name = void 0;
+    this.acl = options.role.acl;
+    this.role = options.role;
+    this.name = options.name;
+    const actionsOption = options.actions || {};
+
+    for (var _i = 0, _Object$keys = Object.keys(actionsOption); _i < _Object$keys.length; _i++) {
+      const actionName = _Object$keys[_i];
+      this.actions.set(actionName, actionsOption[actionName]);
     }
-    getActions() {
-        return Array.from(this.actions.keys()).reduce((carry, key) => {
-            carry[key] = this.actions.get(key);
-            return carry;
-        }, {});
-    }
-    getAction(name) {
-        return this.actions.get(name) || this.actions.get(this.acl.resolveActionAlias(name));
-    }
-    setAction(name, params) {
-        const context = {
-            role: this.role,
-            acl: this.role.acl,
-            params: params || {},
-            path: `${this.name}:${name}`,
-            resourceName: this.name,
-            actionName: name,
-        };
-        this.acl.emit('beforeGrantAction', context);
-        this.actions.set(name, context.params);
-    }
-    setActions(actions) {
-        for (const actionName of Object.keys(actions)) {
-            this.setAction(actionName, actions[actionName]);
-        }
-    }
-    removeAction(name) {
-        this.actions.delete(name);
+  }
+
+  getActions() {
+    return Array.from(this.actions.keys()).reduce((carry, key) => {
+      carry[key] = this.actions.get(key);
+      return carry;
+    }, {});
+  }
+
+  getAction(name) {
+    return this.actions.get(name) || this.actions.get(this.acl.resolveActionAlias(name));
+  }
+
+  setAction(name, params) {
+    const context = {
+      role: this.role,
+      acl: this.role.acl,
+      params: params || {},
+      path: `${this.name}:${name}`,
+      resourceName: this.name,
+      actionName: name
+    };
+    this.acl.emit('beforeGrantAction', context);
+    this.actions.set(name, context.params);
+  }
+
+  setActions(actions) {
+    for (var _i2 = 0, _Object$keys2 = Object.keys(actions); _i2 < _Object$keys2.length; _i2++) {
+      const actionName = _Object$keys2[_i2];
+      this.setAction(actionName, actions[actionName]);
     }
+  }
+
+  removeAction(name) {
+    this.actions.delete(name);
+  }
+
 }
-exports.ACLResource = ACLResource;
-//# sourceMappingURL=acl-resource.js.map
+
+exports.ACLResource = ACLResource;

package/lib/acl-role.js

@@ -1,90 +1,162 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.ACLRole = void 0;
-const acl_resource_1 = require("./acl-resource");
+
+var _aclResource = require("./acl-resource");
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e2) { throw _e2; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e3) { didErr = true; err = _e3; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
 class ACLRole {
-    constructor(acl, name) {
-        this.acl = acl;
-        this.name = name;
-        this.resources = new Map();
+  constructor(acl, name) {
+    this.acl = void 0;
+    this.name = void 0;
+    this.strategy = void 0;
+    this.resources = new Map();
+    this.acl = acl;
+    this.name = name;
+  }
+
+  getResource(name) {
+    return this.resources.get(name);
+  }
+
+  setResource(name, resource) {
+    this.resources.set(name, resource);
+  }
+
+  setStrategy(value) {
+    this.strategy = value;
+  }
+
+  grantResource(resourceName, options) {
+    const resource = new _aclResource.ACLResource({
+      role: this,
+      name: resourceName
+    });
+
+    for (var _i = 0, _Object$entries = Object.entries(options); _i < _Object$entries.length; _i++) {
+      const _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+            actionName = _Object$entries$_i[0],
+            actionParams = _Object$entries$_i[1];
+
+      resource.setAction(actionName, actionParams);
     }
-    getResource(name) {
-        return this.resources.get(name);
+
+    this.resources.set(resourceName, resource);
+  }
+
+  getResourceActionsParams(resourceName) {
+    const resource = this.getResource(resourceName);
+    return resource.getActions();
+  }
+
+  revokeResource(resourceName) {
+    for (var _i2 = 0, _arr2 = [...this.resources.keys()]; _i2 < _arr2.length; _i2++) {
+      const key = _arr2[_i2];
+
+      if (key === resourceName || key.includes(`${resourceName}.`)) {
+        this.resources.delete(key);
+      }
     }
-    setResource(name, resource) {
-        this.resources.set(name, resource);
+  }
+
+  grantAction(path, options) {
+    let _this$getResourceActi = this.getResourceActionFromPath(path),
+        resource = _this$getResourceActi.resource,
+        resourceName = _this$getResourceActi.resourceName,
+        actionName = _this$getResourceActi.actionName;
+
+    if (!resource) {
+      resource = new _aclResource.ACLResource({
+        role: this,
+        name: resourceName
+      });
+      this.resources.set(resourceName, resource);
     }
-    setStrategy(value) {
-        this.strategy = value;
-    }
-    grantResource(resourceName, options) {
-        const resource = new acl_resource_1.ACLResource({
-            role: this,
-            name: resourceName,
-        });
-        for (const [actionName, actionParams] of Object.entries(options)) {
-            resource.setAction(actionName, actionParams);
-        }
-        this.resources.set(resourceName, resource);
-    }
-    getResourceActionsParams(resourceName) {
-        const resource = this.getResource(resourceName);
-        return resource.getActions();
-    }
-    revokeResource(resourceName) {
-        for (const key of [...this.resources.keys()]) {
-            if (key === resourceName || key.includes(`${resourceName}.`)) {
-                this.resources.delete(key);
-            }
-        }
-    }
-    grantAction(path, options) {
-        let { resource, resourceName, actionName } = this.getResourceActionFromPath(path);
-        if (!resource) {
-            resource = new acl_resource_1.ACLResource({
-                role: this,
-                name: resourceName,
-            });
-            this.resources.set(resourceName, resource);
+
+    resource.setAction(actionName, options);
+  }
+
+  getActionParams(path) {
+    const _this$getResourceActi2 = this.getResourceActionFromPath(path),
+          action = _this$getResourceActi2.action;
+
+    return action;
+  }
+
+  revokeAction(path) {
+    const _this$getResourceActi3 = this.getResourceActionFromPath(path),
+          resource = _this$getResourceActi3.resource,
+          actionName = _this$getResourceActi3.actionName;
+
+    resource.removeAction(actionName);
+  }
+
+  toJSON() {
+    const actions = {};
+
+    var _iterator = _createForOfIteratorHelper(this.resources.keys()),
+        _step;
+
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        const resourceName = _step.value;
+        const resourceActions = this.getResourceActionsParams(resourceName);
+
+        for (var _i3 = 0, _Object$keys = Object.keys(resourceActions); _i3 < _Object$keys.length; _i3++) {
+          const actionName = _Object$keys[_i3];
+          actions[`${resourceName}:${actionName}`] = resourceActions[actionName];
         }
-        resource.setAction(actionName, options);
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
     }
-    getActionParams(path) {
-        const { action } = this.getResourceActionFromPath(path);
-        return action;
-    }
-    revokeAction(path) {
-        const { resource, actionName } = this.getResourceActionFromPath(path);
-        resource.removeAction(actionName);
-    }
-    toJSON() {
-        const actions = {};
-        for (const resourceName of this.resources.keys()) {
-            const resourceActions = this.getResourceActionsParams(resourceName);
-            for (const actionName of Object.keys(resourceActions)) {
-                actions[`${resourceName}:${actionName}`] = resourceActions[actionName];
-            }
-        }
-        return {
-            role: this.name,
-            strategy: this.strategy,
-            actions,
-        };
-    }
-    getResourceActionFromPath(path) {
-        const [resourceName, actionName] = path.split(':');
-        const resource = this.resources.get(resourceName);
-        let action = null;
-        if (resource) {
-            action = resource.getAction(actionName);
-        }
-        return {
-            resourceName,
-            actionName,
-            resource,
-            action,
-        };
+
+    return {
+      role: this.name,
+      strategy: this.strategy,
+      actions
+    };
+  }
+
+  getResourceActionFromPath(path) {
+    const _path$split = path.split(':'),
+          _path$split2 = _slicedToArray(_path$split, 2),
+          resourceName = _path$split2[0],
+          actionName = _path$split2[1];
+
+    const resource = this.resources.get(resourceName);
+    let action = null;
+
+    if (resource) {
+      action = resource.getAction(actionName);
     }
+
+    return {
+      resourceName,
+      actionName,
+      resource,
+      action
+    };
+  }
+
 }
-exports.ACLRole = ACLRole;
-//# sourceMappingURL=acl-role.js.map
+
+exports.ACLRole = ACLRole;