proto.io 0.0.171 → 0.0.172

package/dist/index.mjs

@@ -848,7 +848,7 @@ class ProtoInternal {
         validateSchemaName(options.schema);
         const schema = mergeSchema(defaultSchema, options.fileStorage.schema, options.schema);
         validateSchema(schema);
-        if (!_.every(options.roleInheritKeys, k => {
+        if (!_.every(options.roleResolver?.inheritKeys, k => {
             const type = resolveDataType(schema, 'Role', k);
             return type && isRelation(type) && _.includes(['User', 'Role'], type.target);
         })) {
@@ -1354,7 +1354,7 @@ class ProtoService extends ProtoType {
     constructor(options) {
         super();
         this[PVK] = new ProtoInternal({
-            roleInheritKeys: [],
+            roleResolver: {},
             objectIdSize: 10,
             maxFetchLimit: 1000,
             maxUploadSize: 20 * 1024 * 1024,
@@ -1441,30 +1441,37 @@ class ProtoService extends ProtoType {
         return _.assign(payload, _.isFunction(attrs) ? attrs(payload) : attrs);
     }
     async userRoles(user) {
-        const roleInheritKeys = this[PVK].options.roleInheritKeys;
-        const schema = this.schema;
-        const userKeys = _.filter(roleInheritKeys, k => {
-            const type = resolveDataType(schema, 'Role', k);
-            return !!type && isRelation(type) && type.target === 'User';
-        });
-        const roleKeys = _.filter(roleInheritKeys, k => {
-            const type = resolveDataType(schema, 'Role', k);
-            return !!type && isRelation(type) && type.target === 'Role';
-        });
-        let queue = await this.Query('Role')
-            .or(_.map(_.uniq(['users', ...userKeys]), k => q => q.isIntersect(k, [user])))
-            .includes('name')
-            .find({ master: true });
-        let roles = queue;
-        while (!_.isEmpty(queue)) {
-            queue = await this.Query('Role')
-                .or(_.map(_.uniq(['roles', ...roleKeys]), k => q => q.isIntersect(k, queue)))
-                .notContainsIn('_id', _.compact(_.map(roles, x => x.objectId)))
+        const self = this;
+        const defaultResolver = async () => {
+            const inheritKeys = self[PVK].options.roleResolver?.inheritKeys ?? [];
+            const schema = self.schema;
+            const userKeys = _.filter(inheritKeys, k => {
+                const type = resolveDataType(schema, 'Role', k);
+                return !!type && isRelation(type) && type.target === 'User';
+            });
+            const roleKeys = _.filter(inheritKeys, k => {
+                const type = resolveDataType(schema, 'Role', k);
+                return !!type && isRelation(type) && type.target === 'Role';
+            });
+            let queue = await self.Query('Role')
+                .or(_.map(_.uniq(['users', ...userKeys]), k => q => q.isIntersect(k, [user])))
                 .includes('name')
                 .find({ master: true });
-            roles = _.uniqBy([...roles, ...queue], x => x.objectId);
-        }
-        return roles;
+            let roles = queue;
+            while (!_.isEmpty(queue)) {
+                queue = await self.Query('Role')
+                    .or(_.map(_.uniq(['roles', ...roleKeys]), k => q => q.isIntersect(k, queue)))
+                    .notContainsIn('_id', _.compact(_.map(roles, x => x.objectId)))
+                    .includes('name')
+                    .find({ master: true });
+                roles = _.uniqBy([...roles, ...queue], x => x.objectId);
+            }
+            return roles;
+        };
+        const resolver = self[PVK].options.roleResolver?.resolver;
+        if (resolver)
+            return resolver(user, defaultResolver);
+        return defaultResolver();
     }
     async becomeUser(req, user, options) {
         if (!user.objectId)