oak-domain 1.1.13 → 2.0.1

package/lib/store/CascadeStore.js

@@ -3,78 +3,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CascadeStore = void 0;
 var tslib_1 = require("tslib");
 var assert_1 = tslib_1.__importDefault(require("assert"));
+var Entity_1 = require("../types/Entity");
 var RowStore_1 = require("../types/RowStore");
 var filter_1 = require("./filter");
 var relation_1 = require("./relation");
 var types_1 = require("../types");
 var lodash_1 = require("../utils/lodash");
+var filter_2 = require("./filter");
+var uuid_1 = require("../utils/uuid");
 /**这个用来处理级联的select和update，对不同能力的 */
 var CascadeStore = /** @class */ (function (_super) {
     tslib_1.__extends(CascadeStore, _super);
     function CascadeStore(storageSchema) {
         return _super.call(this, storageSchema) || this;
     }
-    /**
-     * 将一次查询的结果集加入result
-     * @param entity
-     * @param rows
-     * @param context
-     */
-    CascadeStore.prototype.addToResultSelections = function (entity, rows, context) {
-        var _a;
-        var opRecords = context.opRecords;
-        var lastOperation = opRecords[opRecords.length - 1];
-        if (lastOperation && lastOperation.a === 's') {
-            var entityBranch_1 = lastOperation.d[entity];
-            if (entityBranch_1) {
-                rows.forEach(function (row) {
-                    var _a;
-                    var id = row.id;
-                    if (!entityBranch_1[id]) {
-                        Object.assign(entityBranch_1, (_a = {},
-                            _a[id] = (0, lodash_1.cloneDeep)(row),
-                            _a));
-                    }
-                });
-                return;
-            }
-        }
-        else {
-            lastOperation = {
-                a: 's',
-                d: {},
-            };
-            opRecords.push(lastOperation);
-        }
-        var entityBranch = {};
-        rows.forEach(function (row) {
-            var _a;
-            var id = row.id;
-            Object.assign(entityBranch, (_a = {},
-                _a[id] = (0, lodash_1.cloneDeep)(row),
-                _a));
-        });
-        Object.assign(lastOperation.d, (_a = {},
-            _a[entity] = entityBranch,
-            _a));
-    };
-    CascadeStore.prototype.reduceDescendants = function (entity, rows) {
-        var _this = this;
-        return rows.filter(function (ele) { return !!ele; }).map(function (row) {
-            var _a;
-            var row2 = {};
-            for (var attr in row) {
-                var rel = _this.judgeRelation(entity, attr);
-                if (typeof rel === 'number' && [0, 1].includes(rel)) {
-                    Object.assign(row2, (_a = {},
-                        _a[attr] = row[attr],
-                        _a));
-                }
-            }
-            return row2;
-        });
-    };
-    CascadeStore.prototype.destructCascadeSelect = function (entity, projection2, context, option) {
+    CascadeStore.prototype.destructCascadeSelect = function (entity, projection2, context, cascadeSelect, option) {
         var _this = this;
         var projection = {};
         var cascadeSelectionFns = [];
@@ -95,93 +38,84 @@ var CascadeStore = /** @class */ (function (_super) {
                     entityId: 1,
                 });
                 if (supportMtoJoin) {
-                    cascadeSelectionFns.push(function (result) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                        return tslib_1.__generator(this, function (_a) {
-                            if (!toModi) {
-                                result.forEach(function (ele) {
-                                    if (ele.entity === attr) {
-                                        (0, assert_1.default)(ele.entityId);
-                                        if (!ele[attr]) {
-                                            throw new types_1.OakRowUnexistedException([{
-                                                    entity: attr,
-                                                    selection: {
-                                                        data: projection2[attr],
-                                                        filter: {
-                                                            id: ele.entityId,
-                                                        }
+                    cascadeSelectionFns.push(function (result) {
+                        if (!toModi) {
+                            result.forEach(function (ele) {
+                                if (ele.entity === attr) {
+                                    (0, assert_1.default)(ele.entityId);
+                                    if (!ele[attr]) {
+                                        throw new types_1.OakRowUnexistedException([{
+                                                entity: attr,
+                                                selection: {
+                                                    data: projection2[attr],
+                                                    filter: {
+                                                        id: ele.entityId,
                                                     }
-                                                }]);
-                                        }
+                                                }
+                                            }]);
                                     }
-                                });
-                            }
-                            if (!option.dontCollect) {
-                                this.addToResultSelections(attr, this.reduceDescendants(attr, result.map(function (ele) { return ele[attr]; })), context);
-                            }
-                            return [2 /*return*/];
-                        });
-                    }); });
-                    var _e = this_1.destructCascadeSelect(attr, projection2[attr], context, option), subProjection = _e.projection, subCascadeSelectionFns = _e.cascadeSelectionFns;
+                                }
+                            });
+                        }
+                    });
+                    var _e = this_1.destructCascadeSelect(attr, projection2[attr], context, cascadeSelect, option), subProjection = _e.projection, subCascadeSelectionFns = _e.cascadeSelectionFns;
                     Object.assign(projection, (_b = {},
                         _b[attr] = subProjection,
                         _b));
-                    subCascadeSelectionFns.forEach(function (ele) { return cascadeSelectionFns.push(function (result) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                        return tslib_1.__generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0: return [4 /*yield*/, ele(result.map(function (ele2) { return ele2[attr]; }).filter(function (ele2) { return !!ele2; }))];
-                                case 1:
-                                    _a.sent();
-                                    return [2 /*return*/];
-                            }
-                        });
-                    }); }); });
+                    subCascadeSelectionFns.forEach(function (ele) { return cascadeSelectionFns.push(function (result) {
+                        return ele(result.map(function (ele2) { return ele2[attr]; }).filter(function (ele2) { return !!ele2; }));
+                    }); });
                 }
                 else {
-                    cascadeSelectionFns.push(function (result) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                        var entityIds, subRows;
-                        return tslib_1.__generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0:
-                                    entityIds = (0, lodash_1.uniq)(result.filter(function (ele) { return ele.entity === attr; }).map(function (ele) { return ele.entityId; }));
-                                    return [4 /*yield*/, this.cascadeSelect(attr, {
+                    cascadeSelectionFns.push(function (result) {
+                        var dealWithSubRows = function (subRows) {
+                            (0, assert_1.default)(subRows.length <= entityIds.length);
+                            if (subRows.length < entityIds.length && !toModi) {
+                                throw new types_1.OakRowUnexistedException([{
+                                        entity: attr,
+                                        selection: {
                                             data: projection2[attr],
                                             filter: {
                                                 id: {
                                                     $in: entityIds
                                                 },
                                             },
-                                        }, context, option)];
-                                case 1:
-                                    subRows = _a.sent();
-                                    (0, assert_1.default)(subRows.length <= entityIds.length);
-                                    if (subRows.length < entityIds.length && !toModi) {
-                                        throw new types_1.OakRowUnexistedException([{
-                                                entity: attr,
-                                                selection: {
-                                                    data: projection2[attr],
-                                                    filter: {
-                                                        id: {
-                                                            $in: entityIds
-                                                        },
-                                                    },
-                                                },
-                                            }]);
-                                    }
-                                    result.forEach(function (ele) {
-                                        var _a;
-                                        if (ele.entity === attr) {
-                                            var subRow = subRows.find(function (ele2) { return ele2.id === ele.entityId; });
-                                            if (subRow) {
-                                                Object.assign(ele, (_a = {},
-                                                    _a[attr] = subRow,
-                                                    _a));
-                                            }
-                                        }
-                                    });
-                                    return [2 /*return*/];
+                                        },
+                                    }]);
                             }
-                        });
-                    }); });
+                            result.forEach(function (ele) {
+                                var _a, _b;
+                                if (ele.entity === attr) {
+                                    var subRow = subRows.find(function (ele2) { return ele2.id === ele.entityId; });
+                                    if (subRow) {
+                                        Object.assign(ele, (_a = {},
+                                            _a[attr] = subRow,
+                                            _a));
+                                    }
+                                    else {
+                                        Object.assign(ele, (_b = {},
+                                            _b[attr] = null,
+                                            _b));
+                                    }
+                                }
+                            });
+                        };
+                        var entityIds = (0, lodash_1.uniq)(result.filter(function (ele) { return ele.entity === attr; }).map(function (ele) { return ele.entityId; }));
+                        var subRows = cascadeSelect.call(_this, attr, {
+                            data: projection2[attr],
+                            filter: {
+                                id: {
+                                    $in: entityIds
+                                },
+                            },
+                        }, context, option);
+                        if (subRows instanceof Promise) {
+                            return subRows.then(function (subRowss) { return dealWithSubRows(subRowss); });
+                        }
+                        else {
+                            dealWithSubRows(subRows);
+                        }
+                    });
                 }
             }
             else if (typeof relation === 'string') {
@@ -191,91 +125,85 @@ var CascadeStore = /** @class */ (function (_super) {
                 if (supportMtoJoin) {
                     if (!toModi) {
                         // 如果不是modi，要保证外键没有空指针
-                        cascadeSelectionFns.push(function (result) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                            return tslib_1.__generator(this, function (_a) {
-                                if (!toModi) {
-                                    result.forEach(function (ele) {
-                                        if (ele["".concat(attr, "Id")] && !ele[attr]) {
-                                            throw new types_1.OakRowUnexistedException([{
-                                                    entity: relation,
-                                                    selection: {
-                                                        data: projection2[attr],
-                                                        filter: {
-                                                            id: ele["".concat(attr, "Id")],
-                                                        }
+                        cascadeSelectionFns.push(function (result) {
+                            if (!toModi) {
+                                result.forEach(function (ele) {
+                                    if (ele["".concat(attr, "Id")] && !ele[attr]) {
+                                        throw new types_1.OakRowUnexistedException([{
+                                                entity: relation,
+                                                selection: {
+                                                    data: projection2[attr],
+                                                    filter: {
+                                                        id: ele["".concat(attr, "Id")],
                                                     }
-                                                }]);
-                                        }
-                                    });
-                                }
-                                if (!option.dontCollect) {
-                                    this.addToResultSelections(relation, this.reduceDescendants(relation, result.map(function (ele) { return ele[attr]; })), context);
-                                }
-                                return [2 /*return*/];
-                            });
-                        }); });
+                                                }
+                                            }]);
+                                    }
+                                });
+                            }
+                        });
                     }
-                    var _f = this_1.destructCascadeSelect(relation, projection2[attr], context, option), subProjection = _f.projection, subCascadeSelectionFns = _f.cascadeSelectionFns;
+                    var _f = this_1.destructCascadeSelect(relation, projection2[attr], context, cascadeSelect, option), subProjection = _f.projection, subCascadeSelectionFns = _f.cascadeSelectionFns;
                     Object.assign(projection, (_d = {},
                         _d[attr] = subProjection,
                         _d));
-                    subCascadeSelectionFns.forEach(function (ele) { return cascadeSelectionFns.push(function (result) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                        return tslib_1.__generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0: return [4 /*yield*/, ele(result.map(function (ele2) { return ele2[attr]; }).filter(function (ele2) { return !!ele2; }))];
-                                case 1:
-                                    _a.sent();
-                                    return [2 /*return*/];
-                            }
-                        });
-                    }); }); });
+                    subCascadeSelectionFns.forEach(function (ele) { return cascadeSelectionFns.push(function (result) {
+                        return ele(result.map(function (ele2) { return ele2[attr]; }).filter(function (ele2) { return !!ele2; }));
+                    }); });
                 }
                 else {
-                    cascadeSelectionFns.push(function (result) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                        var ids, subRows;
-                        return tslib_1.__generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0:
-                                    ids = (0, lodash_1.uniq)(result.filter(function (ele) { return !!(ele["".concat(attr, "Id")]); }).map(function (ele) { return ele["".concat(attr, "Id")]; }));
-                                    return [4 /*yield*/, this.cascadeSelect(relation, {
+                    cascadeSelectionFns.push(function (result) {
+                        var dealWithSubRows = function (subRows) {
+                            (0, assert_1.default)(subRows.length <= ids.length);
+                            if (subRows.length < ids.length && !toModi) {
+                                throw new types_1.OakRowUnexistedException([{
+                                        entity: relation,
+                                        selection: {
                                             data: projection2[attr],
                                             filter: {
                                                 id: {
                                                     $in: ids
                                                 },
                                             },
-                                        }, context, option)];
-                                case 1:
-                                    subRows = _a.sent();
-                                    (0, assert_1.default)(subRows.length <= ids.length);
-                                    if (subRows.length < ids.length && !toModi) {
-                                        throw new types_1.OakRowUnexistedException([{
-                                                entity: relation,
-                                                selection: {
-                                                    data: projection2[attr],
-                                                    filter: {
-                                                        id: {
-                                                            $in: ids
-                                                        },
-                                                    },
-                                                }
-                                            }]);
-                                    }
-                                    result.forEach(function (ele) {
-                                        var _a;
-                                        if (ele["".concat(attr, "Id")]) {
-                                            var subRow = subRows.find(function (ele2) { return ele2.id === ele["".concat(attr, "Id")]; });
-                                            if (subRow) {
-                                                Object.assign(ele, (_a = {},
-                                                    _a[attr] = subRow,
-                                                    _a));
-                                            }
                                         }
-                                    });
-                                    return [2 /*return*/];
+                                    }]);
                             }
-                        });
-                    }); });
+                            result.forEach(function (ele) {
+                                var _a, _b, _c;
+                                if (ele["".concat(attr, "Id")]) {
+                                    var subRow = subRows.find(function (ele2) { return ele2.id === ele["".concat(attr, "Id")]; });
+                                    if (subRow) {
+                                        Object.assign(ele, (_a = {},
+                                            _a[attr] = subRow,
+                                            _a));
+                                    }
+                                    else {
+                                        Object.assign(ele, (_b = {},
+                                            _b[attr] = null,
+                                            _b));
+                                    }
+                                }
+                                else {
+                                    Object.assign(ele, (_c = {},
+                                        _c[attr] = null,
+                                        _c));
+                                }
+                            });
+                        };
+                        var ids = (0, lodash_1.uniq)(result.filter(function (ele) { return !!(ele["".concat(attr, "Id")]); }).map(function (ele) { return ele["".concat(attr, "Id")]; }));
+                        var subRows = cascadeSelect.call(_this, relation, {
+                            data: projection2[attr],
+                            filter: {
+                                id: {
+                                    $in: ids
+                                },
+                            },
+                        }, context, option);
+                        if (subRows instanceof Promise) {
+                            return subRows.then(function (subRowss) { return dealWithSubRows(subRowss); });
+                        }
+                        dealWithSubRows(subRows);
+                    });
                 }
             }
             else {
@@ -284,73 +212,67 @@ var CascadeStore = /** @class */ (function (_super) {
                 var _h = tslib_1.__read(relation, 2), entity2_1 = _h[0], foreignKey_1 = _h[1];
                 if (foreignKey_1) {
                     // 基于属性的一对多
-                    cascadeSelectionFns.push(function (result) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                        var ids, subRows;
+                    cascadeSelectionFns.push(function (result) {
                         var _a;
-                        return tslib_1.__generator(this, function (_b) {
-                            switch (_b.label) {
-                                case 0:
-                                    ids = result.map(function (ele) { return ele.id; });
-                                    return [4 /*yield*/, this.cascadeSelect(entity2_1, {
-                                            data: subProjection_1,
-                                            filter: (0, filter_1.combineFilters)([(_a = {},
-                                                    _a[foreignKey_1] = {
-                                                        $in: ids,
-                                                    },
-                                                    _a), subFilter_1]),
-                                            sorter: subSorter_1,
-                                            indexFrom: indexFrom_1,
-                                            count: count_1
-                                        }, context, option)];
-                                case 1:
-                                    subRows = _b.sent();
-                                    result.forEach(function (ele) {
-                                        var _a;
-                                        var subRowss = subRows.filter(function (ele2) { return ele2[foreignKey_1] === ele.id; });
-                                        (0, assert_1.default)(subRowss);
-                                        Object.assign(ele, (_a = {},
-                                            _a[attr] = subRowss,
-                                            _a));
-                                    });
-                                    return [2 /*return*/];
-                            }
-                        });
-                    }); });
+                        var ids = result.map(function (ele) { return ele.id; });
+                        var dealWithSubRows = function (subRows) {
+                            result.forEach(function (ele) {
+                                var _a;
+                                var subRowss = subRows.filter(function (ele2) { return ele2[foreignKey_1] === ele.id; });
+                                (0, assert_1.default)(subRowss);
+                                Object.assign(ele, (_a = {},
+                                    _a[attr] = subRowss,
+                                    _a));
+                            });
+                        };
+                        var subRows = cascadeSelect.call(_this, entity2_1, {
+                            data: subProjection_1,
+                            filter: (0, filter_1.combineFilters)([(_a = {},
+                                    _a[foreignKey_1] = {
+                                        $in: ids,
+                                    },
+                                    _a), subFilter_1]),
+                            sorter: subSorter_1,
+                            indexFrom: indexFrom_1,
+                            count: count_1
+                        }, context, option);
+                        if (subRows instanceof Promise) {
+                            return subRows.then(function (subRowss) { return dealWithSubRows(subRowss); });
+                        }
+                        dealWithSubRows(subRows);
+                    });
                 }
                 else {
                     // 基于entity的多对一
-                    cascadeSelectionFns.push(function (result) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                        var ids, subRows;
-                        return tslib_1.__generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0:
-                                    ids = result.map(function (ele) { return ele.id; });
-                                    return [4 /*yield*/, this.cascadeSelect(entity2_1, {
-                                            data: subProjection_1,
-                                            filter: (0, filter_1.combineFilters)([{
-                                                    entity: entity,
-                                                    entityId: {
-                                                        $in: ids,
-                                                    }
-                                                }, subFilter_1]),
-                                            sorter: subSorter_1,
-                                            indexFrom: indexFrom_1,
-                                            count: count_1
-                                        }, context, option)];
-                                case 1:
-                                    subRows = _a.sent();
-                                    result.forEach(function (ele) {
-                                        var _a;
-                                        var subRowss = subRows.filter(function (ele2) { return ele2.entityId === ele.id; });
-                                        (0, assert_1.default)(subRowss);
-                                        Object.assign(ele, (_a = {},
-                                            _a[attr] = subRowss,
-                                            _a));
-                                    });
-                                    return [2 /*return*/];
-                            }
-                        });
-                    }); });
+                    cascadeSelectionFns.push(function (result) {
+                        var ids = result.map(function (ele) { return ele.id; });
+                        var dealWithSubRows = function (subRows) {
+                            result.forEach(function (ele) {
+                                var _a;
+                                var subRowss = subRows.filter(function (ele2) { return ele2.entityId === ele.id; });
+                                (0, assert_1.default)(subRowss);
+                                Object.assign(ele, (_a = {},
+                                    _a[attr] = subRowss,
+                                    _a));
+                            });
+                        };
+                        var subRows = cascadeSelect.call(_this, entity2_1, {
+                            data: subProjection_1,
+                            filter: (0, filter_1.combineFilters)([{
+                                    entity: entity,
+                                    entityId: {
+                                        $in: ids,
+                                    }
+                                }, subFilter_1]),
+                            sorter: subSorter_1,
+                            indexFrom: indexFrom_1,
+                            count: count_1
+                        }, context, option);
+                        if (subRows instanceof Promise) {
+                            return subRows.then(function (subRowss) { return dealWithSubRows(subRowss); });
+                        }
+                        dealWithSubRows(subRows);
+                    });
                 }
             }
         };
