将getUserIdsByActions移到了domain中

lib/store/RelationAuth.d.ts

@@ -102,3 +102,14 @@ export declare class RelationAuth<ED extends EntityDict & BaseEntityDict> {
      */
     private checkActions2;
 }
+/**
+ * 获取有对entity进行actions操作权限的用户Id（不包含root）
+ * @param params
+ * @param context
+ */
+export declare function getUserIdsByActions<ED extends EntityDict & BaseEntityDict, T extends keyof ED, Cxt extends AsyncContext<ED>>(params: {
+    entity: T;
+    entityId: string;
+    actions: ED[T]['Action'][];
+    overlap?: boolean;
+}, context: Cxt): Promise<string[]>;

lib/store/RelationAuth.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RelationAuth = void 0;
+exports.getUserIdsByActions = exports.RelationAuth = void 0;
 var tslib_1 = require("tslib");
 var assert_1 = tslib_1.__importDefault(require("assert"));
 var types_1 = require("../types");
@@ -2059,3 +2059,62 @@ var RelationAuth = /** @class */ (function () {
     return RelationAuth;
 }());
 exports.RelationAuth = RelationAuth;
+;
+/**
+ * 获取有对entity进行actions操作权限的用户Id（不包含root）
+ * @param params
+ * @param context
+ */
+function getUserIdsByActions(params, context) {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var entity, entityId, actions, overlap, filter, actionAuths, userRelations;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    entity = params.entity, entityId = params.entityId, actions = params.actions, overlap = params.overlap;
+                    filter = {
+                        destEntity: entity,
+                        relation: {
+                            entity: entity,
+                            entityId: entityId,
+                        },
+                    };
+                    if (overlap) {
+                        Object.assign(filter, {
+                            deActions: {
+                                $overlaps: actions,
+                            },
+                        });
+                    }
+                    else {
+                        Object.assign(filter, {
+                            deActions: {
+                                $contains: actions,
+                            },
+                        });
+                    }
+                    return [4 /*yield*/, context.select('actionAuth', {
+                            data: {
+                                id: 1,
+                                relation: {
+                                    id: 1,
+                                    userRelation$relation: {
+                                        $entity: 'userRelation',
+                                        data: {
+                                            id: 1,
+                                            userId: 1,
+                                        },
+                                    },
+                                },
+                            },
+                            filter: filter,
+                        }, { dontCollect: true })];
+                case 1:
+                    actionAuths = _a.sent();
+                    userRelations = actionAuths.map(function (ele) { return ele.relation.userRelation$relation; });
+                    return [2 /*return*/, (0, lodash_1.uniq)(Array.prototype.concat.apply([], userRelations).map(function (ele) { return ele.userId; }))];
+            }
+        });
+    });
+}
+exports.getUserIdsByActions = getUserIdsByActions;

src/store/RelationAuth.ts

@@ -2493,4 +2493,58 @@ export class RelationAuth<ED extends EntityDict & BaseEntityDict>{
             }
         }
     }
+};
+
+/**
+ * 获取有对entity进行actions操作权限的用户Id（不包含root）
+ * @param params 
+ * @param context 
+ */
+ export async function getUserIdsByActions<ED extends EntityDict & BaseEntityDict, T extends keyof ED, Cxt extends AsyncContext<ED>>(params: {
+    entity: T;
+    entityId: string;
+    actions: ED[T]['Action'][];
+    overlap?: boolean;
+}, context: Cxt) {
+    const { entity, entityId, actions, overlap } = params;
+    const filter = {
+        destEntity: entity as string,
+        relation: {
+            entity: entity as string,
+            entityId,
+        },
+    };
+    if (overlap) {
+        Object.assign(filter, {
+            deActions: {
+                $overlaps: actions,
+            },
+        });
+    }
+    else {
+        Object.assign(filter, {
+            deActions: {
+                $contains: actions,
+            },
+        });
+    }
+    const actionAuths = await context.select('actionAuth', {
+        data: {
+            id: 1,
+            relation: {
+                id: 1,
+                userRelation$relation: {
+                    $entity: 'userRelation',
+                    data: {
+                        id: 1,
+                        userId: 1,
+                    },
+                },
+            },
+        },
+        filter,
+    }, { dontCollect: true });
+
+    const userRelations = actionAuths.map(ele => ele.relation!.userRelation$relation!);
+    return uniq(Array.prototype.concat.apply([], userRelations).map(ele => ele.userId)) as string[];
 }