oak-domain 2.4.3 → 2.5.1

package/lib/base-app-domain/_SubQuery.d.ts

@@ -3,6 +3,7 @@ import * as ModiEntity from "./ModiEntity/Schema";
 import * as Oper from "./Oper/Schema";
 import * as OperEntity from "./OperEntity/Schema";
 import * as User from "./User/Schema";
+import * as UserEntityGrant from "./UserEntityGrant/Schema";
 export declare type ModiIdSubQuery = {
     [K in "$in" | "$nin"]?: (ModiEntity.ModiIdSubQuery & {
         entity: "modiEntity";
@@ -32,5 +33,12 @@ export declare type UserIdSubQuery = {
         entity: "oper";
     }) | (User.UserIdSubQuery & {
         entity: "user";
+    }) | (User.UserIdSubQuery & {
+        entity: "user";
+    }) | any;
+};
+export declare type UserEntityGrantIdSubQuery = {
+    [K in "$in" | "$nin"]?: (UserEntityGrant.UserEntityGrantIdSubQuery & {
+        entity: "userEntityGrant";
     }) | any;
 };

package/lib/checkers/index.js

@@ -7,6 +7,7 @@ var modi_1 = require("../store/modi");
 function createDynamicCheckers(schema, authDict) {
     var checkers = [];
     checkers.push.apply(checkers, tslib_1.__spreadArray([], tslib_1.__read((0, modi_1.createModiRelatedCheckers)(schema)), false));
+    checkers.push.apply(checkers, tslib_1.__spreadArray([], tslib_1.__read((0, checker_1.createRemoveCheckers)(schema)), false));
     if (authDict) {
         checkers.push.apply(checkers, tslib_1.__spreadArray([], tslib_1.__read((0, checker_1.createAuthCheckers)(schema, authDict)), false));
     }

package/lib/compiler/schemalBuilder.js

@@ -51,6 +51,20 @@ function addRelationship(many, one, key, notNull) {
             _b));
     }
 }
