oak-domain 2.0.2 → 2.0.3

package/lib/store/selection.js

@@ -1,228 +1,228 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.reinforceSelection = void 0;
-var tslib_1 = require("tslib");
-var assert_1 = tslib_1.__importDefault(require("assert"));
-var types_1 = require("../types");
-var Demand_1 = require("../types/Demand");
-var filter_1 = require("./filter");
-var relation_1 = require("./relation");
-/**
- * 对selection进行一些完善，避免编程人员的疏漏
- * @param selection
- */
-function reinforceSelection(schema, entity, selection) {
-    var filter = selection.filter, data = selection.data, sorter = selection.sorter;
-    var checkNode = function (projectionNode, attrs) {
-        attrs.forEach(function (attr) {
-            var _a;
-            if (!projectionNode.hasOwnProperty(attr)) {
-                Object.assign(projectionNode, (_a = {},
-                    _a[attr] = 1,
-                    _a));
-            }
-        });
-    };
-    var relevantIds = [];
-    if (filter) {
-        var toBeAssignNode_1 = {}; // 用来记录在表达式中涉及到的结点
-        // filter当中所关联到的属性必须在projection中
-        var filterNodeDict_1 = {};
-        var checkFilterNode_1 = function (entity2, filterNode, projectionNode) {
-            var _a, e_1, _b, _c, _d, _e, _f;
-            var necessaryAttrs = ['id'];
-            for (var attr in filterNode) {
-                if (attr === '#id') {
-                    (0, assert_1.default)(!filterNodeDict_1[filterNode[attr]], "projection\u4E2D\u7ED3\u70B9\u7684id\u6709\u91CD\u590D, ".concat(filterNode[attr]));
-                    Object.assign(filterNodeDict_1, (_a = {},
-                        _a[filterNode[attr]] = projectionNode,
-                        _a));
-                    if (toBeAssignNode_1[filterNode[attr]]) {
-                        checkNode(projectionNode, toBeAssignNode_1[filterNode[attr]]);
-                    }
-                }
-                else if (['$and', '$or'].includes(attr)) {
-                    try {
-                        for (var _g = (e_1 = void 0, tslib_1.__values(filterNode[attr])), _h = _g.next(); !_h.done; _h = _g.next()) {
-                            var node = _h.value;
-                            checkFilterNode_1(entity2, node, projectionNode);
-                        }
-                    }
-                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                    finally {
-                        try {
-                            if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
-                        }
-                        finally { if (e_1) throw e_1.error; }
-                    }
-                }
-                else if (attr === '$not') {
-                    checkFilterNode_1(entity2, filterNode[attr], projectionNode);
-                }
-                else {
-                    if (attr.toLowerCase().startsWith(Demand_1.EXPRESSION_PREFIX)) {
-                        var exprResult = (0, types_1.getAttrRefInExpression)(filterNode[attr]);
-                        for (var nodeName in exprResult) {
-                            if (nodeName === '#current') {
-                                checkNode(projectionNode, exprResult[nodeName]);
-                            }
-                            else if (filterNodeDict_1[nodeName]) {
-                                checkNode(filterNodeDict_1[nodeName], exprResult[nodeName]);
-                            }
-                            else {
-                                if (toBeAssignNode_1[nodeName]) {
-                                    (_c = toBeAssignNode_1[nodeName]).push.apply(_c, tslib_1.__spreadArray([], tslib_1.__read(exprResult[nodeName]), false));
-                                }
-                                else {
-                                    Object.assign(toBeAssignNode_1, (_d = {},
-                                        _d[nodeName] = exprResult[nodeName],
-                                        _d));
-                                }
-                            }
-                        }
-                    }
-                    else {
-                        var rel = (0, relation_1.judgeRelation)(schema, entity2, attr);
-                        if (rel === 1) {
-                            necessaryAttrs.push(attr);
-                        }
-                        else if (rel === 2) {
-                            // entity/entityId反指
-                            necessaryAttrs.push('entity', 'entityId');
-                            if (!projectionNode[attr]) {
-                                Object.assign(projectionNode, (_e = {},
-                                    _e[attr] = {
-                                        id: 1,
-                                    },
-                                    _e));
-                            }
-                            checkFilterNode_1(attr, filterNode[attr], projectionNode[attr]);
-                        }
-                        else if (typeof rel === 'string') {
-                            necessaryAttrs.push("".concat(attr, "Id"));
-                            if (!projectionNode[attr]) {
-                                Object.assign(projectionNode, (_f = {},
-                                    _f[attr] = {
-                                        id: 1,
-                                    },
-                                    _f));
-                            }
-                            checkFilterNode_1(rel, filterNode[attr], projectionNode[attr]);
-                        }
-                        else if (rel instanceof Array) {
-                            // 现在filter中还不支持一对多的语义，先放着吧
-                        }
-                    }
-                }
-                checkNode(projectionNode, necessaryAttrs);
-            }
-        };
-        checkFilterNode_1(entity, filter, data);
-        relevantIds = (0, filter_1.getRelevantIds)(filter);
-    }
-    // sorter感觉现在取不取影响不大，前端的list直接获取返回的ids了，先不管之
-    if (sorter) {
-    }
-    var toBeAssignNode2 = {}; // 用来记录在表达式中涉及到的结点
-    var projectionNodeDict = {};
-    var checkProjectionNode = function (entity2, projectionNode) {
-        var _a, _b, _c;
-        var necessaryAttrs = ['id'];
-        for (var attr in projectionNode) {
-            if (attr === '#id') {
-                (0, assert_1.default)(!projectionNodeDict[projectionNode[attr]], "projection\u4E2D\u7ED3\u70B9\u7684id\u6709\u91CD\u590D, ".concat(projectionNode[attr]));
-                Object.assign(projectionNodeDict, (_a = {},
-                    _a[projectionNode[attr]] = projectionNode,
-                    _a));
-                if (toBeAssignNode2[projectionNode[attr]]) {
-                    checkNode(projectionNode, toBeAssignNode2[projectionNode[attr]]);
-                }
-            }
-            else {
-                if (attr.toLowerCase().startsWith(Demand_1.EXPRESSION_PREFIX)) {
-                    var exprResult = (0, types_1.getAttrRefInExpression)(projectionNode[attr]);
-                    for (var nodeName in exprResult) {
-                        if (nodeName === '#current') {
-                            checkNode(projectionNode, exprResult[nodeName]);
-                        }
-                        else if (projectionNodeDict[nodeName]) {
-                            checkNode(projectionNodeDict[nodeName], exprResult[nodeName]);
-                        }
-                        else {
-                            if (toBeAssignNode2[nodeName]) {
-                                (_b = toBeAssignNode2[nodeName]).push.apply(_b, tslib_1.__spreadArray([], tslib_1.__read(exprResult[nodeName]), false));
-                            }
-                            else {
-                                Object.assign(toBeAssignNode2, (_c = {},
-                                    _c[nodeName] = exprResult[nodeName],
-                                    _c));
-                            }
-                        }
-                    }
-                }
-                else {
-                    var rel = (0, relation_1.judgeRelation)(schema, entity2, attr);
-                    if (rel === 1) {
-                        necessaryAttrs.push(attr);
-                    }
-                    else if (rel === 2) {
-                        // entity/entityId反指
-                        necessaryAttrs.push('entity', 'entityId');
-                        checkProjectionNode(attr, projectionNode[attr]);
-                    }
-                    else if (typeof rel === 'string') {
-                        necessaryAttrs.push("".concat(attr, "Id"));
-                        checkProjectionNode(rel, projectionNode[attr]);
-                    }
-                    else if (rel instanceof Array) {
-                        var data_1 = projectionNode[attr].data;
-                        if (rel[1]) {
-                            checkNode(data_1, [rel[1]]);
-                        }
-                        else {
-                            checkNode(data_1, ['entity', 'entityId']);
-                        }
-                        checkProjectionNode(rel[0], data_1);
-                    }
-                }
-            }
-            checkNode(projectionNode, necessaryAttrs);
-        }
-        // 如果对象中指向一对多的Modi，此时加上指向Modi的projection
-        if (schema[entity2].toModi) {
-            Object.assign(projectionNode, {
-                modi$entity: {
-                    $entity: 'modi',
-                    data: {
-                        id: 1,
-                        targetEntity: 1,
-                        entity: 1,
-                        entityId: 1,
-                        action: 1,
-                        iState: 1,
-                        data: 1,
-                        filter: 1,
-                    },
-                    filter: {
-                        iState: 'active',
-                    },
-                }
-            });
-        }
-    };
-    checkProjectionNode(entity, data);
-    if (!sorter && relevantIds.length === 0) {
-        // 如果没有sorter，就给予一个按createAt逆序的sorter
-        Object.assign(selection, {
-            sorter: [
-                {
-                    $attr: {
-                        $$createAt$$: 1,
-                    },
-                    $direction: 'desc',
-                }
-            ]
-        });
-    }
-}
-exports.reinforceSelection = reinforceSelection;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reinforceSelection = void 0;
+var tslib_1 = require("tslib");
+var assert_1 = tslib_1.__importDefault(require("assert"));
+var types_1 = require("../types");
+var Demand_1 = require("../types/Demand");
+var filter_1 = require("./filter");
+var relation_1 = require("./relation");
+/**
+ * 对selection进行一些完善，避免编程人员的疏漏
+ * @param selection
+ */
+function reinforceSelection(schema, entity, selection) {
+    var filter = selection.filter, data = selection.data, sorter = selection.sorter;
+    var checkNode = function (projectionNode, attrs) {
+        attrs.forEach(function (attr) {
+            var _a;
+            if (!projectionNode.hasOwnProperty(attr)) {
+                Object.assign(projectionNode, (_a = {},
+                    _a[attr] = 1,
+                    _a));
+            }
+        });
+    };
+    var relevantIds = [];
+    if (filter) {
+        var toBeAssignNode_1 = {}; // 用来记录在表达式中涉及到的结点
+        // filter当中所关联到的属性必须在projection中
+        var filterNodeDict_1 = {};
+        var checkFilterNode_1 = function (entity2, filterNode, projectionNode) {
+            var _a, e_1, _b, _c, _d, _e, _f;
+            var necessaryAttrs = ['id'];
+            for (var attr in filterNode) {
+                if (attr === '#id') {
+                    (0, assert_1.default)(!filterNodeDict_1[filterNode[attr]], "projection\u4E2D\u7ED3\u70B9\u7684id\u6709\u91CD\u590D, ".concat(filterNode[attr]));
+                    Object.assign(filterNodeDict_1, (_a = {},
+                        _a[filterNode[attr]] = projectionNode,
+                        _a));
+                    if (toBeAssignNode_1[filterNode[attr]]) {
+                        checkNode(projectionNode, toBeAssignNode_1[filterNode[attr]]);
+                    }
+                }
+                else if (['$and', '$or'].includes(attr)) {
+                    try {
+                        for (var _g = (e_1 = void 0, tslib_1.__values(filterNode[attr])), _h = _g.next(); !_h.done; _h = _g.next()) {
+                            var node = _h.value;
+                            checkFilterNode_1(entity2, node, projectionNode);
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                }
+                else if (attr === '$not') {
+                    checkFilterNode_1(entity2, filterNode[attr], projectionNode);
+                }
+                else {
+                    if (attr.toLowerCase().startsWith(Demand_1.EXPRESSION_PREFIX)) {
+                        var exprResult = (0, types_1.getAttrRefInExpression)(filterNode[attr]);
+                        for (var nodeName in exprResult) {
+                            if (nodeName === '#current') {
+                                checkNode(projectionNode, exprResult[nodeName]);
+                            }
+                            else if (filterNodeDict_1[nodeName]) {
+                                checkNode(filterNodeDict_1[nodeName], exprResult[nodeName]);
+                            }
+                            else {
+                                if (toBeAssignNode_1[nodeName]) {
+                                    (_c = toBeAssignNode_1[nodeName]).push.apply(_c, tslib_1.__spreadArray([], tslib_1.__read(exprResult[nodeName]), false));
+                                }
+                                else {
+                                    Object.assign(toBeAssignNode_1, (_d = {},
+                                        _d[nodeName] = exprResult[nodeName],
+                                        _d));
+                                }
+                            }
+                        }
+                    }
+                    else {
+                        var rel = (0, relation_1.judgeRelation)(schema, entity2, attr);
+                        if (rel === 1) {
+                            necessaryAttrs.push(attr);
+                        }
+                        else if (rel === 2) {
+                            // entity/entityId反指
+                            necessaryAttrs.push('entity', 'entityId');
+                            if (!projectionNode[attr]) {
+                                Object.assign(projectionNode, (_e = {},
+                                    _e[attr] = {
+                                        id: 1,
+                                    },
+                                    _e));
+                            }
+                            checkFilterNode_1(attr, filterNode[attr], projectionNode[attr]);
+                        }
+                        else if (typeof rel === 'string') {
+                            necessaryAttrs.push("".concat(attr, "Id"));
+                            if (!projectionNode[attr]) {
+                                Object.assign(projectionNode, (_f = {},
+                                    _f[attr] = {
+                                        id: 1,
+                                    },
+                                    _f));
+                            }
+                            checkFilterNode_1(rel, filterNode[attr], projectionNode[attr]);
+                        }
+                        else if (rel instanceof Array) {
+                            // 现在filter中还不支持一对多的语义，先放着吧
+                        }
+                    }
+                }
+                checkNode(projectionNode, necessaryAttrs);
+            }
+        };
+        checkFilterNode_1(entity, filter, data);
+        relevantIds = (0, filter_1.getRelevantIds)(filter);
+    }
+    // sorter感觉现在取不取影响不大，前端的list直接获取返回的ids了，先不管之
+    if (sorter) {
+    }
+    var toBeAssignNode2 = {}; // 用来记录在表达式中涉及到的结点
+    var projectionNodeDict = {};
+    var checkProjectionNode = function (entity2, projectionNode) {
+        var _a, _b, _c;
+        var necessaryAttrs = ['id'];
+        for (var attr in projectionNode) {
+            if (attr === '#id') {
+                (0, assert_1.default)(!projectionNodeDict[projectionNode[attr]], "projection\u4E2D\u7ED3\u70B9\u7684id\u6709\u91CD\u590D, ".concat(projectionNode[attr]));
+                Object.assign(projectionNodeDict, (_a = {},
+                    _a[projectionNode[attr]] = projectionNode,
+                    _a));
+                if (toBeAssignNode2[projectionNode[attr]]) {
+                    checkNode(projectionNode, toBeAssignNode2[projectionNode[attr]]);
+                }
+            }
+            else {
+                if (attr.toLowerCase().startsWith(Demand_1.EXPRESSION_PREFIX)) {
+                    var exprResult = (0, types_1.getAttrRefInExpression)(projectionNode[attr]);
+                    for (var nodeName in exprResult) {
+                        if (nodeName === '#current') {
+                            checkNode(projectionNode, exprResult[nodeName]);
+                        }
+                        else if (projectionNodeDict[nodeName]) {
+                            checkNode(projectionNodeDict[nodeName], exprResult[nodeName]);
+                        }
+                        else {
+                            if (toBeAssignNode2[nodeName]) {
+                                (_b = toBeAssignNode2[nodeName]).push.apply(_b, tslib_1.__spreadArray([], tslib_1.__read(exprResult[nodeName]), false));
+                            }
+                            else {
+                                Object.assign(toBeAssignNode2, (_c = {},
+                                    _c[nodeName] = exprResult[nodeName],
+                                    _c));
+                            }
+                        }
+                    }
+                }
+                else {
+                    var rel = (0, relation_1.judgeRelation)(schema, entity2, attr);
+                    if (rel === 1) {
+                        necessaryAttrs.push(attr);
+                    }
+                    else if (rel === 2) {
+                        // entity/entityId反指
+                        necessaryAttrs.push('entity', 'entityId');
+                        checkProjectionNode(attr, projectionNode[attr]);
+                    }
+                    else if (typeof rel === 'string') {
+                        necessaryAttrs.push("".concat(attr, "Id"));
+                        checkProjectionNode(rel, projectionNode[attr]);
+                    }
+                    else if (rel instanceof Array) {
+                        var data_1 = projectionNode[attr].data;
+                        if (rel[1]) {
+                            checkNode(data_1, [rel[1]]);
+                        }
+                        else {
+                            checkNode(data_1, ['entity', 'entityId']);
+                        }
+                        checkProjectionNode(rel[0], data_1);
+                    }
+                }
+            }
+            checkNode(projectionNode, necessaryAttrs);
+        }
+        // 如果对象中指向一对多的Modi，此时加上指向Modi的projection
+        if (schema[entity2].toModi) {
+            Object.assign(projectionNode, {
+                modi$entity: {
+                    $entity: 'modi',
+                    data: {
+                        id: 1,
+                        targetEntity: 1,
+                        entity: 1,
+                        entityId: 1,
+                        action: 1,
+                        iState: 1,
+                        data: 1,
+                        filter: 1,
+                    },
+                    filter: {
+                        iState: 'active',
+                    },
+                }
+            });
+        }
+    };
+    checkProjectionNode(entity, data);
+    if (!sorter && relevantIds.length === 0) {
+        // 如果没有sorter，就给予一个按createAt逆序的sorter
+        Object.assign(selection, {
+            sorter: [
+                {
+                    $attr: {
+                        $$createAt$$: 1,
+                    },
+                    $direction: 'desc',
+                }
+            ]
+        });
+    }
+}
+exports.reinforceSelection = reinforceSelection;

package/lib/triggers/index.d.ts

@@ -1,6 +1,6 @@
-import { EntityDict as BaseEntityDict } from '../base-app-domain';
-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 AsyncContext<ED>>(schema: StorageSchema<ED>): import("../types").Trigger<ED, keyof ED, Cxt>[];
+import { EntityDict as BaseEntityDict } from '../base-app-domain';
+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 AsyncContext<ED>>(schema: StorageSchema<ED>): import("../types").Trigger<ED, keyof ED, Cxt>[];

package/lib/triggers/index.js

@@ -1,11 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createDynamicTriggers = void 0;
-var tslib_1 = require("tslib");
-var modi_1 = tslib_1.__importDefault(require("./modi"));
-var modi_2 = require("../store/modi");
-exports.default = tslib_1.__spreadArray([], tslib_1.__read(modi_1.default), false);
-function createDynamicTriggers(schema) {
-    return (0, modi_2.createModiRelatedTriggers)(schema);
-}
-exports.createDynamicTriggers = createDynamicTriggers;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDynamicTriggers = void 0;
+var tslib_1 = require("tslib");
+var modi_1 = tslib_1.__importDefault(require("./modi"));
+var modi_2 = require("../store/modi");
+exports.default = tslib_1.__spreadArray([], tslib_1.__read(modi_1.default), false);
+function createDynamicTriggers(schema) {
+    return (0, modi_2.createModiRelatedTriggers)(schema);
+}
+exports.createDynamicTriggers = createDynamicTriggers;

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";
-declare const triggers: Trigger<EntityDict, 'modi', AsyncContext<EntityDict>>[];
-export default triggers;
+import { EntityDict } from "../base-app-domain";
+import { AsyncContext } from "../store/AsyncRowStore";
+import { Trigger } from "../types";
+declare const triggers: Trigger<EntityDict, 'modi', AsyncContext<EntityDict>>[];
+export default triggers;

package/lib/triggers/modi.js

@@ -1,72 +1,72 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var triggers = [
-    {
-        name: '当modi被应用时，将相应的operate完成',
-        entity: 'modi',
-        action: 'apply',
-        when: 'after',
-        fn: function (_a, context, option) {
-            var operation = _a.operation;
-            return tslib_1.__awaiter(void 0, void 0, void 0, function () {
-                var filter, modies, modies_1, modies_1_1, modi, targetEntity, id, action, data, filter_1, e_1_1;
-                var e_1, _b;
-                return tslib_1.__generator(this, function (_c) {
-                    switch (_c.label) {
-                        case 0:
-                            filter = operation.filter;
-                            return [4 /*yield*/, context.select('modi', {
-                                    data: {
-                                        id: 1,
-                                        action: 1,
-                                        data: 1,
-                                        filter: 1,
-                                        targetEntity: 1,
-                                    },
-                                    filter: filter,
-                                }, option)];
-                        case 1:
-                            modies = _c.sent();
-                            _c.label = 2;
-                        case 2:
-                            _c.trys.push([2, 7, 8, 9]);
-                            modies_1 = tslib_1.__values(modies), modies_1_1 = modies_1.next();
-                            _c.label = 3;
-                        case 3:
-                            if (!!modies_1_1.done) return [3 /*break*/, 6];
-                            modi = modies_1_1.value;
-                            targetEntity = modi.targetEntity, id = modi.id, action = modi.action, data = modi.data, filter_1 = modi.filter;
-                            return [4 /*yield*/, context.operate(targetEntity, {
-                                    id: id,
-                                    action: action,
-                                    data: data,
-                                    filter: filter_1,
-                                }, Object.assign({}, option, {
-                                    blockTrigger: true,
-                                }))];
-                        case 4:
-                            _c.sent();
-                            _c.label = 5;
-                        case 5:
-                            modies_1_1 = modies_1.next();
-                            return [3 /*break*/, 3];
-                        case 6: return [3 /*break*/, 9];
-                        case 7:
-                            e_1_1 = _c.sent();
-                            e_1 = { error: e_1_1 };
-                            return [3 /*break*/, 9];
-                        case 8:
-                            try {
-                                if (modies_1_1 && !modies_1_1.done && (_b = modies_1.return)) _b.call(modies_1);
-                            }
-                            finally { if (e_1) throw e_1.error; }
-                            return [7 /*endfinally*/];
-                        case 9: return [2 /*return*/, modies.length];
-                    }
-                });
-            });
-        }
-    }
-];
-exports.default = triggers;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var triggers = [
+    {
+        name: '当modi被应用时，将相应的operate完成',
+        entity: 'modi',
+        action: 'apply',
+        when: 'after',
+        fn: function (_a, context, option) {
+            var operation = _a.operation;
+            return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+                var filter, modies, modies_1, modies_1_1, modi, targetEntity, id, action, data, filter_1, e_1_1;
+                var e_1, _b;
+                return tslib_1.__generator(this, function (_c) {
+                    switch (_c.label) {
+                        case 0:
+                            filter = operation.filter;
+                            return [4 /*yield*/, context.select('modi', {
+                                    data: {
+                                        id: 1,
+                                        action: 1,
+                                        data: 1,
+                                        filter: 1,
+                                        targetEntity: 1,
+                                    },
+                                    filter: filter,
+                                }, option)];
+                        case 1:
+                            modies = _c.sent();
+                            _c.label = 2;
+                        case 2:
+                            _c.trys.push([2, 7, 8, 9]);
+                            modies_1 = tslib_1.__values(modies), modies_1_1 = modies_1.next();
+                            _c.label = 3;
+                        case 3:
+                            if (!!modies_1_1.done) return [3 /*break*/, 6];
+                            modi = modies_1_1.value;
+                            targetEntity = modi.targetEntity, id = modi.id, action = modi.action, data = modi.data, filter_1 = modi.filter;
+                            return [4 /*yield*/, context.operate(targetEntity, {
+                                    id: id,
+                                    action: action,
+                                    data: data,
+                                    filter: filter_1,
+                                }, Object.assign({}, option, {
+                                    blockTrigger: true,
+                                }))];
+                        case 4:
+                            _c.sent();
+                            _c.label = 5;
+                        case 5:
+                            modies_1_1 = modies_1.next();
+                            return [3 /*break*/, 3];
+                        case 6: return [3 /*break*/, 9];
+                        case 7:
+                            e_1_1 = _c.sent();
+                            e_1 = { error: e_1_1 };
+                            return [3 /*break*/, 9];
+                        case 8:
+                            try {
+                                if (modies_1_1 && !modies_1_1.done && (_b = modies_1.return)) _b.call(modies_1);
+                            }
+                            finally { if (e_1) throw e_1.error; }
+                            return [7 /*endfinally*/];
+                        case 9: return [2 /*return*/, modies.length];
+                    }
+                });
+            });
+        }
+    }
+];
+exports.default = triggers;