@@ -363,620 +285,6 @@ var CascadeStore = /** @class */ (function (_super) {
             cascadeSelectionFns: cascadeSelectionFns,
         };
     };
-    CascadeStore.prototype.cascadeSelect = function (entity, selection, context, option) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var data, filter, indexFrom, count, sorter, _a, projection, cascadeSelectionFns, rows, ruException_1;
-            var _this = this;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        data = selection.data, filter = selection.filter, indexFrom = selection.indexFrom, count = selection.count, sorter = selection.sorter;
-                        return [4 /*yield*/, this.destructCascadeSelect(entity, data, context, option)];
-                    case 1:
-                        _a = _b.sent(), projection = _a.projection, cascadeSelectionFns = _a.cascadeSelectionFns;
-                        return [4 /*yield*/, this.selectAbjointRow(entity, {
-                                data: projection,
-                                filter: filter,
-                                indexFrom: indexFrom,
-                                count: count,
-                                sorter: sorter
-                            }, context, option)];
-                    case 2:
-                        rows = _b.sent();
-                        if (!option.dontCollect) {
-                            this.addToResultSelections(entity, this.supportMultipleCreate() ? this.reduceDescendants(entity, rows) : rows, context);
-                        }
-                        if (!(cascadeSelectionFns.length > 0)) return [3 /*break*/, 4];
-                        ruException_1 = [];
-                        return [4 /*yield*/, Promise.all(cascadeSelectionFns.map(function (ele) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                                var e_1, rows_1;
-                                return tslib_1.__generator(this, function (_a) {
-                                    switch (_a.label) {
-                                        case 0:
-                                            _a.trys.push([0, 2, , 3]);
-                                            return [4 /*yield*/, ele(rows)];
-                                        case 1:
-                                            _a.sent();
-                                            return [3 /*break*/, 3];
-                                        case 2:
-                                            e_1 = _a.sent();
-                                            if (e_1 instanceof types_1.OakRowUnexistedException) {
-                                                rows_1 = e_1.getRows();
-                                                ruException_1.push.apply(ruException_1, tslib_1.__spreadArray([], tslib_1.__read(rows_1), false));
-                                            }
-                                            else {
-                                                throw e_1;
-                                            }
-                                            return [3 /*break*/, 3];
-                                        case 3: return [2 /*return*/];
-                                    }
-                                });
-                            }); }))];
-                    case 3:
-                        _b.sent();
-                        if (ruException_1.length > 0) {
-                            throw new types_1.OakRowUnexistedException(ruException_1);
-                        }
-                        _b.label = 4;
-                    case 4: return [2 /*return*/, rows];
-                }
-            });
-        });
-    };
-    CascadeStore.prototype.cascadeSelect2 = function (entity, selection, context, option) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var data, filter, projection, oneToMany, oneToManyOnEntity, manyToOne, manyToOneOnEntity, supportMtoJoin, attr, relation, _a, entity2, foreignKey, rows;
-            var _b, _c, _d, _e, _f, _g, _h, _j;
-            var _this = this;
-            return tslib_1.__generator(this, function (_k) {
-                switch (_k.label) {
-                    case 0:
-                        data = selection.data, filter = selection.filter;
-                        projection = {};
-                        oneToMany = {};
-                        oneToManyOnEntity = {};
-                        manyToOne = {};
-                        manyToOneOnEntity = {};
-                        supportMtoJoin = this.supportManyToOneJoin();
-                        for (attr in data) {
-                            relation = (0, relation_1.judgeRelation)(this.storageSchema, entity, attr);
-                            if (relation === 1 || relation == 0) {
-                                Object.assign(projection, (_b = {},
-                                    _b[attr] = data[attr],
-                                    _b));
-                            }
-                            else if (relation === 2) {
-                                // 基于entity的多对一
-                                Object.assign(projection, {
-                                    entity: 1,
-                                    entityId: 1,
-                                });
-                                if (supportMtoJoin) {
-                                    Object.assign(projection, (_c = {},
-                                        _c[attr] = data[attr],
-                                        _c));
-                                }
-                                else {
-                                    Object.assign(manyToOneOnEntity, (_d = {},
-                                        _d[attr] = 1,
-                                        _d));
-                                }
-                            }
-                            else if (typeof relation === 'string') {
-                                // 基于属性的多对一
-                                if (supportMtoJoin) {
-                                    Object.assign(projection, (_e = {},
-                                        _e[attr] = data[attr],
-                                        _e));
-                                }
-                                else {
-                                    Object.assign(projection, (_f = {},
-                                        _f["".concat(attr, "Id")] = 1,
-                                        _f));
-                                    Object.assign(manyToOne, (_g = {},
-                                        _g[attr] = relation,
-                                        _g));
-                                }
-                            }
-                            else {
-                                _a = tslib_1.__read(relation, 2), entity2 = _a[0], foreignKey = _a[1];
-                                if (foreignKey) {
-                                    // 基于属性的一对多
-                                    Object.assign(oneToMany, (_h = {},
-                                        _h[attr] = {
-                                            entity: entity2,
-                                            foreignKey: foreignKey,
-                                        },
-                                        _h));
-                                }
-                                else {
-                                    // 基于entity的多对一
-                                    Object.assign(oneToManyOnEntity, (_j = {},
-                                        _j[attr] = entity2,
-                                        _j));
-                                }
-                            }
-                        }
-                        return [4 /*yield*/, this.selectAbjointRow(entity, Object.assign({}, selection, {
-                                data: projection,
-                            }), context, option)];
-                    case 1:
-                        rows = _k.sent();
-                        if (!option.dontCollect) {
-                            this.addToResultSelections(entity, rows, context);
-                        }
-                        return [4 /*yield*/, Promise.all(
-                            // manyToOne
-                            (function () {
-                                var attrs = Object.keys(manyToOne);
-                                if (attrs.length > 0) {
-                                    return attrs.map(function (attr) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                                        var subRows;
-                                        return tslib_1.__generator(this, function (_a) {
-                                            switch (_a.label) {
-                                                case 0: return [4 /*yield*/, this.cascadeSelect(manyToOne[attr], {
-                                                        data: data[attr],
-                                                        filter: {
-                                                            id: {
-                                                                $in: rows.map(function (row) { return row["".concat(attr, "Id")]; })
-                                                            },
-                                                        }
-                                                    }, context, option)];
-                                                case 1:
-                                                    subRows = _a.sent();
-                                                    rows.forEach(function (row) {
-                                                        var _a;
-                                                        var subRow = subRows.find(function (ele) { return ele.id === row["".concat(attr, "Id")]; });
-                                                        Object.assign(row, (_a = {},
-                                                            _a[attr] = subRow,
-                                                            _a));
-                                                    });
-                                                    return [2 /*return*/];
-                                            }
-                                        });
-                                    }); });
-                                }
-                                return [];
-                            })().concat(
-                            // manyToOneOnEntity
-                            (function () {
-                                var attrs = Object.keys(manyToOneOnEntity);
-                                if (attrs.length > 0) {
-                                    return attrs.map(function (attr) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                                        var subRows;
-                                        return tslib_1.__generator(this, function (_a) {
-                                            switch (_a.label) {
-                                                case 0: return [4 /*yield*/, this.cascadeSelect(attr, {
-                                                        data: data[attr],
-                                                        filter: {
-                                                            id: {
-                                                                $in: rows.filter(function (row) { return row.entity === attr; }).map(function (row) { return row.entityId; })
-                                                            },
-                                                        }
-                                                    }, context, option)];
-                                                case 1:
-                                                    subRows = _a.sent();
-                                                    rows.filter(function (row) { return row.entity === attr; }).forEach(function (row) {
-                                                        var _a;
-                                                        var subRow = subRows.find(function (ele) { return ele.id === row.entityId; });
-                                                        Object.assign(row, (_a = {},
-                                                            _a[attr] = subRow,
-                                                            _a));
-                                                    });
-                                                    return [2 /*return*/];
-                                            }
-                                        });
-                                    }); });
-                                }
-                                return [];
-                            })()).concat((function () {
-                                var attrs = Object.keys(oneToMany);
-                                if (attrs.length > 0) {
-                                    // 必须一行一行的查询，否则indexFrom和count无法准确
-                                    return rows.map(function (row) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                                        var _a, _b, _i, attr, _c, entity2, foreignKey, filter2, rows2;
-                                        var _d, _e;
-                                        return tslib_1.__generator(this, function (_f) {
-                                            switch (_f.label) {
-                                                case 0:
-                                                    _a = [];
-                                                    for (_b in oneToMany)
-                                                        _a.push(_b);
-                                                    _i = 0;
-                                                    _f.label = 1;
-                                                case 1:
-                                                    if (!(_i < _a.length)) return [3 /*break*/, 4];
-                                                    attr = _a[_i];
-                                                    _c = oneToMany[attr], entity2 = _c.entity, foreignKey = _c.foreignKey;
-                                                    filter2 = data[attr];
-                                                    return [4 /*yield*/, this.cascadeSelect(entity2, Object.assign({}, filter2, {
-                                                            filter: (0, filter_1.addFilterSegment)((_d = {},
-                                                                _d[foreignKey] = row.id,
-                                                                _d), filter2.filter),
-                                                        }), context, option)];
-                                                case 2:
-                                                    rows2 = _f.sent();
-                                                    Object.assign(row, (_e = {},
-                                                        _e[attr] = rows2,
-                                                        _e));
-                                                    _f.label = 3;
-                                                case 3:
-                                                    _i++;
-                                                    return [3 /*break*/, 1];
-                                                case 4: return [2 /*return*/];
-                                            }
-                                        });
-                                    }); });
-                                }
-                                return [];
-                            })()).concat((function () {
-                                var attrs = Object.keys(oneToManyOnEntity);
-                                if (attrs.length > 0) {
-                                    // 必须一行一行的查询，否则indexFrom和count无法准确
-                                    return rows.map(function (row) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                                        var _a, _b, _i, attr, filter2, rows2;
-                                        var _c;
-                                        return tslib_1.__generator(this, function (_d) {
-                                            switch (_d.label) {
-                                                case 0:
-                                                    _a = [];
-                                                    for (_b in oneToManyOnEntity)
-                                                        _a.push(_b);
-                                                    _i = 0;
-                                                    _d.label = 1;
-                                                case 1:
-                                                    if (!(_i < _a.length)) return [3 /*break*/, 4];
-                                                    attr = _a[_i];
-                                                    filter2 = data[attr];
-                                                    return [4 /*yield*/, this.cascadeSelect(oneToManyOnEntity[attr], Object.assign({}, filter2, {
-                                                            filter: (0, filter_1.addFilterSegment)({
-                                                                entityId: row.id,
-                                                                entity: entity,
-                                                            }, filter2.filter),
-                                                        }), context, option)];
-                                                case 2:
-                                                    rows2 = _d.sent();
-                                                    Object.assign(row, (_c = {},
-                                                        _c[attr] = rows2,
-                                                        _c));
-                                                    _d.label = 3;
-                                                case 3:
-                                                    _i++;
-                                                    return [3 /*break*/, 1];
-                                                case 4: return [2 /*return*/];
-                                            }
-                                        });
-                                    }); });
-                                }
-                                return [];
-                            })()))];
-                    case 2:
-                        _k.sent();
-                        return [2 /*return*/, rows];
-                }
-            });
-        });
-    };
-    CascadeStore.prototype.destructCascadeUpdate = function (entity, action, data, context, option, result, filter) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var modiAttr, option2, opData, _loop_2, this_2, _a, _b, _i, attr;
-            var _this = this;
-            return tslib_1.__generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        modiAttr = this.getSchema()[entity].toModi;
-                        option2 = Object.assign({}, option);
-                        opData = {};
-                        if (modiAttr && action !== 'remove') {
-                            // create/update具有modi对象的对象，对其子对象的update行为全部是create modi对象（缓存动作）
-                            // delete此对象，所有的modi子对象应该通过触发器作废，这个通过系统的trigger来搞
-                            (0, assert_1.default)(!option2.modiParentId && !option2.modiParentEntity);
-                            if (action === 'create') {
-                                option2.modiParentId = data.id;
-                            }
-                            else {
-                                (0, assert_1.default)((filter === null || filter === void 0 ? void 0 : filter.id) && typeof filter.id === 'string');
-                                option2.modiParentId = filter.id;
-                            }
-                            option2.modiParentEntity = entity;
-                        }
-                        _loop_2 = function (attr) {
-                            var relation, operationMto, actionMto, dataMto, filterMto, fkId, entity_1, result2, operationMto, actionMto, dataMto, filterMto, _d, _e, fkId, result2, _f, entityOtm_1, foreignKey_2, otmOperations, dealWithOneToMany, otmOperations_1, otmOperations_1_1, oper, e_2_1;
-                            var _g, _h, _j, e_2, _k;
-                            return tslib_1.__generator(this, function (_l) {
-                                switch (_l.label) {
-                                    case 0:
-                                        relation = (0, relation_1.judgeRelation)(this_2.storageSchema, entity, attr);
-                                        if (!(relation === 1)) return [3 /*break*/, 1];
-                                        Object.assign(opData, (_g = {},
-                                            _g[attr] = data[attr],
-                                            _g));
-                                        return [3 /*break*/, 16];
-                                    case 1:
-                                        if (!(relation === 2)) return [3 /*break*/, 3];
-                                        operationMto = data[attr];
-                                        actionMto = operationMto.action, dataMto = operationMto.data, filterMto = operationMto.filter;
-                                        if (actionMto === 'create') {
-                                            Object.assign(opData, {
-                                                entityId: dataMto.id,
-                                                entity: attr,
-                                            });
-                                        }
-                                        else if (action === 'create') {
-                                            fkId = data.entityId, entity_1 = data.entity;
-                                            (0, assert_1.default)(typeof fkId === 'string' || entity_1 === attr);
-                                            if (filterMto === null || filterMto === void 0 ? void 0 : filterMto.id) {
-                                                // 若已有id则不用处理，否则会干扰modi的后续判断(会根据filter来判断对象id，如果判断不出来去查实际的对象，但实际的对象其实还未创建好)
-                                                (0, assert_1.default)(filterMto.id === fkId);
-                                            }
-                                            else {
-                                                // A中data的entityId作为B中filter的主键
-                                                Object.assign(operationMto, {
-                                                    filter: (0, filter_1.addFilterSegment)({
-                                                        id: fkId,
-                                                    }),
-                                                    filterMto: filterMto,
-                                                });
-                                            }
-                                        }
-                                        else {
-                                            // 剩下三种情况都是B中的filter的id来自A中row的entityId
-                                            (0, assert_1.default)(!data.hasOwnProperty('entityId') && !data.hasOwnProperty('entity'));
-                                            if (filterMto === null || filterMto === void 0 ? void 0 : filterMto.id) {
-                                                // 若已有id则不用处理，否则会干扰modi的后续判断(会根据filter来判断对象id，如果判断不出来去查实际的对象，但实际的对象其实还未创建好)
-                                                (0, assert_1.default)(typeof filterMto.id === 'string');
-                                            }
-                                            else {
-                                                // A中data的entityId作为B中filter的主键
-                                                Object.assign(operationMto, {
-                                                    filter: (0, filter_1.addFilterSegment)({
-                                                        id: {
-                                                            $in: {
-                                                                entity: entity,
-                                                                data: {
-                                                                    entityId: 1,
-                                                                },
-                                                                filter: (0, filter_1.addFilterSegment)({
-                                                                    entity: attr,
-                                                                }, filter),
-                                                            }
-                                                        },
-                                                    }, filterMto),
-                                                });
-                                            }
-                                        }
-                                        return [4 /*yield*/, this_2.cascadeUpdate(attr, operationMto, context, option2)];
-                                    case 2:
-                                        result2 = _l.sent();
-                                        this_2.mergeOperationResult(result, result2);
-                                        return [3 /*break*/, 16];
-                                    case 3:
-                                        if (!(typeof relation === 'string')) return [3 /*break*/, 5];
-                                        operationMto = data[attr];
-                                        actionMto = operationMto.action, dataMto = operationMto.data, filterMto = operationMto.filter;
-                                        if (actionMto === 'create') {
-                                            Object.assign(opData, (_h = {},
-                                                _h["".concat(attr, "Id")] = dataMto.id,
-                                                _h));
-                                        }
-                                        else if (action === 'create') {
-                                            _d = data, _e = "".concat(attr, "Id"), fkId = _d[_e];
-                                            (0, assert_1.default)(typeof fkId === 'string');
-                                            if (filterMto === null || filterMto === void 0 ? void 0 : filterMto.id) {
-                                                // 若已有id则不用处理，否则会干扰modi的后续判断(会根据filter来判断对象id，如果判断不出来去查实际的对象，但实际的对象其实还未创建好)
-                                                (0, assert_1.default)(filterMto.id === fkId);
-                                            }
-                                            else {
-                                                // A中data的entityId作为B中filter的主键
-                                                Object.assign(operationMto, {
-                                                    filter: (0, filter_1.addFilterSegment)(filterMto || {}, {
-                                                        id: fkId,
-                                                    }),
-                                                });
-                                            }
-                                        }
-                                        else {
-                                            (0, assert_1.default)(!data.hasOwnProperty("".concat(attr, "Id")));
-                                            if (filterMto === null || filterMto === void 0 ? void 0 : filterMto.id) {
-                                                // 若已有id则不用处理，否则会干扰modi的后续判断(会根据filter来判断对象id，如果判断不出来去查实际的对象，但实际的对象其实还未创建好)
-                                                (0, assert_1.default)(typeof filterMto.id === 'string');
-                                            }
-                                            else {
-                                                // A中data的entityId作为B中filter的主键
-                                                Object.assign(operationMto, {
-                                                    filter: (0, filter_1.addFilterSegment)(filterMto || {}, {
-                                                        id: {
-                                                            $in: {
-                                                                entity: entity,
-                                                                data: (_j = {},
-                                                                    _j["".concat(attr, "Id")] = 1,
-                                                                    _j),
-                                                                filter: filter,
-                                                            }
-                                                        },
-                                                    }),
-                                                });
-                                            }
-                                        }
-                                        return [4 /*yield*/, this_2.cascadeUpdate(relation, operationMto, context, option2)];
-                                    case 4:
-                                        result2 = _l.sent();
-                                        this_2.mergeOperationResult(result, result2);
-                                        return [3 /*break*/, 16];
-                                    case 5:
-                                        (0, assert_1.default)(relation instanceof Array);
-                                        _f = tslib_1.__read(relation, 2), entityOtm_1 = _f[0], foreignKey_2 = _f[1];
-                                        otmOperations = data[attr];
-                                        dealWithOneToMany = function (otm) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                                            var actionOtm, dataOtm, filterOtm, id_1, id_2, id, id_3, id_4, id, result2;
-                                            var _a, _b, _c, _d;
-                                            return tslib_1.__generator(this, function (_e) {
-                                                switch (_e.label) {
-                                                    case 0:
-                                                        actionOtm = otm.action, dataOtm = otm.data, filterOtm = otm.filter;
-                                                        if (!foreignKey_2) {
-                                                            // 基于entity/entityId的one-to-many
-                                                            if (action === 'create') {
-                                                                id_1 = data.id;
-                                                                if (dataOtm instanceof Array) {
-                                                                    dataOtm.forEach(function (ele) { return Object.assign(ele, {
-                                                                        entity: entity,
-                                                                        entityId: id_1,
-                                                                    }); });
-                                                                }
-                                                                else {
-                                                                    Object.assign(dataOtm, {
-                                                                        entity: entity,
-                                                                        entityId: id_1,
-                                                                    });
-                                                                }
-                                                            }
-                                                            else if (actionOtm === 'create') {
-                                                                id_2 = filter.id;
-                                                                (0, assert_1.default)(typeof id_2 === 'string');
-                                                                if (dataOtm instanceof Array) {
-                                                                    dataOtm.forEach(function (ele) { return Object.assign(ele, {
-                                                                        entity: entity,
-                                                                        entityId: id_2,
-                                                                    }); });
-                                                                }
-                                                                else {
-                                                                    Object.assign(dataOtm, {
-                                                                        entity: entity,
-                                                                        entityId: id_2,
-                                                                    });
-                                                                }
-                                                            }
-                                                            else {
-                                                                id = filter.id;
-                                                                Object.assign(otm, {
-                                                                    filter: (0, filter_1.addFilterSegment)({
-                                                                        entity: entity,
-                                                                        entityId: id,
-                                                                    }, filterOtm),
-                                                                });
-                                                                if (action === 'remove' && actionOtm === 'update') {
-                                                                    Object.assign(dataOtm, {
-                                                                        entity: null,
-                                                                        entityId: null,
-                                                                    });
-                                                                }
-                                                            }
-                                                        }
-                                                        else {
-                                                            // 基于foreignKey的one-to-many
-                                                            if (action === 'create') {
-                                                                id_3 = data.id;
-                                                                if (dataOtm instanceof Array) {
-                                                                    dataOtm.forEach(function (ele) {
-                                                                        var _a;
-                                                                        return Object.assign(ele, (_a = {},
-                                                                            _a[foreignKey_2] = id_3,
-                                                                            _a));
-                                                                    });
-                                                                }
-                                                                else {
-                                                                    Object.assign(dataOtm, (_a = {},
-                                                                        _a[foreignKey_2] = id_3,
-                                                                        _a));
-                                                                }
-                                                            }
-                                                            else if (actionOtm === 'create') {
-                                                                id_4 = filter.id;
-                                                                (0, assert_1.default)(typeof id_4 === 'string');
-                                                                if (dataOtm instanceof Array) {
-                                                                    dataOtm.forEach(function (ele) {
-                                                                        var _a;
-                                                                        return Object.assign(ele, (_a = {},
-                                                                            _a[foreignKey_2] = id_4,
-                                                                            _a));
-                                                                    });
-                                                                }
-                                                                else {
-                                                                    Object.assign(dataOtm, (_b = {},
-                                                                        _b[foreignKey_2] = id_4,
-                                                                        _b));
-                                                                }
-                                                            }
-                                                            else {
-                                                                id = filter.id;
-                                                                Object.assign(otm, {
-                                                                    filter: (0, filter_1.addFilterSegment)((_c = {},
-                                                                        _c[foreignKey_2] = id,
-                                                                        _c), filterOtm),
-                                                                });
-                                                                if (action === 'remove' && actionOtm === 'update') {
-                                                                    Object.assign(dataOtm, (_d = {},
-                                                                        _d[foreignKey_2] = null,
-                                                                        _d));
-                                                                }
-                                                            }
-                                                        }
-                                                        return [4 /*yield*/, this.cascadeUpdate(entityOtm_1, otm, context, option2)];
-                                                    case 1:
-                                                        result2 = _e.sent();
-                                                        this.mergeOperationResult(result, result2);
-                                                        return [2 /*return*/];
-                                                }
-                                            });
-                                        }); };
-                                        if (!(otmOperations instanceof Array)) return [3 /*break*/, 14];
-                                        _l.label = 6;
-                                    case 6:
-                                        _l.trys.push([6, 11, 12, 13]);
-                                        otmOperations_1 = (e_2 = void 0, tslib_1.__values(otmOperations)), otmOperations_1_1 = otmOperations_1.next();
-                                        _l.label = 7;
-                                    case 7:
-                                        if (!!otmOperations_1_1.done) return [3 /*break*/, 10];
-                                        oper = otmOperations_1_1.value;
-                                        return [4 /*yield*/, dealWithOneToMany(oper)];
-                                    case 8:
-                                        _l.sent();
-                                        _l.label = 9;
-                                    case 9:
-                                        otmOperations_1_1 = otmOperations_1.next();
-                                        return [3 /*break*/, 7];
-                                    case 10: return [3 /*break*/, 13];
-                                    case 11:
-                                        e_2_1 = _l.sent();
-                                        e_2 = { error: e_2_1 };
-                                        return [3 /*break*/, 13];
-                                    case 12:
-                                        try {
-                                            if (otmOperations_1_1 && !otmOperations_1_1.done && (_k = otmOperations_1.return)) _k.call(otmOperations_1);
-                                        }
-                                        finally { if (e_2) throw e_2.error; }
-                                        return [7 /*endfinally*/];
-                                    case 13: return [3 /*break*/, 16];
-                                    case 14: return [4 /*yield*/, dealWithOneToMany(otmOperations)];
-                                    case 15:
-                                        _l.sent();
-                                        _l.label = 16;
-                                    case 16: return [2 /*return*/];
-                                }
-                            });
-                        };
-                        this_2 = this;
-                        _a = [];
-                        for (_b in data)
-                            _a.push(_b);
-                        _i = 0;
-                        _c.label = 1;
-                    case 1:
-                        if (!(_i < _a.length)) return [3 /*break*/, 4];
-                        attr = _a[_i];
-                        return [5 /*yield**/, _loop_2(attr)];
-                    case 2:
-                        _c.sent();
-                        _c.label = 3;
-                    case 3:
-                        _i++;
-                        return [3 /*break*/, 1];
-                    case 4: return [2 /*return*/, opData];
-                }
-            });
-        });
-    };
     /**
      * 级联更新
      * A --> B
@@ -1001,69 +309,320 @@ var CascadeStore = /** @class */ (function (_super) {
      * 两者必须通过entity/entityId关联
      * 此时需要把对B的更新记录成一条新插入的Modi对象，并将A上的entity/entityId指向该对象（新生成的Modi对象的id与此operation的id保持一致）
      * @param entity
-     * @param operation
+     * @param action
+     * @param data
      * @param context
      * @param option
+     * @param result
+     * @param filter
+     * @returns
      */
-    CascadeStore.prototype.cascadeUpdate = function (entity, operation, context, option) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var action, data, filter, id, opData, result, data_1, data_1_1, d, od, e_3_1, operation2, count;
-            var e_3, _a, _b, _c;
-            return tslib_1.__generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        action = operation.action, data = operation.data, filter = operation.filter, id = operation.id;
-                        result = {};
-                        if (!(['create', 'create-l'].includes(action) && data instanceof Array)) return [3 /*break*/, 9];
-                        opData = [];
-                        _d.label = 1;
-                    case 1:
-                        _d.trys.push([1, 6, 7, 8]);
-                        data_1 = tslib_1.__values(data), data_1_1 = data_1.next();
-                        _d.label = 2;
-                    case 2:
-                        if (!!data_1_1.done) return [3 /*break*/, 5];
-                        d = data_1_1.value;
-                        return [4 /*yield*/, this.destructCascadeUpdate(entity, action, d, context, option, result)];
-                    case 3:
-                        od = _d.sent();
-                        opData.push(od);
-                        _d.label = 4;
-                    case 4:
-                        data_1_1 = data_1.next();
-                        return [3 /*break*/, 2];
-                    case 5: return [3 /*break*/, 8];
-                    case 6:
-                        e_3_1 = _d.sent();
-                        e_3 = { error: e_3_1 };
-                        return [3 /*break*/, 8];
-                    case 7:
+    CascadeStore.prototype.destructCascadeUpdate = function (entity, action, data, context, option, cascadeUpdate, filter) {
+        var _this = this;
+        var modiAttr = this.getSchema()[entity].toModi;
+        var option2 = Object.assign({}, option);
+        var opData = {};
+        var beforeFns = [];
+        var afterFns = [];
+        if (modiAttr && action !== 'remove' && !option.dontCreateModi) {
+            // create/update具有modi对象的对象，对其子对象的update行为全部是create modi对象（缓存动作）
+            // delete此对象，所有的modi子对象应该通过触发器作废，这个目前先通过系统的trigger来实现
+            (0, assert_1.default)(!option2.modiParentId && !option2.modiParentEntity);
+            if (action === 'create') {
+                option2.modiParentId = data.id;
+            }
+            else {
+                (0, assert_1.default)((filter === null || filter === void 0 ? void 0 : filter.id) && typeof filter.id === 'string');
+                option2.modiParentId = filter.id;
+            }
+            option2.modiParentEntity = entity;
+        }
+        var _loop_2 = function (attr) {
+            var _a, _b, _c, e_1, _d;
+            var relation = (0, relation_1.judgeRelation)(this_2.storageSchema, entity, attr);
+            if (relation === 1) {
+                Object.assign(opData, (_a = {},
+                    _a[attr] = data[attr],
+                    _a));
+            }
+            else if (relation === 2) {
+                // 基于entity/entityId的many-to-one
+                var operationMto_1 = data[attr];
+                var actionMto = operationMto_1.action, dataMto = operationMto_1.data, filterMto = operationMto_1.filter;
+                if (actionMto === 'create') {
+                    Object.assign(opData, {
+                        entityId: dataMto.id,
+                        entity: attr,
+                    });
+                }
+                else if (action === 'create') {
+                    var fkId = data.entityId, entity_1 = data.entity;
+                    (0, assert_1.default)(typeof fkId === 'string' || entity_1 === attr);
+                    if (filterMto === null || filterMto === void 0 ? void 0 : filterMto.id) {
+                        // 若已有id则不用处理，否则会干扰modi的后续判断(会根据filter来判断对象id，如果判断不出来去查实际的对象，但实际的对象其实还未创建好)
+                        (0, assert_1.default)(filterMto.id === fkId);
+                    }
+                    else {
+                        // A中data的entityId作为B中filter的主键
+                        Object.assign(operationMto_1, {
+                            filter: (0, filter_1.addFilterSegment)({
+                                id: fkId,
+                            }),
+                            filterMto: filterMto,
+                        });
+                    }
+                }
+                else {
+                    // 剩下三种情况都是B中的filter的id来自A中row的entityId
+                    (0, assert_1.default)(!data.hasOwnProperty('entityId') && !data.hasOwnProperty('entity'));
+                    if (filterMto === null || filterMto === void 0 ? void 0 : filterMto.id) {
+                        // 若已有id则不用处理，否则会干扰modi的后续判断(会根据filter来判断对象id，如果判断不出来去查实际的对象，但实际的对象其实还未创建好)
+                        (0, assert_1.default)(typeof filterMto.id === 'string');
+                    }
+                    else {
+                        // A中data的entityId作为B中filter的主键
+                        Object.assign(operationMto_1, {
+                            filter: (0, filter_1.addFilterSegment)({
+                                id: {
+                                    $in: {
+                                        entity: entity,
+                                        data: {
+                                            entityId: 1,
+                                        },
+                                        filter: (0, filter_1.addFilterSegment)({
+                                            entity: attr,
+                                        }, filter),
+                                    }
+                                },
+                            }, filterMto),
+                        });
+                    }
+                }
+                beforeFns.push(function () { return cascadeUpdate.call(_this, attr, operationMto_1, context, option2); });
+            }
+            else if (typeof relation === 'string') {
+                // 基于attr的外键的many-to-one
+                var operationMto_2 = data[attr];
+                var actionMto = operationMto_2.action, dataMto = operationMto_2.data, filterMto = operationMto_2.filter;
+                if (actionMto === 'create') {
+                    Object.assign(opData, (_b = {},
+                        _b["".concat(attr, "Id")] = dataMto.id,
+                        _b));
+                }
+                else if (action === 'create') {
+                    var _e = data, _f = "".concat(attr, "Id"), fkId = _e[_f];
+                    (0, assert_1.default)(typeof fkId === 'string');
+                    if (filterMto === null || filterMto === void 0 ? void 0 : filterMto.id) {
+                        // 若已有id则不用处理，否则会干扰modi的后续判断(会根据filter来判断对象id，如果判断不出来去查实际的对象，但实际的对象其实还未创建好)
+                        (0, assert_1.default)(filterMto.id === fkId);
+                    }
+                    else {
+                        // A中data的entityId作为B中filter的主键
+                        Object.assign(operationMto_2, {
+                            filter: (0, filter_1.addFilterSegment)(filterMto || {}, {
+                                id: fkId,
+                            }),
+                        });
+                    }
+                }
+                else {
+                    (0, assert_1.default)(!data.hasOwnProperty("".concat(attr, "Id")));
+                    if (filterMto === null || filterMto === void 0 ? void 0 : filterMto.id) {
+                        // 若已有id则不用处理，否则会干扰modi的后续判断(会根据filter来判断对象id，如果判断不出来去查实际的对象，但实际的对象其实还未创建好)
+                        (0, assert_1.default)(typeof filterMto.id === 'string');
+                    }
+                    else {
+                        // A中data的entityId作为B中filter的主键
+                        Object.assign(operationMto_2, {
+                            filter: (0, filter_1.addFilterSegment)(filterMto || {}, {
+                                id: {
+                                    $in: {
+                                        entity: entity,
+                                        data: (_c = {},
+                                            _c["".concat(attr, "Id")] = 1,
+                                            _c),
+                                        filter: filter,
+                                    }
+                                },
+                            }),
+                        });
+                    }
+                }
+                beforeFns.push(function () { return cascadeUpdate.call(_this, relation, operationMto_2, context, option2); });
+            }
+            else {
+                (0, assert_1.default)(relation instanceof Array);
+                var _g = tslib_1.__read(relation, 2), entityOtm_1 = _g[0], foreignKey_2 = _g[1];
+                var otmOperations = data[attr];
+                var dealWithOneToMany = function (otm) {
+                    var _a, _b, _c, _d;
+                    var actionOtm = otm.action, dataOtm = otm.data, filterOtm = otm.filter;
+                    if (!foreignKey_2) {
+                        // 基于entity/entityId的one-to-many
+                        if (action === 'create') {
+                            var id_1 = data.id;
+                            if (dataOtm instanceof Array) {
+                                dataOtm.forEach(function (ele) { return Object.assign(ele, {
+                                    entity: entity,
+                                    entityId: id_1,
+                                }); });
+                            }
+                            else {
+                                Object.assign(dataOtm, {
+                                    entity: entity,
+                                    entityId: id_1,
+                                });
+                            }
+                        }
+                        else if (actionOtm === 'create') {
+                            // 这里先假设A（必是update）的filter上一定有id，否则用户界面上应该设计不出来这样的操作
+                            var id_2 = filter.id;
+                            (0, assert_1.default)(typeof id_2 === 'string');
+                            if (dataOtm instanceof Array) {
+                                dataOtm.forEach(function (ele) { return Object.assign(ele, {
+                                    entity: entity,
+                                    entityId: id_2,
+                                }); });
+                            }
+                            else {
+                                Object.assign(dataOtm, {
+                                    entity: entity,
+                                    entityId: id_2,
+                                });
+                            }
+                        }
+                        else {
+                            // 这里先假设A（必是update）的filter上一定有id，否则用户界面上应该设计不出来这样的操作
+                            var id = filter.id;
+                            Object.assign(otm, {
+                                filter: (0, filter_1.addFilterSegment)({
+                                    entity: entity,
+                                    entityId: id,
+                                }, filterOtm),
+                            });
+                            if (action === 'remove' && actionOtm === 'update') {
+                                Object.assign(dataOtm, {
+                                    entity: null,
+                                    entityId: null,
+                                });
+                            }
+                        }
+                    }
+                    else {
+                        // 基于foreignKey的one-to-many
+                        if (action === 'create') {
+                            var id_3 = data.id;
+                            if (dataOtm instanceof Array) {
+                                dataOtm.forEach(function (ele) {
+                                    var _a;
+                                    return Object.assign(ele, (_a = {},
+                                        _a[foreignKey_2] = id_3,
+                                        _a));
+                                });
+                            }
+                            else {
+                                Object.assign(dataOtm, (_a = {},
+                                    _a[foreignKey_2] = id_3,
+                                    _a));
+                            }
+                        }
+                        else if (actionOtm === 'create') {
+                            // 这里先假设A（必是update）的filter上一定有id，否则用户界面上应该设计不出来这样的操作
+                            var id_4 = filter.id;
+                            (0, assert_1.default)(typeof id_4 === 'string');
+                            if (dataOtm instanceof Array) {
+                                dataOtm.forEach(function (ele) {
+                                    var _a;
+                                    return Object.assign(ele, (_a = {},
+                                        _a[foreignKey_2] = id_4,
+                                        _a));
+                                });
+                            }
+                            else {
+                                Object.assign(dataOtm, (_b = {},
+                                    _b[foreignKey_2] = id_4,
+                                    _b));
+                            }
+                        }
+                        else {
+                            // 这里先假设A（必是update）的filter上一定有id，否则用户界面上应该设计不出来这样的操作
+                            var id = filter.id;
+                            Object.assign(otm, {
+                                filter: (0, filter_1.addFilterSegment)((_c = {},
+                                    _c[foreignKey_2] = id,
+                                    _c), filterOtm),
+                            });
+                            if (action === 'remove' && actionOtm === 'update') {
+                                Object.assign(dataOtm, (_d = {},
+                                    _d[foreignKey_2] = null,
+                                    _d));
+                            }
+                        }
+                    }
+                    afterFns.push(function () { return cascadeUpdate.call(_this, entityOtm_1, otm, context, option2); });
+                };
+                if (otmOperations instanceof Array) {
+                    try {
+                        for (var otmOperations_1 = (e_1 = void 0, tslib_1.__values(otmOperations)), otmOperations_1_1 = otmOperations_1.next(); !otmOperations_1_1.done; otmOperations_1_1 = otmOperations_1.next()) {
+                            var oper = otmOperations_1_1.value;
+                            dealWithOneToMany(oper);
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
                         try {
-                            if (data_1_1 && !data_1_1.done && (_a = data_1.return)) _a.call(data_1);
+                            if (otmOperations_1_1 && !otmOperations_1_1.done && (_d = otmOperations_1.return)) _d.call(otmOperations_1);
                         }
-                        finally { if (e_3) throw e_3.error; }
-                        return [7 /*endfinally*/];
-                    case 8: return [3 /*break*/, 11];
-                    case 9: return [4 /*yield*/, this.destructCascadeUpdate(entity, action, data, context, option, result, filter)];
-                    case 10:
-                        opData = _d.sent();
-                        _d.label = 11;
-                    case 11:
-                        operation2 = Object.assign({}, operation, {
-                            data: opData,
-                        });
-                        return [4 /*yield*/, this.doUpdateSingleRow(entity, operation2, context, option)];
-                    case 12:
-                        count = _d.sent();
-                        this.mergeOperationResult(result, (_b = {},
-                            _b[entity] = (_c = {},
-                                _c[operation2.action] = count,
-                                _c),
-                            _b));
-                        return [2 /*return*/, result];
+                        finally { if (e_1) throw e_1.error; }
+                    }
                 }
-            });
-        });
+                else {
+                    dealWithOneToMany(otmOperations);
+                }
+            }
+        };
+        var this_2 = this;
+        for (var attr in data) {
+            _loop_2(attr);
+        }
+        return {
+            data: opData,
+            beforeFns: beforeFns,
+            afterFns: afterFns,
+        };
+    };
+    // 对插入的数据，没有初始值的属性置null
+    CascadeStore.prototype.preProcessDataCreated = function (entity, data) {
+        var now = Date.now();
+        var attributes = this.getSchema()[entity].attributes;
+        var processSingle = function (data2) {
+            var _a, _b;
+            for (var key in attributes) {
+                if (data2[key] === undefined) {
+                    Object.assign(data2, (_a = {},
+                        _a[key] = null,
+                        _a));
+                }
+            }
+            Object.assign(data2, (_b = {},
+                _b[Entity_1.CreateAtAttribute] = now,
+                _b[Entity_1.UpdateAtAttribute] = now,
+                _b));
+        };
+        if (data instanceof Array) {
+            data.forEach(function (ele) { return processSingle(ele); });
+        }
+        else {
+            processSingle(data);
+        }
+    };
+    // 对更新的数据，去掉所有的undefined属性
+    CascadeStore.prototype.preProcessDataUpdated = function (data) {
+        var undefinedKeys = Object.keys(data).filter(function (ele) { return data[ele] === undefined; });
+        undefinedKeys.forEach(function (ele) { return (0, lodash_1.unset)(data, ele); });
+    };
+    CascadeStore.prototype.judgeRelation = function (entity, attr) {
+        return (0, relation_1.judgeRelation)(this.storageSchema, entity, attr);
     };
     /**
      * 和具体的update过程无关的例程放在这里，包括对later动作的处理、对oper的记录以及对record的收集等
@@ -1072,10 +631,10 @@ var CascadeStore = /** @class */ (function (_super) {
      * @param context
      * @param option
      */
-    CascadeStore.prototype.doUpdateSingleRow = function (entity, operation, context, option) {
+    CascadeStore.prototype.doUpdateSingleRowAsync = function (entity, operation, context, option) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var data, action, operId, filter, now, _a, modiCreate, addTimestamp_1, result_1, createInner, multipleCreate, data_2, data_2_1, d, createSingleOper, e_4_1, createOper, _b, ids_1, selection, rows, modiUpsert, upsertModis, _c, originData, originId, createOper, updateAttrCount, result_2;
-            var e_4, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+            var data, action, operId, filter, now, _a, modiCreate, result_1, createInner, multipleCreate, data_1, data_1_1, d, createSingleOper, e_2_1, operatorId, createOper, _b, ids_1, selection, rows, modiUpsert, upsertModis, _c, originData, originId, createOper, updateAttrCount, result;
+            var e_2, _d, _e, _f, _g, _h, _j, _k, _l, _m;
             var _this = this;
             return tslib_1.__generator(this, function (_o) {
                 switch (_o.label) {
@@ -1088,6 +647,7 @@ var CascadeStore = /** @class */ (function (_super) {
                         }
                         return [3 /*break*/, 23];
                     case 1:
+                        this.preProcessDataCreated(entity, data);
                         if (!(option.modiParentEntity && !['modi', 'modiEntity', 'oper', 'operEntity'].includes(entity))) return [3 /*break*/, 3];
                         modiCreate = {
                             id: 'dummy',
@@ -1107,35 +667,25 @@ var CascadeStore = /** @class */ (function (_super) {
                                 iState: 'active',
                             },
                         };
-                        return [4 /*yield*/, this.cascadeUpdate('modi', modiCreate, context, option)];
+                        return [4 /*yield*/, this.cascadeUpdateAsync('modi', modiCreate, context, option)];
                     case 2:
                         _o.sent();
                         return [2 /*return*/, 1];
                     case 3:
-                        addTimestamp_1 = function (data2) {
-                            Object.assign(data2, {
-                                $$createAt$$: now,
-                                $$updateAt$$: now,
-                            });
-                        };
-                        if (data instanceof Array) {
-                            data.forEach(function (ele) { return addTimestamp_1(ele); });
-                        }
-                        else {
-                            addTimestamp_1(data);
-                        }
+                        result_1 = 0;
                         createInner = function (operation2) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                            var e_5;
-                            return tslib_1.__generator(this, function (_a) {
-                                switch (_a.label) {
+                            var _a, e_3;
+                            return tslib_1.__generator(this, function (_b) {
+                                switch (_b.label) {
                                     case 0:
-                                        _a.trys.push([0, 2, , 3]);
-                                        return [4 /*yield*/, this.updateAbjointRow(entity, operation2, context, option)];
+                                        _b.trys.push([0, 2, , 3]);
+                                        _a = result_1;
+                                        return [4 /*yield*/, this.updateAbjointRowAsync(entity, operation2, context, option)];
                                     case 1:
-                                        result_1 = _a.sent();
+                                        result_1 = _a + _b.sent();
                                         return [3 /*break*/, 3];
                                     case 2:
-                                        e_5 = _a.sent();
+                                        e_3 = _b.sent();
                                         /* 这段代码是处理插入时有重复的行，现在看有问题，等实际需求出现再写
                                         if (e instanceof OakCongruentRowExists) {
                                             if (option.allowExists) {
@@ -1199,7 +749,7 @@ var CascadeStore = /** @class */ (function (_super) {
                                                 }
                                             }
                                         } */
-                                        throw e_5;
+                                        throw e_3;
                                     case 3: return [2 /*return*/];
                                 }
                             });
@@ -1213,11 +763,11 @@ var CascadeStore = /** @class */ (function (_super) {
                         return [3 /*break*/, 12];
                     case 5:
                         _o.trys.push([5, 10, 11, 12]);
-                        data_2 = tslib_1.__values(data), data_2_1 = data_2.next();
+                        data_1 = tslib_1.__values(data), data_1_1 = data_1.next();
                         _o.label = 6;
                     case 6:
-                        if (!!data_2_1.done) return [3 /*break*/, 9];
-                        d = data_2_1.value;
+                        if (!!data_1_1.done) return [3 /*break*/, 9];
+                        d = data_1_1.value;
                         createSingleOper = {
                             id: 'any',
                             action: 'create',
@@ -1228,18 +778,18 @@ var CascadeStore = /** @class */ (function (_super) {
                         _o.sent();
                         _o.label = 8;
                     case 8:
-                        data_2_1 = data_2.next();
+                        data_1_1 = data_1.next();
                         return [3 /*break*/, 6];
                     case 9: return [3 /*break*/, 12];
                     case 10:
-                        e_4_1 = _o.sent();
-                        e_4 = { error: e_4_1 };
+                        e_2_1 = _o.sent();
+                        e_2 = { error: e_2_1 };
                         return [3 /*break*/, 12];
                     case 11:
                         try {
-                            if (data_2_1 && !data_2_1.done && (_d = data_2.return)) _d.call(data_2);
+                            if (data_1_1 && !data_1_1.done && (_d = data_1.return)) _d.call(data_1);
                         }
-                        finally { if (e_4) throw e_4.error; }
+                        finally { if (e_2) throw e_2.error; }
                         return [7 /*endfinally*/];
                     case 12: return [3 /*break*/, 15];
                     case 13: return [4 /*yield*/, createInner(operation)];
@@ -1257,6 +807,10 @@ var CascadeStore = /** @class */ (function (_super) {
                         if (!(!option.dontCreateOper && !['oper', 'operEntity', 'modiEntity', 'modi'].includes(entity))) return [3 /*break*/, 22];
                         // 按照框架要求生成Oper和OperEntity这两个内置的对象
                         (0, assert_1.default)(operId);
+                        return [4 /*yield*/, context.getCurrentUserId(true)];
+                    case 16:
+                        operatorId = _o.sent();
+                        if (!operatorId) return [3 /*break*/, 22];
                         _e = {
                             id: 'dummy',
                             action: 'create'
@@ -1264,11 +818,9 @@ var CascadeStore = /** @class */ (function (_super) {
                         _f = {
                             id: operId,
                             action: action,
-                            data: data
+                            data: data,
+                            operatorId: operatorId
                         };
-                        return [4 /*yield*/, context.getCurrentUserId()];
-                    case 16:
-                        _f.operatorId = _o.sent();
                         if (!(data instanceof Array)) return [3 /*break*/, 18];
                         _g = {
                             id: 'dummy',
@@ -1280,7 +832,7 @@ var CascadeStore = /** @class */ (function (_super) {
                                     switch (_b.label) {
                                         case 0:
                                             _a = {};
-                                            return [4 /*yield*/, generateNewId()];
+                                            return [4 /*yield*/, (0, uuid_1.generateNewIdAsync)()];
                                         case 1: return [2 /*return*/, (_a.id = _b.sent(),
                                                 _a.entity = entity,
                                                 _a.entityId = ele.id,
@@ -1298,7 +850,7 @@ var CascadeStore = /** @class */ (function (_super) {
                             action: 'create'
                         };
                         _j = {};
-                        return [4 /*yield*/, generateNewId()];
+                        return [4 /*yield*/, (0, uuid_1.generateNewIdAsync)()];
                     case 19:
                         _b = [(_h.data = (_j.id = _o.sent(),
                                 _j.entity = entity,
@@ -1310,7 +862,7 @@ var CascadeStore = /** @class */ (function (_super) {
                         createOper = (_e.data = (_f.operEntity$oper = _b,
                             _f),
                             _e);
-                        return [4 /*yield*/, this.cascadeUpdate('oper', createOper, context, {
+                        return [4 /*yield*/, this.cascadeUpdateAsync('oper', createOper, context, {
                                 dontCollect: true,
                                 dontCreateOper: true,
                             })];
@@ -1319,7 +871,7 @@ var CascadeStore = /** @class */ (function (_super) {
                         _o.label = 22;
                     case 22: return [2 /*return*/, result_1];
                     case 23:
-                        ids_1 = (0, filter_1.getRelevantIds)(filter);
+                        ids_1 = (0, filter_2.getRelevantIds)(filter);
                         if (!(ids_1.length === 0)) return [3 /*break*/, 25];
                         selection = {
                             data: {
@@ -1329,7 +881,7 @@ var CascadeStore = /** @class */ (function (_super) {
                             indexFrom: operation.indexFrom,
                             count: operation.count,
                         };
-                        return [4 /*yield*/, this.selectAbjointRow(entity, selection, context, {
+                        return [4 /*yield*/, this.selectAbjointRowAsync(entity, selection, context, {
                                 dontCollect: true,
                             })];
                     case 24:
@@ -1337,10 +889,13 @@ var CascadeStore = /** @class */ (function (_super) {
                         ids_1.push.apply(ids_1, tslib_1.__spreadArray([], tslib_1.__read((rows.map(function (ele) { return ele.id; }))), false));
                         _o.label = 25;
                     case 25:
+                        if (data) {
+                            this.preProcessDataUpdated(data);
+                        }
                         if (!(option.modiParentEntity && !['modi', 'modiEntity'].includes(entity))) return [3 /*break*/, 31];
                         modiUpsert = void 0;
                         if (!(action !== 'remove')) return [3 /*break*/, 27];
-                        return [4 /*yield*/, this.selectAbjointRow('modi', {
+                        return [4 /*yield*/, this.selectAbjointRowAsync('modi', {
                                 data: {
                                     id: 1,
                                     data: 1,
@@ -1351,11 +906,11 @@ var CascadeStore = /** @class */ (function (_super) {
                                         $in: ['create', 'update'],
                                     },
                                     iState: 'active',
-                                    filter: {
+                                    filter: ids_1.length > 0 ? {
                                         id: {
                                             $in: ids_1,
                                         },
-                                    }
+                                    } : filter,
                                 },
                                 sorter: [
                                     {
@@ -1398,11 +953,7 @@ var CascadeStore = /** @class */ (function (_super) {
                             action: action,
                             data: data,
                             iState: 'active',
-                            filter: {
-                                id: {
-                                    $in: ids_1,
-                                },
-                            }
+                            filter: filter
                         };
                         _m = {
                             id: 'dummy',
@@ -1414,7 +965,7 @@ var CascadeStore = /** @class */ (function (_super) {
                                     switch (_b.label) {
                                         case 0:
                                             _a = {};
-                                            return [4 /*yield*/, generateNewId()];
+                                            return [4 /*yield*/, (0, uuid_1.generateNewIdAsync)()];
                                         case 1: return [2 /*return*/, (_a.id = _b.sent(),
                                                 _a.entity = entity,
                                                 _a.entityId = id,
@@ -1428,7 +979,7 @@ var CascadeStore = /** @class */ (function (_super) {
                             _l),
                             _k);
                         _o.label = 29;
-                    case 29: return [4 /*yield*/, this.cascadeUpdate('modi', modiUpsert, context, option)];
+                    case 29: return [4 /*yield*/, this.cascadeUpdateAsync('modi', modiUpsert, context, option)];
                     case 30:
                         _o.sent();
                         return [2 /*return*/, 1];
@@ -1462,7 +1013,7 @@ var CascadeStore = /** @class */ (function (_super) {
                                                     switch (_b.label) {
                                                         case 0:
                                                             _a = {};
-                                                            return [4 /*yield*/, generateNewId()];
+                                                            return [4 /*yield*/, (0, uuid_1.generateNewIdAsync)()];
                                                         case 1: return [2 /*return*/, (_a.id = _b.sent(),
                                                                 _a.entity = entity,
                                                                 _a.entityId = ele,
@@ -1475,7 +1026,7 @@ var CascadeStore = /** @class */ (function (_super) {
                                             _c),
                                             _b),
                                             _a);
-                                        return [4 /*yield*/, this.cascadeUpdate('oper', createOper_1, context, {
+                                        return [4 /*yield*/, this.cascadeUpdateAsync('oper', createOper_1, context, {
                                                 dontCollect: true,
                                                 dontCreateOper: true,
                                             })];
@@ -1528,19 +1079,432 @@ var CascadeStore = /** @class */ (function (_super) {
                         _o.sent();
                         return [2 /*return*/, 0];
                     case 35: return [2 /*return*/, 0];
-                    case 36: return [4 /*yield*/, this.updateAbjointRow(entity, operation, context, option)];
+                    case 36: return [4 /*yield*/, this.updateAbjointRowAsync(entity, operation, context, option)];
                     case 37:
-                        result_2 = _o.sent();
+                        result = _o.sent();
                         return [4 /*yield*/, createOper()];
                     case 38:
                         _o.sent();
-                        return [2 /*return*/, result_2];
+                        return [2 /*return*/, result];
                 }
             });
         });
     };
-    CascadeStore.prototype.judgeRelation = function (entity, attr) {
-        return (0, relation_1.judgeRelation)(this.storageSchema, entity, attr);
+    CascadeStore.prototype.doUpdateSingleRow = function (entity, operation, context, option) {
+        var e_4, _a;
+        var _this = this;
+        var data = operation.data, action = operation.action, operId = operation.id, filter = operation.filter;
+        var now = Date.now();
+        switch (action) {
+            case 'create': {
+                this.preProcessDataCreated(entity, data);
+                var result_2 = 0;
+                var createInner = function (operation2) {
+                    try {
+                        result_2 += _this.updateAbjointRow(entity, operation2, context, option);
+                    }
+                    catch (e) {
+                        throw e;
+                    }
+                };
+                if (data instanceof Array) {
+                    var multipleCreate = this.supportMultipleCreate();
+                    if (multipleCreate) {
+                        createInner(operation);
+                    }
+                    else {
+                        try {
+                            for (var data_2 = tslib_1.__values(data), data_2_1 = data_2.next(); !data_2_1.done; data_2_1 = data_2.next()) {
+                                var d = data_2_1.value;
+                                var createSingleOper = {
+                                    id: 'any',
+                                    action: 'create',
+                                    data: d,
+                                };
+                                createInner(createSingleOper);
+                            }
+                        }
+                        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                        finally {
+                            try {
+                                if (data_2_1 && !data_2_1.done && (_a = data_2.return)) _a.call(data_2);
+                            }
+                            finally { if (e_4) throw e_4.error; }
+                        }
+                    }
+                }
+                else {
+                    createInner(operation);
+                }
+                return result_2;
+            }
+            default: {
+                if (action === 'remove') {
+                }
+                else {
+                    var updateAttrCount = Object.keys(data).length;
+                    if (updateAttrCount > 0) {
+                        // 优化一下，如果不更新任何属性，则不实际执行
+                        Object.assign(data, {
+                            $$updateAt$$: now,
+                        });
+                        this.preProcessDataUpdated(data);
+                    }
+                    else {
+                        return 0;
+                    }
+                }
+                return this.updateAbjointRow(entity, operation, context, option);
+            }
+        }
+    };
+    CascadeStore.prototype.cascadeUpdate = function (entity, operation, context, option) {
+        var e_5, _a, e_6, _b, e_7, _c;
+        var action = operation.action, data = operation.data, filter = operation.filter, id = operation.id;
+        var opData;
+        var wholeBeforeFns = [];
+        var wholeAfterFns = [];
+        var result = {};
+        if (['create', 'create-l'].includes(action) && data instanceof Array) {
+            opData = [];
+            try {
+                for (var data_3 = tslib_1.__values(data), data_3_1 = data_3.next(); !data_3_1.done; data_3_1 = data_3.next()) {
+                    var d = data_3_1.value;
+                    var _d = this.destructCascadeUpdate(entity, action, d, context, option, this.cascadeUpdate), od = _d.data, beforeFns = _d.beforeFns, afterFns = _d.afterFns;
+                    opData.push(od);
+                    wholeBeforeFns.push.apply(wholeBeforeFns, tslib_1.__spreadArray([], tslib_1.__read(beforeFns), false));
+                    wholeAfterFns.push.apply(wholeAfterFns, tslib_1.__spreadArray([], tslib_1.__read(afterFns), false));
+                }
+            }
+            catch (e_5_1) { e_5 = { error: e_5_1 }; }
+            finally {
+                try {
+                    if (data_3_1 && !data_3_1.done && (_a = data_3.return)) _a.call(data_3);
+                }
+                finally { if (e_5) throw e_5.error; }
+            }
+        }
+        else {
+            var _e = this.destructCascadeUpdate(entity, action, data, context, option, this.cascadeUpdate, filter), od = _e.data, beforeFns = _e.beforeFns, afterFns = _e.afterFns;
+            opData = od;
+            wholeBeforeFns.push.apply(wholeBeforeFns, tslib_1.__spreadArray([], tslib_1.__read(beforeFns), false));
+            wholeAfterFns.push.apply(wholeAfterFns, tslib_1.__spreadArray([], tslib_1.__read(afterFns), false));
+        }
+        var operation2 = Object.assign({}, operation, {
+            data: opData,
+        });
+        try {
+            for (var wholeBeforeFns_1 = tslib_1.__values(wholeBeforeFns), wholeBeforeFns_1_1 = wholeBeforeFns_1.next(); !wholeBeforeFns_1_1.done; wholeBeforeFns_1_1 = wholeBeforeFns_1.next()) {
+                var before_1 = wholeBeforeFns_1_1.value;
+                before_1();
+            }
+        }
+        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+        finally {
+            try {
+                if (wholeBeforeFns_1_1 && !wholeBeforeFns_1_1.done && (_b = wholeBeforeFns_1.return)) _b.call(wholeBeforeFns_1);
+            }
+            finally { if (e_6) throw e_6.error; }
+        }
+        var count = this.doUpdateSingleRow(entity, operation2, context, option);
+        try {
+            for (var wholeAfterFns_1 = tslib_1.__values(wholeAfterFns), wholeAfterFns_1_1 = wholeAfterFns_1.next(); !wholeAfterFns_1_1.done; wholeAfterFns_1_1 = wholeAfterFns_1.next()) {
+                var after_1 = wholeAfterFns_1_1.value;
+                after_1();
+            }
+        }
+        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+        finally {
+            try {
+                if (wholeAfterFns_1_1 && !wholeAfterFns_1_1.done && (_c = wholeAfterFns_1.return)) _c.call(wholeAfterFns_1);
+            }
+            finally { if (e_7) throw e_7.error; }
+        }
+        return result;
+    };
+    /**
+     *
+     * @param entity
+     * @param operation
+     * @param context
+     * @param option
+     */
+    CascadeStore.prototype.cascadeUpdateAsync = function (entity, operation, context, option) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var action, data, filter, id, opData, wholeBeforeFns, wholeAfterFns, result, data_4, data_4_1, d, _a, od, beforeFns, afterFns, _b, od, beforeFns, afterFns, operation2, wholeBeforeFns_2, wholeBeforeFns_2_1, before_2, e_8_1, count, wholeAfterFns_2, wholeAfterFns_2_1, after_2, e_9_1;
+            var e_10, _c, e_8, _d, _e, _f, e_9, _g;
+            return tslib_1.__generator(this, function (_h) {
+                switch (_h.label) {
+                    case 0:
+                        action = operation.action, data = operation.data, filter = operation.filter, id = operation.id;
+                        wholeBeforeFns = [];
+                        wholeAfterFns = [];
+                        result = {};
+                        if (['create', 'create-l'].includes(action) && data instanceof Array) {
+                            opData = [];
+                            try {
+                                for (data_4 = tslib_1.__values(data), data_4_1 = data_4.next(); !data_4_1.done; data_4_1 = data_4.next()) {
+                                    d = data_4_1.value;
+                                    _a = this.destructCascadeUpdate(entity, action, d, context, option, this.cascadeUpdateAsync), od = _a.data, beforeFns = _a.beforeFns, afterFns = _a.afterFns;
+                                    opData.push(od);
+                                    wholeBeforeFns.push.apply(wholeBeforeFns, tslib_1.__spreadArray([], tslib_1.__read(beforeFns), false));
+                                    wholeAfterFns.push.apply(wholeAfterFns, tslib_1.__spreadArray([], tslib_1.__read(afterFns), false));
+                                }
+                            }
+                            catch (e_10_1) { e_10 = { error: e_10_1 }; }
+                            finally {
+                                try {
+                                    if (data_4_1 && !data_4_1.done && (_c = data_4.return)) _c.call(data_4);
+                                }
+                                finally { if (e_10) throw e_10.error; }
+                            }
+                        }
+                        else {
+                            _b = this.destructCascadeUpdate(entity, action, data, context, option, this.cascadeUpdateAsync, filter), od = _b.data, beforeFns = _b.beforeFns, afterFns = _b.afterFns;
+                            opData = od;
+                            wholeBeforeFns.push.apply(wholeBeforeFns, tslib_1.__spreadArray([], tslib_1.__read(beforeFns), false));
+                            wholeAfterFns.push.apply(wholeAfterFns, tslib_1.__spreadArray([], tslib_1.__read(afterFns), false));
+                        }
+                        operation2 = Object.assign({}, operation, {
+                            data: opData,
+                        });
+                        _h.label = 1;
+                    case 1:
+                        _h.trys.push([1, 6, 7, 8]);
+                        wholeBeforeFns_2 = tslib_1.__values(wholeBeforeFns), wholeBeforeFns_2_1 = wholeBeforeFns_2.next();
+                        _h.label = 2;
+                    case 2:
+                        if (!!wholeBeforeFns_2_1.done) return [3 /*break*/, 5];
+                        before_2 = wholeBeforeFns_2_1.value;
+                        return [4 /*yield*/, before_2()];
+                    case 3:
+                        _h.sent();
+                        _h.label = 4;
+                    case 4:
+                        wholeBeforeFns_2_1 = wholeBeforeFns_2.next();
+                        return [3 /*break*/, 2];
+                    case 5: return [3 /*break*/, 8];
+                    case 6:
+                        e_8_1 = _h.sent();
+                        e_8 = { error: e_8_1 };
+                        return [3 /*break*/, 8];
+                    case 7:
+                        try {
+                            if (wholeBeforeFns_2_1 && !wholeBeforeFns_2_1.done && (_d = wholeBeforeFns_2.return)) _d.call(wholeBeforeFns_2);
+                        }
+                        finally { if (e_8) throw e_8.error; }
+                        return [7 /*endfinally*/];
+                    case 8: return [4 /*yield*/, this.doUpdateSingleRowAsync(entity, operation2, context, option)];
+                    case 9:
+                        count = _h.sent();
+                        this.mergeOperationResult(result, (_e = {},
+                            _e[entity] = (_f = {},
+                                _f[operation2.action] = count,
+                                _f),
+                            _e));
+                        _h.label = 10;
+                    case 10:
+                        _h.trys.push([10, 15, 16, 17]);
+                        wholeAfterFns_2 = tslib_1.__values(wholeAfterFns), wholeAfterFns_2_1 = wholeAfterFns_2.next();
+                        _h.label = 11;
+                    case 11:
+                        if (!!wholeAfterFns_2_1.done) return [3 /*break*/, 14];
+                        after_2 = wholeAfterFns_2_1.value;
+                        return [4 /*yield*/, after_2()];
+                    case 12:
+                        _h.sent();
+                        _h.label = 13;
+                    case 13:
+                        wholeAfterFns_2_1 = wholeAfterFns_2.next();
+                        return [3 /*break*/, 11];
+                    case 14: return [3 /*break*/, 17];
+                    case 15:
+                        e_9_1 = _h.sent();
+                        e_9 = { error: e_9_1 };
+                        return [3 /*break*/, 17];
+                    case 16:
+                        try {
+                            if (wholeAfterFns_2_1 && !wholeAfterFns_2_1.done && (_g = wholeAfterFns_2.return)) _g.call(wholeAfterFns_2);
+                        }
+                        finally { if (e_9) throw e_9.error; }
+                        return [7 /*endfinally*/];
+                    case 17: return [2 /*return*/, result];
+                }
+            });
+        });
+    };
+    CascadeStore.prototype.cascadeSelect = function (entity, selection, context, option) {
+        var data = selection.data, filter = selection.filter, indexFrom = selection.indexFrom, count = selection.count, sorter = selection.sorter;
+        var _a = this.destructCascadeSelect(entity, data, context, this.cascadeSelect, option), projection = _a.projection, cascadeSelectionFns = _a.cascadeSelectionFns;
+        var rows = this.selectAbjointRow(entity, {
+            data: projection,
+            filter: filter,
+            indexFrom: indexFrom,
+            count: count,
+            sorter: sorter
+        }, context, option);
+        if (cascadeSelectionFns.length > 0) {
+            var ruException_1 = [];
+            cascadeSelectionFns.forEach(function (ele) {
+                try {
+                    ele(rows);
+                }
+                catch (e) {
+                    if (e instanceof types_1.OakRowUnexistedException) {
+                        var rows_1 = e.getRows();
+                        ruException_1.push.apply(ruException_1, tslib_1.__spreadArray([], tslib_1.__read(rows_1), false));
+                    }
+                    else {
+                        throw e;
+                    }
+                }
+            });
+            if (ruException_1.length > 0) {
+                throw new types_1.OakRowUnexistedException(ruException_1);
+            }
+        }
+        return rows;
+    };
+    /**
+     * 将一次查询的结果集加入result
+     * todo 如果是supportMtoOJoin，这里还要解构（未充分测试）
+     * @param entity
+     * @param rows
+     * @param context
+     */
+    CascadeStore.prototype.addToResultSelections = function (entity, rows, context) {
+        if (this.supportManyToOneJoin()) {
+            var attrsToPick_1 = [];
+            var _loop_3 = function (attr) {
+                var data = {};
+                var rel = this_3.judgeRelation(entity, attr);
+                if (rel === 2) {
+                    this_3.addToResultSelections(attr, rows.map(function (ele) { return ele[attr]; }), context);
+                }
+                else if (typeof rel === 'string') {
+                    this_3.addToResultSelections(rel, rows.map(function (ele) { return ele[attr]; }), context);
+                }
+                else if (rel instanceof Array) {
+                    this_3.addToResultSelections(rel[0], rows.map(function (ele) { return ele[attr]; }).reduce(function (prev, current) { return prev.concat(current); }, []), context);
+                }
+                else {
+                    attrsToPick_1.push(attr);
+                }
+            };
+            var this_3 = this;
+            for (var attr in rows[0]) {
+                _loop_3(attr);
+            }
+            var originRows = rows.map(function (ele) { return (0, lodash_1.pick)(ele, attrsToPick_1); });
+            this.addSingleRowToResultSelections(entity, originRows, context);
+        }
+        else {
+            this.addSingleRowToResultSelections(entity, rows, context);
+        }
+    };
+    CascadeStore.prototype.addSingleRowToResultSelections = function (entity, rows, context) {
+        var _a;
+        var opRecords = context.opRecords;
+        var lastOperation = opRecords[opRecords.length - 1];
+        if (lastOperation && lastOperation.a === 's') {
+            var entityBranch_1 = lastOperation.d[entity];
+            if (entityBranch_1) {
+                rows.forEach(function (row) {
+                    var _a;
+                    if (row) {
+                        (0, assert_1.default)(row.id);
+                        var id = row.id;
+                        if (!entityBranch_1[id]) {
+                            Object.assign(entityBranch_1, (_a = {},
+                                _a[id] = row,
+                                _a));
+                        }
+                        else {
+                            Object.assign(entityBranch_1[id], row);
+                        }
+                    }
+                });
+                return;
+            }
+        }
+        else {
+            lastOperation = {
+                a: 's',
+                d: {},
+            };
+            opRecords.push(lastOperation);
+        }
+        var entityBranch = {};
+        rows.forEach(function (row) {
+            var _a;
+            if (row) {
+                var id = row.id;
+                Object.assign(entityBranch, (_a = {},
+                    _a[id] = row,
+                    _a));
+            }
+        });
+        Object.assign(lastOperation.d, (_a = {},
+            _a[entity] = entityBranch,
+            _a));
+    };
+    CascadeStore.prototype.cascadeSelectAsync = function (entity, selection, context, option) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var data, filter, indexFrom, count, sorter, _a, projection, cascadeSelectionFns, rows, ruException_2;
+            var _this = this;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        data = selection.data, filter = selection.filter, indexFrom = selection.indexFrom, count = selection.count, sorter = selection.sorter;
+                        _a = this.destructCascadeSelect(entity, data, context, this.cascadeSelectAsync, option), projection = _a.projection, cascadeSelectionFns = _a.cascadeSelectionFns;
+                        return [4 /*yield*/, this.selectAbjointRowAsync(entity, {
+                                data: projection,
+                                filter: filter,
+                                indexFrom: indexFrom,
+                                count: count,
+                                sorter: sorter
+                            }, context, option)];
+                    case 1:
+                        rows = _b.sent();
+                        if (!option.dontCollect) {
+                            this.addToResultSelections(entity, rows, context);
+                        }
+                        if (!(cascadeSelectionFns.length > 0)) return [3 /*break*/, 3];
+                        ruException_2 = [];
+                        return [4 /*yield*/, Promise.all(cascadeSelectionFns.map(function (ele) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                var e_11, rows_2;
+                                return tslib_1.__generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            _a.trys.push([0, 2, , 3]);
+                                            return [4 /*yield*/, ele(rows)];
+                                        case 1:
+                                            _a.sent();
+                                            return [3 /*break*/, 3];
+                                        case 2:
+                                            e_11 = _a.sent();
+                                            if (e_11 instanceof types_1.OakRowUnexistedException) {
+                                                rows_2 = e_11.getRows();
+                                                ruException_2.push.apply(ruException_2, tslib_1.__spreadArray([], tslib_1.__read(rows_2), false));
+                                            }
+                                            else {
+                                                throw e_11;
+                                            }
+                                            return [3 /*break*/, 3];
+                                        case 3: return [2 /*return*/];
+                                    }
+                                });
+                            }); }))];
+                    case 2:
+                        _b.sent();
+                        if (ruException_2.length > 0) {
+                            throw new types_1.OakRowUnexistedException(ruException_2);
+                        }
+                        _b.label = 3;
+                    case 3: return [2 /*return*/, rows];
+                }
+            });
+        });
     };
     return CascadeStore;
 }(RowStore_1.RowStore));