+/**
+ * 对relationship去重。一旦发生对象重定义这里就有可能重复
+ */
+function uniqRelationships() {
+    for (var entity in ManyToOne) {
+        ManyToOne[entity] = (0, lodash_1.uniqBy)(ManyToOne[entity], function (ele) { return "".concat(ele[0], "-").concat(ele[1]); });
+    }
+    for (var entity in OneToMany) {
+        OneToMany[entity] = (0, lodash_1.uniqBy)(OneToMany[entity], function (ele) { return "".concat(ele[0], "-").concat(ele[1]); });
+    }
+    for (var entity in ReversePointerRelations) {
+        OneToMany[entity] = (0, lodash_1.uniq)(OneToMany[entity]);
+    }
+}
 function createForeignRef(entity, foreignKey, ref) {
     if (entity === foreignKey) {
         return factory.createIdentifier(ref);
@@ -317,9 +331,10 @@ function analyzeEntity(filename, path, program, relativePath) {
     var sourceFile = program.getSourceFile(fullPath);
     var moduleName = filename.split('.')[0];
     if (Schema.hasOwnProperty(moduleName)) {
-        if (!path.includes('oak-general-business')) {
-            console.log("\u51FA\u73B0\u4E86\u540C\u540D\u7684Entity\u5B9A\u4E49\u300C".concat(moduleName, "\u300D\uFF0C\u5C06\u4F7F\u7528\u60A8\u6240\u5B9A\u4E49\u7684\u5BF9\u8C61\u7ED3\u6784\u53D6\u4EE3\u6389\u9ED8\u8BA4\u5BF9\u8C61\uFF0C\u8BF7\u786E\u8BA4"));
-        }
+        delete ActionAsts[moduleName];
+        delete SchemaAsts[moduleName];
+        // removeFromRelationShip(moduleName);
+        console.warn("\u51FA\u73B0\u4E86\u540C\u540D\u7684Entity\u5B9A\u4E49\u300C".concat(moduleName, "\u300D\uFF0C\u5C06\u4F7F\u7528").concat(fullPath, "\u53D6\u4EE3\u6389\u9ED8\u8BA4\u5BF9\u8C61\uFF0C\u8BF7\u68C0\u67E5\u65B0\u7684\u5BF9\u8C61\u7ED3\u6784\u53CA\u76F8\u5173\u5E38\u91CF\u5B9A\u4E49\u4E0E\u539F\u6709\u7684\u517C\u5BB9\uFF0C\u5426\u5219\u539F\u6709\u5BF9\u8C61\u7684\u76F8\u5173\u903B\u8F91\u4F1A\u51FA\u73B0\u4E0D\u53EF\u77E5\u5F02\u5E38"));
     }
     var referencedSchemas = [];
     var schemaAttrs = [];
@@ -340,7 +355,7 @@ function analyzeEntity(filename, path, program, relativePath) {
     // let relationHierarchy: ts.ObjectLiteralExpression | undefined = undefined;
     // let reverseCascadeRelationHierarchy: ts.ObjectLiteralExpression | undefined = undefined;
     ts.forEachChild(sourceFile, function (node) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e;
         if (ts.isImportDeclaration(node)) {
             var entityImported = getEntityImported(node);
             if (entityImported) {
@@ -389,7 +404,9 @@ function analyzeEntity(filename, path, program, relativePath) {
                                 && referencedSchemas.includes(typeArguments[0].typeName.text), "\u300C".concat(filename, "\u300D\u975E\u6CD5\u7684\u5C5E\u6027\u5B9A\u4E49\u300C").concat(attrName, "\u300D"));
                             var reverseEntity = typeArguments[0].typeName.text;
                             if (ReversePointerRelations[reverseEntity]) {
-                                ReversePointerRelations[reverseEntity].push(moduleName);
+                                if (!ReversePointerRelations[reverseEntity].includes(moduleName)) {
+                                    ReversePointerRelations[reverseEntity].push(moduleName);
+                                }
                             }
                             else {
                                 (0, lodash_1.assign)(ReversePointerRelations, (_a = {},
@@ -520,6 +537,9 @@ function analyzeEntity(filename, path, program, relativePath) {
                 if (hasRelationDef || moduleName === 'User') {
                     actionDefNodes.push(factory.createTypeReferenceNode('RelationAction', undefined));
                 }
+                if (process.env.COMPLING_AS_LIB) {
+                    actionDefNodes.push(factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword));
+                }
                 pushStatementIntoActionAst(moduleName, factory.createTypeAliasDeclaration(undefined, [factory.createModifier(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier("Action"), undefined, factory.createUnionTypeNode(actionDefNodes)), sourceFile);
                 dealWithActions(moduleName, filename, node.type, program, sourceFile, !!hasRelationDef || moduleName === 'User');
             }
@@ -558,12 +578,35 @@ function analyzeEntity(filename, path, program, relativePath) {
                     _d));
                 addRelationship(relationEntityName, 'User', 'user', true);
                 addRelationship(relationEntityName, moduleName, entityLc, true);
+                // 对UserEntityGrant对象，建立相应的反指关系
+                if (ReversePointerRelations['UserEntityGrant']) {
+                    if (!ReversePointerRelations['UserEntityGrant'].includes(moduleName)) {
+                        ReversePointerRelations['UserEntityGrant'].push(moduleName);
+                    }
+                }
+                else {
+                    (0, lodash_1.assign)(ReversePointerRelations, (_e = {},
+                        _e['UserEntityGrant'] = [moduleName],
+                        _e));
+                }
                 hasRelationDef = node;
             }
             else if (node.name.text.endsWith('Action') || node.name.text.endsWith('State')) {
                 (0, assert_1.default)(!localeDef, "\u3010".concat(filename, "\u3011locale\u5B9A\u4E49\u987B\u5728Action/State\u4E4B\u540E"));
                 hasActionOrStateDef = true;
-                pushStatementIntoActionAst(moduleName, factory.updateTypeAliasDeclaration(node, node.decorators, [factory.createModifier(ts.SyntaxKind.ExportKeyword)], node.name, node.typeParameters, node.type), sourceFile);
+                var type = node.type;
+                if (ts.isUnionTypeNode(type)) {
+                    pushStatementIntoActionAst(moduleName, factory.updateTypeAliasDeclaration(node, node.decorators, [factory.createModifier(ts.SyntaxKind.ExportKeyword)], node.name, node.typeParameters, process.env.COMPLING_AS_LIB ? factory.createUnionTypeNode(tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(type.types), false), [
+                        factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword)
+                    ], false)) : type), sourceFile);
+                }
+                else {
+                    (0, assert_1.default)(ts.isLiteralTypeNode(type) || ts.isTypeReferenceNode(type), "".concat(moduleName, " - ").concat(node.name));
+                    pushStatementIntoActionAst(moduleName, factory.updateTypeAliasDeclaration(node, node.decorators, [factory.createModifier(ts.SyntaxKind.ExportKeyword)], node.name, node.typeParameters, process.env.COMPLING_AS_LIB ? factory.createUnionTypeNode([
+                        type,
+                        factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword)
+                    ]) : type), sourceFile);
+                }
             }
             else if (beforeSchema) {
                 // 本地规定的一些形状定义，直接使用
@@ -2871,6 +2914,14 @@ function constructAttributes(entity) {
                         attrAssignments.push(factory.createPropertyAssignment(factory.createIdentifier("type"), factory.createStringLiteral("varchar")), factory.createPropertyAssignment(factory.createIdentifier("params"), factory.createObjectLiteralExpression([
                             factory.createPropertyAssignment(factory.createIdentifier("length"), factory.createNumericLiteral(typeArguments[0].literal.text)),
                         ], true)));
+                        // 如果是entity，在这里处理一下ref
+                        if (ts.isIdentifier(name) && name.text === 'entity') {
+                            var mtoRelations = ReversePointerRelations[entity];
+                            if (mtoRelations) {
+                                var mtoEntities = mtoRelations.map(function (ele) { return (0, string_1.firstLetterLowerCase)(ele); });
+                                attrAssignments.push(factory.createPropertyAssignment(factory.createIdentifier("ref"), factory.createArrayLiteralExpression(mtoEntities.map(function (ele) { return factory.createStringLiteral(ele); }), false)));
+                            }
+                        }
                         break;
                     }
                     case 'Text':
@@ -3283,6 +3334,7 @@ function analyzeEntities(inputDir, relativePath) {
         analyzeEntity(filename, inputDir, program, relativePath);
     });
     analyzeInModi();
+    uniqRelationships();
 }
 exports.analyzeEntities = analyzeEntities;
 function buildSchema(outputDir) {

package/lib/entities/User.d.ts

@@ -4,4 +4,5 @@ export interface Schema extends EntityShape {
     name?: String<16>;
     nickname?: String<64>;
     password?: Text;
+    ref?: Schema;
 }

package/lib/entities/User.js

@@ -1,12 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 ;
+var UserActionDef = {
+    stm: {
+        mergeTo: ['normal', 'merged'],
+    },
+};
 var locale = {
     zh_CN: {
         attr: {
             name: '姓名',
             nickname: '昵称',
             password: '密码',
+            ref: '指向用户',
+            userState: '状态',
+        },
+        action: {
+            mergeTo: '合并',
         },
+        v: {
+            userState: {
+                normal: '正常',
+                merged: '已被合并',
+            },
+        }
     },
 };

package/lib/entities/UserEntityGrant.d.ts

@@ -0,0 +1,7 @@
+import { String } from '../types/DataType';
+import { EntityShape } from '../types/Entity';
+export interface Schema extends EntityShape {
+    entity: String<32>;
+    entityId: String<64>;
+    relation: String<32>;
+}

package/lib/entities/UserEntityGrant.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+;
+var locale = {
+    zh_CN: {
+        attr: {
+            relation: '关系',
+            entity: '关联对象',
+            entityId: '关联对象id',
+        },
+    },
+};

package/lib/store/TriggerExecutor.js

@@ -6,6 +6,7 @@ var assert_1 = tslib_1.__importDefault(require("assert"));
 var lodash_1 = require("../utils/lodash");
 var filter_1 = require("../store/filter");
 var Entity_1 = require("../types/Entity");
+var Trigger_1 = require("../types/Trigger");
 var SyncRowStore_1 = require("./SyncRowStore");
 var checker_1 = require("./checker");
 /**
@@ -33,10 +34,11 @@ var TriggerExecutor = /** @class */ (function () {
         var entity = checker.entity, action = checker.action, type = checker.type, conditionalFilter = checker.conditionalFilter;
         var triggerName = "".concat(String(entity)).concat(action, "\u6743\u9650\u68C0\u67E5-").concat(this.counter++);
         var _a = (0, checker_1.translateCheckerInAsyncContext)(checker), fn = _a.fn, when = _a.when;
+        var priority = type === 'data' ? Trigger_1.DATA_CHECKER_DEFAULT_PRIORITY : Trigger_1.CHECKER_DEFAULT_PRIORITY; // checker的默认优先级最低（前面的trigger可能会赋上一些相应的值）
         var trigger = {
             checkerType: type,
             name: triggerName,
-            priority: checker.priority || 20,
+            priority: checker.priority || priority,
             entity: entity,
             action: action,
             fn: fn,
@@ -59,7 +61,10 @@ var TriggerExecutor = /** @class */ (function () {
             throw new Error("\u4E0D\u53EF\u6709\u540C\u540D\u7684\u89E6\u53D1\u5668\u300C".concat(trigger.name, "\u300D"));
         }
         if (typeof trigger.priority !== 'number') {
-            trigger.priority = 10; // 默认值
+            trigger.priority = Trigger_1.TRIGGER_DEFAULT_PRIORITY; // 默认值
+        }
+        else {
+            (0, assert_1.default)(trigger.priority <= Trigger_1.TRIGGER_MAX_PRIORITY && trigger.priority >= Trigger_1.TRIGGER_MIN_PRIORITY, "trigger\u300C".concat(trigger.name, "\u300D\u7684\u4F18\u5148\u7EA7\u5B9A\u4E49\u8D8A\u754C\uFF0C\u5E94\u8BE5\u5728").concat(Trigger_1.TRIGGER_MIN_PRIORITY, "\u5230").concat(Trigger_1.TRIGGER_MAX_PRIORITY, "\u4E4B\u95F4"));
         }
         if (trigger.filter) {
             (0, assert_1.default)(typeof trigger.action === 'string' && trigger.action !== 'create'

package/lib/store/checker.d.ts

@@ -10,4 +10,17 @@ export declare function translateCheckerInSyncContext<ED extends EntityDict & Ba
     fn: (operation: ED[T]['Operation'], context: Cxt, option: OperateOption | SelectOption) => void;
     when: 'before' | 'after';
 };
+/**
+ * 根据权限定义，创建出相应的checker
+ * @param schema
+ * @param authDict
+ * @returns
+ */
 export declare function createAuthCheckers<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED> | SyncContext<ED>>(schema: StorageSchema<ED>, authDict: AuthDefDict<ED>): Checker<ED, keyof ED, Cxt>[];
+/**
+ * 对对象的删除，检查其是否会产生其他行上的空指针，不允许这种情况的出现
+ * @param schema
+ * @returns
+ * 如果有的对象允许删除，需要使用trigger来处理其相关联的外键对象，这些trigger写作before，则会在checker之前执行，仍然可以删除成功
+ */
+export declare function createRemoveCheckers<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED> | SyncContext<ED>>(schema: StorageSchema<ED>): Checker<ED, keyof ED, Cxt>[];

package/lib/store/checker.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createAuthCheckers = exports.translateCheckerInSyncContext = exports.translateCheckerInAsyncContext = void 0;
+exports.createRemoveCheckers = exports.createAuthCheckers = exports.translateCheckerInSyncContext = exports.translateCheckerInAsyncContext = void 0;
 var tslib_1 = require("tslib");
 var assert_1 = tslib_1.__importDefault(require("assert"));
 var filter_1 = require("../store/filter");
@@ -392,6 +392,12 @@ function translateActionAuthFilterMaker(schema, relationItem, entity) {
     var filterMaker = translateCascadeRelationFilterMaker(schema, relationItem, entity);
     return function (userId) { return filterMaker(userId); };
 }
+/**
+ * 根据权限定义，创建出相应的checker
+ * @param schema
+ * @param authDict
+ * @returns
+ */
 function createAuthCheckers(schema, authDict) {
     var checkers = [];
     var _loop_1 = function (entity) {
@@ -496,3 +502,224 @@ function createAuthCheckers(schema, authDict) {
     return checkers;
 }
 exports.createAuthCheckers = createAuthCheckers;
+/**
+ * 对对象的删除，检查其是否会产生其他行上的空指针，不允许这种情况的出现
+ * @param schema
+ * @returns
+ * 如果有的对象允许删除，需要使用trigger来处理其相关联的外键对象，这些trigger写作before，则会在checker之前执行，仍然可以删除成功
+ */
+function createRemoveCheckers(schema) {
+    var e_1, _a;
+    var checkers = [];
+    // 先建立所有的一对多的关系
+    var OneToManyMatrix = {};
+    var OneToManyOnEntityMatrix = {};
+    var addToMto = function (e, f, attr) {
+        var _a;
+        if (OneToManyMatrix[f]) {
+            (_a = OneToManyMatrix[f]) === null || _a === void 0 ? void 0 : _a.push([e, attr]);
+        }
+        else {
+            OneToManyMatrix[f] = [[e, attr]];
+        }
+    };
+    var addToMtoEntity = function (e, fs) {
+        var e_2, _a;
+        var _b;
+        try {
+            for (var fs_1 = tslib_1.__values(fs), fs_1_1 = fs_1.next(); !fs_1_1.done; fs_1_1 = fs_1.next()) {
+                var f = fs_1_1.value;
+                if (!OneToManyOnEntityMatrix[f]) {
+                    OneToManyOnEntityMatrix[f] = [e];
+                }
+                else {
+                    (_b = OneToManyOnEntityMatrix[f]) === null || _b === void 0 ? void 0 : _b.push(e);
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (fs_1_1 && !fs_1_1.done && (_a = fs_1.return)) _a.call(fs_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+    };
+    for (var entity in schema) {
+        if (['operEntity', 'modiEntity', 'userEntityGrant'].includes(entity)) {
+            continue; // 系统功能性数据，不用处理
+        }
+        var attributes = schema[entity].attributes;
+        for (var attr in attributes) {
+            if (attributes[attr].type === 'ref') {
+                addToMto(entity, attributes[attr].ref, attr);
+            }
+            else if (attr === 'entity') {
+                if (attributes[attr].ref) {
+                    addToMtoEntity(entity, attributes[attr].ref);
+                }
+                else if (process.env.NODE_ENV === 'development') {
+                    console.warn("".concat(entity, "\u7684entity\u53CD\u6307\u6307\u9488\u627E\u4E0D\u5230\u6709\u6548\u7684\u5BF9\u8C61"));
+                }
+            }
+        }
+    }
+    // 当删除一时，要确认多上面没有指向一的数据
+    var entities = (0, lodash_1.union)(Object.keys(OneToManyMatrix), Object.keys(OneToManyOnEntityMatrix));
+    var _loop_3 = function (entity) {
+        checkers.push({
+            entity: entity,
+            action: 'remove',
+            type: 'logical',
+            checker: function (operation, context, option) {
+                var e_3, _a, e_4, _b;
+                var promises = [];
+                if (OneToManyMatrix[entity]) {
+                    var _loop_4 = function (otm) {
+                        var _g, _h, _j, _k;
+                        var _l = tslib_1.__read(otm, 2), e = _l[0], attr = _l[1];
+                        var proj = (_g = {
+                                id: 1
+                            },
+                            _g[attr] = 1,
+                            _g);
+                        var filter = operation.filter && (_h = {},
+                            _h[attr.slice(0, attr.length - 2)] = operation.filter,
+                            _h);
+                        var result = context.select(e, {
+                            data: proj,
+                            filter: filter,
+                            indexFrom: 0,
+                            count: 1
+                        }, { dontCollect: true });
+                        if (result instanceof Promise) {
+                            promises.push(result.then(function (_a) {
+                                var _b, _c;
+                                var _d = tslib_1.__read(_a, 1), row = _d[0];
+                                if (row) {
+                                    var record = {
+                                        a: 's',
+                                        d: (_b = {},
+                                            _b[e] = (_c = {},
+                                                _c[row.id] = row,
+                                                _c),
+                                            _b)
+                                    };
+                                    throw new Exception_1.OakRowInconsistencyException(record, "\u60A8\u65E0\u6CD5\u5220\u9664\u5B58\u5728\u6709\u6548\u6570\u636E\u300C".concat(e, "\u300D\u5173\u8054\u7684\u884C"));
+                                }
+                            }));
+                        }
+                        else {
+                            var _m = tslib_1.__read(result, 1), row = _m[0];
+                            if (row) {
+                                var record = {
+                                    a: 's',
+                                    d: (_j = {},
+                                        _j[e] = (_k = {},
+                                            _k[row.id] = row,
+                                            _k),
+                                        _j)
+                                };
+                                throw new Exception_1.OakRowInconsistencyException(record, "\u60A8\u65E0\u6CD5\u5220\u9664\u5B58\u5728\u6709\u6548\u6570\u636E\u300C".concat(e, "\u300D\u5173\u8054\u7684\u884C"));
+                            }
+                        }
+                    };
+                    try {
+                        for (var _c = (e_3 = void 0, tslib_1.__values(OneToManyMatrix[entity])), _d = _c.next(); !_d.done; _d = _c.next()) {
+                            var otm = _d.value;
+                            _loop_4(otm);
+                        }
+                    }
+                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                    finally {
+                        try {
+                            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                        }
+                        finally { if (e_3) throw e_3.error; }
+                    }
+                }
+                if (OneToManyOnEntityMatrix[entity]) {
+                    var _loop_5 = function (otm) {
+                        var _o, _p, _q;
+                        var proj = {
+                            id: 1,
+                            entity: 1,
+                            entityId: 1,
+                        };
+                        var filter = operation.filter && (_o = {},
+                            _o[entity] = operation.filter,
+                            _o);
+                        var result = context.select(otm, {
+                            data: proj,
+                            filter: filter,
+                            indexFrom: 0,
+                            count: 1
+                        }, { dontCollect: true });
+                        if (result instanceof Promise) {
+                            promises.push(result.then(function (_a) {
+                                var _b, _c;
+                                var _d = tslib_1.__read(_a, 1), row = _d[0];
+                                if (row) {
+                                    var record = {
+                                        a: 's',
+                                        d: (_b = {},
+                                            _b[otm] = (_c = {},
+                                                _c[row.id] = row,
+                                                _c),
+                                            _b)
+                                    };
+                                    throw new Exception_1.OakRowInconsistencyException(record, "\u60A8\u65E0\u6CD5\u5220\u9664\u5B58\u5728\u6709\u6548\u6570\u636E\u300C".concat(otm, "\u300D\u5173\u8054\u7684\u884C"));
+                                }
+                            }));
+                        }
+                        else {
+                            var _r = tslib_1.__read(result, 1), row = _r[0];
+                            if (row) {
+                                var record = {
+                                    a: 's',
+                                    d: (_p = {},
+                                        _p[otm] = (_q = {},
+                                            _q[row.id] = row,
+                                            _q),
+                                        _p)
+                                };
+                                throw new Exception_1.OakRowInconsistencyException(record, "\u60A8\u65E0\u6CD5\u5220\u9664\u5B58\u5728\u6709\u6548\u6570\u636E\u300C".concat(otm, "\u300D\u5173\u8054\u7684\u884C"));
+                            }
+                        }
+                    };
+                    try {
+                        for (var _e = (e_4 = void 0, tslib_1.__values(OneToManyOnEntityMatrix[entity])), _f = _e.next(); !_f.done; _f = _e.next()) {
+                            var otm = _f.value;
+                            _loop_5(otm);
+                        }
+                    }
+                    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                    finally {
+                        try {
+                            if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                        }
+                        finally { if (e_4) throw e_4.error; }
+                    }
+                }
+                if (promises.length > 0) {
+                    return Promise.all(promises).then(function () { return undefined; });
+                }
+            }
+        });
+    };
+    try {
+        for (var entities_1 = tslib_1.__values(entities), entities_1_1 = entities_1.next(); !entities_1_1.done; entities_1_1 = entities_1.next()) {
+            var entity = entities_1_1.value;
+            _loop_3(entity);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (entities_1_1 && !entities_1_1.done && (_a = entities_1.return)) _a.call(entities_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return checkers;
+}
+exports.createRemoveCheckers = createRemoveCheckers;

package/lib/store/modi.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createModiRelatedTriggers = exports.createModiRelatedCheckers = exports.abandonModis = exports.applyModis = exports.createOperationsFromModies = void 0;
 var tslib_1 = require("tslib");
+var types_1 = require("../types");
 var action_1 = require("../actions/action");
 var lodash_1 = require("../utils/lodash");
 var uuid_1 = require("../utils/uuid");
@@ -154,35 +155,52 @@ function createModiRelatedTriggers(schema) {
         if (inModi) {
             // 当关联modi的对象被删除时，对应的modi也删除
             triggers.push({
-                name: "\u5F53\u5220\u9664".concat(entity, "\u5BF9\u8C61\u65F6\uFF0C\u5220\u9664\u76F8\u5173\u8054\u8FD8\u6D3B\u8DC3\u7684modi"),
+                name: "\u5F53\u5220\u9664".concat(entity, "\u5BF9\u8C61\u65F6\uFF0C\u5220\u9664\u76F8\u5173\u8054\u7684modi\u7684modiEntity"),
                 action: 'remove',
                 entity: entity,
                 when: 'after',
+                priority: types_1.REMOVE_CASCADE_PRIORITY,
                 fn: function (_a, context, option) {
                     var operation = _a.operation;
                     return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                        var data, id, _b, _c, _d;
-                        var _e;
-                        return tslib_1.__generator(this, function (_f) {
-                            switch (_f.label) {
+                        var data, id, _b, _c, _d, _e, _f, _g;
+                        var _h, _j;
+                        return tslib_1.__generator(this, function (_k) {
+                            switch (_k.label) {
                                 case 0:
                                     data = operation.data;
                                     id = data.id;
                                     _c = (_b = context).operate;
-                                    _d = ['modi'];
-                                    _e = {};
+                                    _d = ['modiEntity'];
+                                    _h = {};
                                     return [4 /*yield*/, (0, uuid_1.generateNewIdAsync)()];
-                                case 1: return [4 /*yield*/, _c.apply(_b, _d.concat([(_e.id = _f.sent(),
-                                            _e.action = 'remove',
-                                            _e.data = {},
-                                            _e.filter = {
+                                case 1: return [4 /*yield*/, _c.apply(_b, _d.concat([(_h.id = _k.sent(),
+                                            _h.action = 'remove',
+                                            _h.data = {},
+                                            _h.filter = {
+                                                modi: {
+                                                    entity: entity,
+                                                    entityId: id,
+                                                },
+                                            },
+                                            _h), { dontCollect: true }]))];
+                                case 2:
+                                    _k.sent();
+                                    _f = (_e = context).operate;
+                                    _g = ['modi'];
+                                    _j = {};
+                                    return [4 /*yield*/, (0, uuid_1.generateNewIdAsync)()];
+                                case 3: return [4 /*yield*/, _f.apply(_e, _g.concat([(_j.id = _k.sent(),
+                                            _j.action = 'remove',
+                                            _j.data = {},
+                                            _j.filter = {
                                                 entity: entity,
                                                 entityId: id,
                                             },
-                                            _e), option]))];
-                                case 2:
-                                    _f.sent();
-                                    return [2 /*return*/, 1];
+                                            _j), { dontCollect: true }]))];
+                                case 4:
+                                    _k.sent();
+                                    return [2 /*return*/, 0];
                             }
                         });
                     });

package/lib/types/Auth.d.ts

@@ -12,7 +12,7 @@ export declare type DataChecker<ED extends EntityDict, T extends keyof ED, Cxt e
     type: 'data';
     entity: T;
     action: Omit<ED[T]['Action'], 'remove'> | Array<Omit<ED[T]['Action'], 'remove'>>;
-    checker: (data: ED[T]['Create']['data'] | ED[T]['Update']['data'], context: Cxt) => void | Promise<void>;
+    checker: (data: ED[T]['Create']['data'] | ED[T]['Update']['data'], context: Cxt) => any | Promise<any>;
     conditionalFilter?: ED[T]['Update']['filter'] | ((operation: ED[T]['Operation'], context: Cxt, option: OperateOption) => ED[T]['Update']['filter'] | Promise<ED[T]['Selection']['filter']>);
 };
 export declare type RowChecker<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = {
@@ -44,7 +44,7 @@ export declare type LogicalChecker<ED extends EntityDict, T extends keyof ED, Cx
     when?: 'after';
     entity: T;
     action: ED[T]['Action'] | Array<ED[T]['Action']>;
-    checker: (operation: ED[T]['Operation'] | ED[T]['Selection'], context: Cxt, option: OperateOption | SelectOption) => void | Promise<void>;
+    checker: (operation: ED[T]['Operation'] | ED[T]['Selection'], context: Cxt, option: OperateOption | SelectOption) => any | Promise<any>;
     conditionalFilter?: ED[T]['Update']['filter'] | ((operation: ED[T]['Operation'], context: Cxt, option: OperateOption) => ED[T]['Update']['filter']);
 };
 export declare type LogicalRelationChecker<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = {
@@ -53,7 +53,7 @@ export declare type LogicalRelationChecker<ED extends EntityDict, T extends keyo
     when?: 'after';
     entity: T;
     action: ED[T]['Action'] | Array<ED[T]['Action']>;
-    checker: (operation: ED[T]['Operation'] | ED[T]['Selection'], context: Cxt, option: OperateOption | SelectOption) => void | Promise<void>;
+    checker: (operation: ED[T]['Operation'] | ED[T]['Selection'], context: Cxt, option: OperateOption | SelectOption) => any | Promise<any>;
     conditionalFilter?: ED[T]['Update']['filter'] | ((operation: ED[T]['Operation'], context: Cxt, option: OperateOption) => ED[T]['Update']['filter']);
 };
 export declare type Checker<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = DataChecker<ED, T, Cxt> | RowChecker<ED, T, Cxt> | RelationChecker<ED, T, Cxt> | LogicalChecker<ED, T, Cxt> | LogicalRelationChecker<ED, T, Cxt>;

package/lib/types/Storage.d.ts

@@ -20,7 +20,7 @@ export interface Index<SH extends EntityShape> {
 export interface Attribute {
     type: DataType | Ref;
     params?: DataTypeParams;
-    ref?: string;
+    ref?: string | string[];
     onRefDelete?: 'delete' | 'setNull' | 'ignore';
     default?: string | number | boolean;
     notNull?: boolean;

package/lib/types/Trigger.d.ts

@@ -4,6 +4,15 @@ import { AsyncContext } from "../store/AsyncRowStore";
 import { SyncContext } from "../store/SyncRowStore";
 import { EntityDict, OperateOption } from "../types/Entity";
 import { EntityShape } from "../types/Entity";
+/**
+ * 优先级越小，越早执行。定义在1～99之间
+ */
+export declare const TRIGGER_DEFAULT_PRIORITY = 50;
+export declare const TRIGGER_MIN_PRIORITY = 1;
+export declare const TRIGGER_MAX_PRIORITY = 99;
+export declare const DATA_CHECKER_DEFAULT_PRIORITY = 60;
+export declare const CHECKER_DEFAULT_PRIORITY = 99;
+export declare const REMOVE_CASCADE_PRIORITY = 70;
 interface TriggerBase<ED extends EntityDict, T extends keyof ED> {
     checkerType?: CheckerType;
     entity: T;