oak-domain 2.4.2 → 2.4.4

package/lib/base-app-domain/ModiEntity/Storage.js

@@ -12,7 +12,8 @@ exports.desc = {
             type: "varchar",
             params: {
                 length: 32
-            }
+            },
+            ref: ["user"]
         },
         entityId: {
             type: "varchar",

package/lib/base-app-domain/OperEntity/Storage.js

@@ -12,7 +12,8 @@ exports.desc = {
             type: "varchar",
             params: {
                 length: 32
-            }
+            },
+            ref: ["modi", "user"]
         },
         entityId: {
             type: "varchar",

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(...createRemoveCheckers<ED, Cxt>(schema));
     if (authDict) {
         checkers.push.apply(checkers, tslib_1.__spreadArray([], tslib_1.__read((0, checker_1.createAuthCheckers)(schema, authDict)), false));
     }

package/lib/compiler/schemalBuilder.js

@@ -2871,6 +2871,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':

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");
@@ -287,8 +287,19 @@ function translateCascadeRelationFilterMaker(schema, lch, entity2) {
     var cascadePath = lch.cascadePath, relations = lch.relations;
     var paths = cascadePath.split('.');
     var translateRelationFilter = function (entity) {
-        // 有两种情况，此entity和user有Relation定义，或是此entity上有userId
-        if (schema[entity].relation) {
+        // 有两种情况，此entity和user有Relation定义，或是此entity已经指向user
+        if (entity === 'user') {
+            return function (userId) { return ({
+                id: userId,
+            }); };
+        }
+        else if (schema[entity].relation) {
+            if (relations) {
+                var diff = (0, lodash_1.difference)(relations, schema[entity].relation);
+                if (diff.length > 0) {
+                    throw new Error("".concat(entity2, "\u4E0A\u67D0auth\u5B9A\u4E49\u7684relations\u4E2D\u542B\u6709\u4E0D\u53EF\u8BC6\u522B\u7684\u5173\u7CFB\u5B9A\u4E49").concat(diff.join(','), "\uFF0C \u8BF7\u4ED4\u7EC6\u68C0\u67E5"));
+                }
+            }
             var relationEntityName_1 = "user".concat((0, string_1.firstLetterUpperCase)(entity));
             return function (userId) {
                 var _a;
@@ -313,11 +324,9 @@ function translateCascadeRelationFilterMaker(schema, lch, entity2) {
                 };
             };
         }
-        var attributes = schema[entity].attributes;
-        (0, assert_1.default)(attributes.hasOwnProperty('userId') && attributes.userId.type === 'ref' && attributes.userId.ref === 'user', "\u5728".concat(entity, "\u4E0A\u65E2\u627E\u4E0D\u5230userId\uFF0C\u4E5F\u6CA1\u6709relation\u5B9A\u4E49"));
-        return function (userId) { return ({
-            userId: userId,
-        }); };
+        else {
+            (0, assert_1.default)(false, "".concat(entity2, "\u4E0A\u67D0auth\u5B9A\u4E49\u7684cascadePath").concat(cascadePath, "\u4E0D\u80FD\u5B9A\u4F4D\u5230User\u5BF9\u8C61\u6216\u8005\u548CUser\u5173\u8054\u7684\u5173\u7CFB\u5BF9\u8C61\uFF0C \u8BF7\u4ED4\u7EC6\u68C0\u67E5"));
+        }
     };
     var translateFilterMakerIter = function (entity, iter) {
         var relation = (0, relation_1.judgeRelation)(schema, entity, paths[iter]);
@@ -325,32 +334,23 @@ function translateCascadeRelationFilterMaker(schema, lch, entity2) {
             if (relation === 2) {
                 var filterMaker_1 = translateRelationFilter(paths[iter]);
                 return function (userId) {
-                    var _a;
                     var filter = filterMaker_1(userId);
-                    if (filter.$in) {
-                        return {
-                            entity: paths[iter],
-                            entityId: filter,
-                        };
-                    }
-                    return _a = {},
-                        _a[paths[iter]] = filter,
-                        _a;
+                    (0, assert_1.default)(filter.id);
+                    return {
+                        entity: paths[iter],
+                        entityId: filter.id,
+                    };
                 };
             }
             (0, assert_1.default)(typeof relation === 'string');
             var filterMaker_2 = translateRelationFilter(relation);
             return function (userId) {
-                var _a, _b;
+                var _a;
                 var filter = filterMaker_2(userId);
-                if (filter.$in) {
-                    return _a = {},
-                        _a["".concat(paths[iter], "Id")] = filter,
-                        _a;
-                }
-                return _b = {},
-                    _b[paths[iter]] = filter,
-                    _b;
+                (0, assert_1.default)(filter.id);
+                return _a = {},
+                    _a["".concat(paths[iter], "Id")] = filter.id,
+                    _a;
             };
         }
         else {
@@ -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'].includes(entity)) {
+            continue; // OperEntity会指向每一个对象，不必处理
+        }
+        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.intersection)(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/selection.js

@@ -230,6 +230,9 @@ function reinforceSelection(schema, entity, selection) {
                 }
             ]
         });
+        Object.assign(data, {
+            $$createAt$$: 1,
+        });
     }
 }
 exports.reinforceSelection = reinforceSelection;

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,14 @@ 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;
 interface TriggerBase<ED extends EntityDict, T extends keyof ED> {
     checkerType?: CheckerType;
     entity: T;

package/lib/types/Trigger.js

@@ -1,5 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CHECKER_DEFAULT_PRIORITY = exports.DATA_CHECKER_DEFAULT_PRIORITY = exports.TRIGGER_MAX_PRIORITY = exports.TRIGGER_MIN_PRIORITY = exports.TRIGGER_DEFAULT_PRIORITY = void 0;
+/**
+ * 优先级越小，越早执行。定义在1～99之间
+ */
+exports.TRIGGER_DEFAULT_PRIORITY = 50;
+exports.TRIGGER_MIN_PRIORITY = 1;
+exports.TRIGGER_MAX_PRIORITY = 99;
+exports.DATA_CHECKER_DEFAULT_PRIORITY = 60;
+exports.CHECKER_DEFAULT_PRIORITY = 99;
 ;
 ;
 ;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "oak-domain",
-    "version": "2.4.2",
+    "version": "2.4.4",
     "author": {
         "name": "XuChang"
     },