oak-domain 1.1.13 → 2.0.1

package/lib/store/filter.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeTreeDescendantFilter = exports.makeTreeAncestorFilter = exports.same = exports.getRelevantIds = exports.repel = exports.contains = exports.combineFilters = exports.unionFilterSegment = exports.addFilterSegment = void 0;
+exports.checkFilterContains = exports.makeTreeDescendantFilter = exports.makeTreeAncestorFilter = exports.same = exports.getRelevantIds = exports.repel = exports.contains = exports.combineFilters = exports.unionFilterSegment = exports.addFilterSegment = void 0;
 var tslib_1 = require("tslib");
 var assert_1 = tslib_1.__importDefault(require("assert"));
+var types_1 = require("../types");
 var lodash_1 = require("../utils/lodash");
+var relation_1 = require("./relation");
 function addFilterSegment() {
     var filters = [];
     for (var _i = 0; _i < arguments.length; _i++) {
@@ -96,6 +98,371 @@ function combineFilters(filters, union) {
 }
 exports.combineFilters = combineFilters;
 /**
+ * 判断value1表达的单个属性查询与同属性上value2表达的查询是相容还是相斥
+ * 相容即value2所表达的查询结果一定符合value1表达的查询结果，例如：
+ * value1: {
+ *  $gt: 8,
+ * }
+ * value2: {
+ *  $eq: 12
+ * }
+ * 此时value1相容value2
+ *
+ * 相斥即value1所表达的查询结果与value2一定毫无联系，例如：
+ * value1: {
+ *  $gt: 8,
+ * }
+ * value2: {
+ *  $lt: 2,
+ * }
+ * @param value1
+ * @param value2
+ */
+function judgeFilterValueRelation(value1, value2, contained) {
+    if (typeof value1 === 'object') {
+        var attr = Object.keys(value1)[0];
+        if (['$gt', '$lt', '$gte', '$lte', '$eq', '$ne',
+            '$startsWith', '$endsWith', '$includes'].includes(attr)) {
+            switch (attr) {
+                case '$gt': {
+                    if (typeof value2 === 'object') {
+                        var attr2 = Object.keys(value2)[0];
+                        return attr2 === '$gt' && value2[attr2] >= value1.$gt
+                            || ['$gte', '$eq'].includes(attr2) && value2[attr2] > value1.$gt
+                            || attr2 === '$in' && value2[attr2] instanceof Array && !((value2[attr2]).find(function (ele) { return typeof ele !== typeof value1.$gt || ele <= value1.$gt; }));
+                    }
+                    else {
+                        return value2 > value1.$gt;
+                    }
+                }
+                case '$gte': {
+                    if (typeof value2 === 'object') {
+                        var attr2 = Object.keys(value2)[0];
+                        return attr2 === '$gt' && value2[attr2] > value1.$gte
+                            || ['$gte', '$eq'].includes(attr2) && value2[attr2] >= value1.$gte
+                            || attr2 === '$in' && value2[attr2] instanceof Array && !((value2[attr2]).find(function (ele) { return typeof ele !== typeof value1.$gte || ele < value1.$gte; }));
+                    }
+                    else {
+                        return value2 >= value1.$gt;
+                    }
+                }
+                case '$lt': {
+                    if (typeof value2 === 'object') {
+                        var attr2 = Object.keys(value2)[0];
+                        return attr2 === '$lt' && value2[attr2] <= value1.$lt
+                            || ['$lte', '$eq'].includes(attr2) && value2[attr2] < value1.$lt
+                            || attr2 === '$in' && value2[attr2] instanceof Array && !(value2[attr2]).find(function (ele) { return typeof ele !== typeof value1.$lt || ele >= value1.$lt; });
+                    }
+                    else {
+                        return value2 < value1.$lt;
+                    }
+                }
+                case '$lte': {
+                    if (typeof value2 === 'object') {
+                        var attr2 = Object.keys(value2)[0];
+                        return attr2 === '$lt' && value2[attr2] < value1.$lte
+                            || ['$lte', '$eq'].includes(attr2) && value2[attr2] <= value1.$lte
+                            || attr2 === '$in' && value2[attr2] instanceof Array && !(value2[attr2].find(function (ele) { return typeof ele !== typeof value1.$lte || ele > value1.$lte; }));
+                    }
+                    else {
+                        return value2 <= value1.$lte;
+                    }
+                }
+                case '$eq': {
+                    if (typeof value2 === 'object') {
+                        var attr2 = Object.keys(value2)[0];
+                        return attr2 === '$eq' && value2[attr2] === value1.$eq;
+                    }
+                    else {
+                        return value2 === value1.$eq;
+                    }
+                }
+                case '$ne': {
+                    if (typeof value2 === 'object') {
+                        var attr2 = Object.keys(value2)[0];
+                        return attr2 === '$eq' && value2[attr2] !== value1.$ne
+                            || attr2 === '$ne' && value2[attr2] === value1.$ne
+                            || attr2 === '$gt' && value2[attr2] >= value1.$ne
+                            || attr2 === '$gte' && value2[attr2] > value1.$ne
+                            || attr2 === '$lt' && value2[attr2] <= value1.$ne
+                            || attr2 === '$in' && value2[attr2] instanceof Array && !((value2[attr2]).find(function (ele) { return ele === value1.$ne; }))
+                            || attr2 === '$nin' && value2[attr2] instanceof Array && !!(value2[attr2]).find(function (ele) { return ele === value1.$ne; });
+                    }
+                    else {
+                        return value2 !== value1.$ne;
+                    }
+                }
+                case '$startsWith': {
+                    if (typeof value2 === 'object') {
+                        var attr2 = Object.keys(value2)[0];
+                        return attr2 === '$startsWith' && typeof (value2[attr2]) === 'string'
+                            && value2[attr2].startsWith(value1.$startsWith)
+                            || attr2 === '$in' && value2[attr2] instanceof Array
+                                && !value2[attr2].find(function (ele) { return typeof ele !== 'string' || !ele.startsWith(value1.$startsWith); });
+                    }
+                    else {
+                        return typeof value2 === 'string' && value2.startsWith(value1.$startsWith);
+                    }
+                }
+                case '$endsWith': {
+                    if (typeof value2 === 'object') {
+                        var attr2 = Object.keys(value2)[0];
+                        return attr2 === '$endsWith' && typeof (value2[attr2]) === 'string'
+                            && value2[attr2].endsWith(value1.$endsWith)
+                            || attr2 === '$in' && value2[attr2] instanceof Array
+                                && !value2[attr2].find(function (ele) { return typeof ele !== 'string' || !ele.endsWith(value1.$endsWith); });
+                    }
+                    else {
+                        return typeof value2 === 'string' && value2.endsWith(value1.$endsWith);
+                    }
+                }
+                case '$includes': {
+                    if (typeof value2 === 'object') {
+                        var attr2 = Object.keys(value2)[0];
+                        return ['$includes', '$startsWith', '$endsWith'].includes(attr2)
+                            && typeof (value2[attr2]) === 'string'
+                            && value2[attr2].includes(value1.$includes)
+                            || attr2 === '$in' && value2[attr2] instanceof Array
+                                && !value2[attr2].find(function (ele) { return typeof ele !== 'string' || !ele.includes(value1.$includes); });
+                    }
+                    else {
+                        return typeof value2 === 'string' && value2.includes(value1.$includes);
+                    }
+                }
+                default: {
+                    (0, assert_1.default)(false, "\u4E0D\u80FD\u5904\u7406\u7684\u7B97\u5B50\u300C".concat(attr, "\u300D"));
+                }
+            }
+        }
+        else if (['$exists'].includes(attr)) {
+            (0, assert_1.default)(attr === '$exists');
+            if (typeof value2 === 'object') {
+                var attr2 = Object.keys(value2)[0];
+                if (value1.$exists === false) {
+                    return attr2 === '$exists' && value2[attr2] === false;
+                }
+                else {
+                    // 可能不完整，有没有更多情况？
+                    return !(attr2 === '$exists' && value2[attr2] === false
+                        || attr2 === '$nin');
+                }
+            }
+            else {
+                return value1.$exists === true;
+            }
+        }
+        else if (['$in', '$nin', '$between'].includes(attr)) {
+            switch (attr) {
+                case '$in': {
+                    if (value1.$in instanceof Array) {
+                        if (typeof value2 === 'object') {
+                            var attr2 = Object.keys(value2)[0];
+                            return attr2 === '$in' && value2[attr2] instanceof Array
+                                && (0, lodash_1.difference)(value2[attr2], value1.$in).length === 0;
+                        }
+                        else {
+                            return value1.$in.includes(value2);
+                        }
+                    }
+                    else {
+                        // 子查询，暂不支持
+                        return false;
+                    }
+                }
+                case '$nin': {
+                    if (value1.$nin instanceof Array) {
+                        if (typeof value2 === 'object') {
+                            var attr2 = Object.keys(value2)[0];
+                            return attr2 === '$in' && value2[attr2] instanceof Array
+                                && (0, lodash_1.intersection)(value2[attr2], value1.$nin).length === 0
+                                || attr2 === '$nin' && value2[attr2] instanceof Array
+                                    && (0, lodash_1.difference)(value1.$nin, value2[attr2]).length === 0;
+                        }
+                        else {
+                            return !value1.$nin.includes(value2);
+                        }
+                    }
+                    else {
+                        // 子查询，暂不支持
+                        return false;
+                    }
+                }
+                case '$between': {
+                    (0, assert_1.default)(value1.$between instanceof Array);
+                    if (typeof value2 === 'object') {
+                        var attr2 = Object.keys(value2)[0];
+                        return attr2 === '$in' && value2[attr2] instanceof Array
+                            && Math.max.apply(Math, tslib_1.__spreadArray([], tslib_1.__read(value2[attr2]), false)) <= value1.$between[1] && Math.min.apply(Math, tslib_1.__spreadArray([], tslib_1.__read(value2[attr2]), false)) >= value1.$between[0]
+                            || attr2 === '$eq' && typeof value2[attr2] === 'number'
+                                && value2[attr2] <= value1.$between[1] && value2[attr2] >= value1.$between[0];
+                    }
+                    else {
+                        return value2 <= value1.$between[1] && value2 >= value1.$between[0];
+                    }
+                }
+                default: {
+                    (0, assert_1.default)(false, "\u6682\u4E0D\u652F\u6301\u7684\u7B97\u5B50".concat(attr));
+                }
+            }
+        }
+        else {
+            return false;
+        }
+    }
+    else {
+        // value1是一个等值查询
+        if (typeof value2 === 'object') {
+            return false;
+        }
+        else {
+            return value1 === value2;
+        }
+    }
+}
+function compareFilter2AttributeValue(entity, schema, attr, filter, conditionalFilterAttrValue, contained) {
+    var _a;
+    for (var attr2 in filter) {
+        if (['$and', '$or'].includes(attr2)) {
+            switch (attr2) {
+                case '$and':
+                case '$or':
+                case '$xor': {
+                    var logicQueries = filter[attr2];
+                    var results = logicQueries.map(function (logicQuery) { return compareFilter2AttributeValue(entity, schema, attr, logicQuery, conditionalFilterAttrValue, contained); });
+                    if (attr2 === '$and' && contained || attr2 === '$or' && !contained) {
+                        // 如果filter的多个算子是and关系，则只要有一个包含此条件就行
+                        // 如果filter的多个算子是or关系，则只要有一个相斥只条件就行
+                        if (results.includes(true)) {
+                            return true;
+                        }
+                    }
+                    else if (attr2 === '$or' && contained || attr2 === '$and' && !contained) {
+                        // 如果filter的多个算子是or关系，则必须每个都能包含此条件
+                        // 如果filter的多个算子是and关系，则必须每个都与此条件相斥
+                        if (!results.includes(false)) {
+                            return true;
+                        }
+                    }
+                    else {
+                        (0, assert_1.default)(false);
+                    }
+                    break;
+                }
+                case '$not': {
+                    /* 判断相容，如果filter的中有not，此not条件应当和conditionalFilterAttrValue的条件相斥
+                    * 如： conditionalFilter 为 { a: { $ne: 3 } }
+                    *       filter 为 { $not: { a: 3 }}
+                    * 判断相斥，如果filter中有not，此not条件应当被conditionalFilterAttrValue的条件相容
+                    * 如： conditionalFilter为 { a: 2 }
+                    *       filter 为 { $not: { a: { $gt: 1 }}}
+                    *
+                    * todo 再想一想对吗？
+                    */
+                    var logicQuery = filter[attr2];
+                    if (contained && !compareFilter2AttributeValue(entity, schema, attr2, logicQuery, conditionalFilterAttrValue, !contained)) {
+                        return false;
+                    }
+                    if (!contained && judgeFilterRelation(entity, schema, (_a = {}, _a[attr2] = conditionalFilterAttrValue, _a), logicQuery, contained)) {
+                        return true;
+                    }
+                    break;
+                }
+                default: {
+                    break;
+                }
+            }
+        }
+        else if (attr2.toLowerCase().startsWith(types_1.EXPRESSION_PREFIX)) {
+            return false;
+        }
+        else if (attr2.toLowerCase() === '$text') {
+            return false;
+        }
+        else {
+            if (attr === attr2) {
+                var rel = (0, relation_1.judgeRelation)(schema, entity, attr2);
+                if (rel === 1) {
+                    return judgeFilterValueRelation(filter[attr2], conditionalFilterAttrValue, contained);
+                }
+                else if (rel === 2) {
+                    return judgeFilterRelation(attr2, schema, filter[attr2], conditionalFilterAttrValue, contained);
+                }
+                else if (typeof rel === 'string') {
+                    return judgeFilterRelation(rel, schema, filter[attr2], conditionalFilterAttrValue, contained);
+                }
+                else {
+                    (0, assert_1.default)(false);
+                }
+            }
+        }
+    }
+    return contained;
+}
+/**
+ * @param entity
+ * @param schema
+ * @param filter
+ * @param conditionalFilter
+ * @param contained: true代表filter包容conditionalFilter, false代表filter与conditionalFilter相斥
+ */
+function judgeFilterRelation(entity, schema, filter, conditionalFilter, contained) {
+    for (var attr in conditionalFilter) {
+        if (['$and', '$or', '$not'].includes(attr)) {
+            switch (attr) {
+                case '$and':
+                case '$or': {
+                    var logicQueries = conditionalFilter[attr];
+                    var results = logicQueries.map(function (logicQuery) { return judgeFilterRelation(entity, schema, filter, logicQuery, contained); });
+                    if (contained) {
+                        // 如果是包容关系，则无论and还是or，conditionalFilter中的任何一个查询条件都应当被filter所包容
+                        if (results.includes(false)) {
+                            return false;
+                        }
+                    }
+                    else if (!contained) {
+                        // 如果是相斥关系，则无论and还是or，conditionalFilter中的任何一个查询条件都应当与filter所相斥
+                        if (!results.includes(true)) {
+                            return false;
+                        }
+                    }
+                    else {
+                        (0, assert_1.default)(false);
+                    }
+                    break;
+                }
+                case '$not': {
+                    var logicQuery = conditionalFilter[attr];
+                    if (!judgeFilterRelation(entity, schema, filter, logicQuery, !contained)) {
+                        return false;
+                    }
+                    break;
+                }
+                default: {
+                    throw new Error("\u6682\u4E0D\u652F\u6301\u7684\u903B\u8F91\u7B97\u5B50".concat(attr));
+                }
+            }
+        }
+        else if (attr.toLowerCase().startsWith(types_1.EXPRESSION_PREFIX)) {
+            return false;
+        }
+        else if (attr.toLowerCase() === '$text') {
+            return false;
+        }
+        else {
+            if (contained && !compareFilter2AttributeValue(entity, schema, attr, filter, conditionalFilter[attr], contained)) {
+                // 相容关系只要有一个不相容就不相容
+                return false;
+            }
+            if (!contained && !compareFilter2AttributeValue(entity, schema, attr, filter, conditionalFilter[attr], contained)) {
+                // 相斥关系只要有一个相斥就相斥
+                return true;
+            }
+        }
+    }
+    return contained;
+}
+/**
+ *
  * 判断filter是否包含conditionalFilter中的查询条件，即filter查询的结果一定满足conditionalFilter的约束
  * filter = {
  *      a: 1
@@ -110,9 +477,9 @@ exports.combineFilters = combineFilters;
  * @param schema
  * @param filter
  * @param conditionalFilter
+ * @returns
  */
 function contains(entity, schema, filter, conditionalFilter) {
-    // todo
     return false;
 }
 exports.contains = contains;
@@ -150,7 +517,7 @@ function getRelevantIds(filter) {
     }
     // 因为要准确判定id，如果有其它的过滤条件，可能会使实际处理的行数少于id指向的行数，只能返回空数组
     var attrs = Object.keys(filter);
-    if ((0, lodash_1.union)(attrs, ['id', '$and', '$or']).length > 3) {
+    if ((0, lodash_1.intersection)(attrs, ['id', '$and', '$or']).length > 3) {
         return [];
     }
     if (filter === null || filter === void 0 ? void 0 : filter.$and) {
@@ -284,3 +651,28 @@ function makeTreeDescendantFilter(entity, parentKey, filter, level, includeAll,
     return currentLevelInFilter;
 }
 exports.makeTreeDescendantFilter = makeTreeDescendantFilter;
+function checkFilterContains(entity, context, contained, filter) {
+    if (!filter) {
+        throw new types_1.OakRowInconsistencyException();
+    }
+    var schema = context.getSchema();
+    // 优先判断两个条件是否相容
+    if (contains(entity, schema, filter, contained)) {
+        return true;
+    }
+    // 再判断加上了conditionalFilter后取得的行数是否缩减
+    var filter2 = combineFilters([filter, {
+            $not: contained,
+        }]);
+    var count = context.count(entity, {
+        filter: filter2,
+    }, {
+        dontCollect: true,
+        blockTrigger: true,
+    });
+    if (count instanceof Promise) {
+        return count.then(function (count2) { return count2 === 0; });
+    }
+    return count === 0;
+}
+exports.checkFilterContains = checkFilterContains;

package/lib/store/modi.d.ts

@@ -1,12 +1,13 @@
 import { EntityDict as BaseEntityDict } from '../base-app-domain';
-import { UniversalContext } from '../store/UniversalContext';
 import { OpSchema as Modi } from '../base-app-domain/Modi/Schema';
-import { Checker, Operation, StorageSchema, EntityDict, Context, OperateOption, Trigger } from '../types';
+import { Operation, StorageSchema, RowChecker, EntityDict, OperateOption, Trigger } from '../types';
+import { AsyncContext } from './AsyncRowStore';
+import { SyncContext } from './SyncRowStore';
 export declare function createOperationsFromModies(modies: Modi[]): Array<{
     operation: Operation<string, Object, Object>;
     entity: string;
 }>;
-export declare function applyModis<ED extends EntityDict & BaseEntityDict, Cxt extends UniversalContext<ED>, Op extends OperateOption>(filter: ED['modi']['Selection']['filter'], context: Cxt, option: Op): Promise<import("../types").OperationResult<ED>>;
-export declare function abandonModis<ED extends EntityDict & BaseEntityDict, Cxt extends UniversalContext<ED>, Op extends OperateOption>(filter: ED['modi']['Selection']['filter'], context: Cxt, option: Op): Promise<import("../types").OperationResult<ED>>;
-export declare function createModiRelatedCheckers<ED extends EntityDict & BaseEntityDict, Cxt extends Context<ED>>(schema: StorageSchema<ED>): Checker<ED, keyof ED, Cxt>[];
-export declare function createModiRelatedTriggers<ED extends EntityDict & BaseEntityDict, Cxt extends Context<ED>>(schema: StorageSchema<ED>): Trigger<ED, keyof ED, Cxt>[];
+export declare function applyModis<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>, Op extends OperateOption>(filter: ED['modi']['Selection']['filter'], context: Cxt, option: Op): Promise<import("../types").OperationResult<ED>>;
+export declare function abandonModis<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>, Op extends OperateOption>(filter: ED['modi']['Selection']['filter'], context: Cxt, option: Op): Promise<import("../types").OperationResult<ED>>;
+export declare function createModiRelatedCheckers<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED> | SyncContext<ED>>(schema: StorageSchema<ED>): RowChecker<ED, keyof ED, Cxt>[];
+export declare function createModiRelatedTriggers<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>>(schema: StorageSchema<ED>): Trigger<ED, keyof ED, Cxt>[];

package/lib/store/modi.js

@@ -2,9 +2,9 @@
 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");
 function createOperationsFromModies(modies) {
     return modies.map(function (modi) {
         return {
@@ -26,15 +26,15 @@ function applyModis(filter, context, option) {
         return tslib_1.__generator(this, function (_e) {
             switch (_e.label) {
                 case 0:
-                    _b = (_a = context.rowStore).operate;
+                    _b = (_a = context).operate;
                     _c = ['modi'];
                     _d = {};
-                    return [4 /*yield*/, generateNewId()];
+                    return [4 /*yield*/, (0, uuid_1.generateNewIdAsync)()];
                 case 1: return [2 /*return*/, _b.apply(_a, _c.concat([(_d.id = _e.sent(),
                             _d.action = 'apply',
                             _d.data = {},
                             _d.filter = filter,
-                            _d), context, Object.assign({}, option, {
+                            _d), Object.assign({}, option, {
                             blockTrigger: false,
                         })]))];
             }
@@ -49,10 +49,10 @@ function abandonModis(filter, context, option) {
         return tslib_1.__generator(this, function (_e) {
             switch (_e.label) {
                 case 0:
-                    _b = (_a = context.rowStore).operate;
+                    _b = (_a = context).operate;
                     _c = ['modi'];
                     _d = {};
-                    return [4 /*yield*/, generateNewId()];
+                    return [4 /*yield*/, (0, uuid_1.generateNewIdAsync)()];
                 case 1: return [2 /*return*/, _b.apply(_a, _c.concat([(_d.id = _e.sent(),
                             _d.action = 'abandon',
                             _d.data = {},
@@ -65,7 +65,7 @@ function abandonModis(filter, context, option) {
                                     $direction: 'asc',
                                 }
                             ],
-                            _d), context, Object.assign({}, option, {
+                            _d), Object.assign({}, option, {
                             blockTrigger: false,
                         })]))];
             }
@@ -74,7 +74,6 @@ function abandonModis(filter, context, option) {
 }
 exports.abandonModis = abandonModis;
 function createModiRelatedCheckers(schema) {
-    var _this = this;
     var checkers = [];
     var _loop_1 = function (entity) {
         var _a = schema[entity], actionType = _a.actionType, actions = _a.actions, inModi = _a.inModi;
@@ -86,43 +85,33 @@ function createModiRelatedCheckers(schema) {
             entity: entity,
             action: restActions,
             type: 'row',
-            checker: function (_a, context) {
-                var operation = _a.operation;
-                return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                    var filter, filter2, count;
-                    var _b;
-                    return tslib_1.__generator(this, function (_c) {
-                        switch (_c.label) {
-                            case 0:
-                                filter = operation.filter;
-                                filter2 = {
-                                    modi: {
-                                        iState: 'active',
-                                    },
-                                };
-                                if (filter) {
-                                    Object.assign(filter2, (_b = {},
-                                        _b[entity] = filter,
-                                        _b));
-                                }
-                                else {
-                                    Object.assign(filter2, {
-                                        entity: entity,
-                                    });
+            filter: function (context, option) {
+                if (option.modiParentId && option.modiParentEntity) {
+                    // 如果本身也是创建modi就允许通过
+                    return {
+                        id: {
+                            $exists: true,
+                        },
+                    };
+                }
+                return {
+                    id: {
+                        $nin: {
+                            entity: 'modiEntity',
+                            data: {
+                                entityId: 1,
+                            },
+                            filter: {
+                                entity: entity,
+                                modi: {
+                                    iState: 'active',
                                 }
-                                return [4 /*yield*/, context.rowStore.count('modiEntity', {
-                                        filter: filter2,
-                                    }, context, {})];
-                            case 1:
-                                count = _c.sent();
-                                if (count > 0) {
-                                    throw new types_1.OakRowLockedException();
-                                }
-                                return [2 /*return*/, 0];
-                        }
-                    });
-                });
+                            },
+                        },
+                    }
+                };
             },
+            errMsg: "\u66F4\u65B0\u7684\u5BF9\u8C61".concat(entity, "\u4E0A\u6709\u5C1A\u672A\u7ED3\u675F\u7684modi"),
         });
     };
     for (var entity in schema) {
@@ -153,10 +142,10 @@ function createModiRelatedTriggers(schema) {
                                 case 0:
                                     data = operation.data;
                                     id = data.id;
-                                    _c = (_b = context.rowStore).operate;
+                                    _c = (_b = context).operate;
                                     _d = ['modi'];
                                     _e = {};
-                                    return [4 /*yield*/, generateNewId()];
+                                    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 = {},
@@ -164,7 +153,7 @@ function createModiRelatedTriggers(schema) {
                                                 entity: entity,
                                                 entityId: id,
                                             },
-                                            _e), context, option]))];
+                                            _e), option]))];
                                 case 2:
                                     _f.sent();
                                     return [2 /*return*/, 1];

package/lib/store/relation.d.ts

@@ -10,4 +10,4 @@ import { StorageSchema } from "../types/Storage";
  */
 export declare function judgeRelation<ED extends {
     [E: string]: EntityDef;
-}>(schema: StorageSchema<ED>, entity: keyof ED, attr: string): string | string[] | 1 | 0 | 2;
+}>(schema: StorageSchema<ED>, entity: keyof ED, attr: string): string | 2 | 1 | string[] | 0;

package/lib/store/selection.js

@@ -199,6 +199,7 @@ function reinforceSelection(schema, entity, selection) {
                         entity: 1,
                         entityId: 1,
                         action: 1,
+                        iState: 1,
                         data: 1,
                         filter: 1,
                     },

package/lib/triggers/index.d.ts

@@ -1,5 +1,6 @@
 import { EntityDict as BaseEntityDict } from '../base-app-domain';
-import { StorageSchema, EntityDict, Context } from '../types';
-declare const _default: import("../types").Trigger<BaseEntityDict, "modi", import("../store/UniversalContext").UniversalContext<BaseEntityDict>>[];
+import { StorageSchema, EntityDict } from '../types';
+import { AsyncContext } from '../store/AsyncRowStore';
+declare const _default: import("../types").Trigger<BaseEntityDict, "modi", AsyncContext<BaseEntityDict>>[];
 export default _default;
-export declare function createDynamicTriggers<ED extends EntityDict & BaseEntityDict, Cxt extends Context<ED>>(schema: StorageSchema<ED>): import("../types").Trigger<ED, keyof ED, Cxt>[];
+export declare function createDynamicTriggers<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>>(schema: StorageSchema<ED>): import("../types").Trigger<ED, keyof ED, Cxt>[];

package/lib/triggers/modi.d.ts

@@ -1,5 +1,5 @@
 import { EntityDict } from "../base-app-domain";
+import { AsyncContext } from "../store/AsyncRowStore";
 import { Trigger } from "../types";
-import { UniversalContext } from "../store/UniversalContext";
-declare const triggers: Trigger<EntityDict, 'modi', UniversalContext<EntityDict>>[];
+declare const triggers: Trigger<EntityDict, 'modi', AsyncContext<EntityDict>>[];
 export default triggers;