oak-domain 1.1.4 → 1.1.7

package/lib/actions/action.d.ts

@@ -4,11 +4,13 @@ export declare type AppendOnlyAction = ReadOnlyAction | 'create';
 export declare type ExcludeUpdateAction = AppendOnlyAction | 'remove';
 export declare type ExcludeRemoveAction = AppendOnlyAction | 'update';
 export declare type GenericAction = 'update' | ExcludeUpdateAction;
+export declare type RelationAction = 'grant' | 'revoke';
 export declare const readOnlyActions: string[];
 export declare const appendOnlyActions: string[];
 export declare const excludeUpdateActions: string[];
 export declare const exludeRemoveActions: string[];
 export declare const genericActions: string[];
+export declare const relationActions: string[];
 export declare type AbleAction = 'enable' | 'disable';
 export declare type AbleState = 'enabled' | 'disabled';
 export declare const makeAbleActionDef: (initialState?: AbleState) => ActionDef<AbleAction, AbleState>;

package/lib/actions/action.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeAbleActionDef = exports.genericActions = exports.exludeRemoveActions = exports.excludeUpdateActions = exports.appendOnlyActions = exports.readOnlyActions = void 0;
+exports.makeAbleActionDef = exports.relationActions = exports.genericActions = exports.exludeRemoveActions = exports.excludeUpdateActions = exports.appendOnlyActions = exports.readOnlyActions = void 0;
 exports.readOnlyActions = ['count', 'stat', 'download', 'select'];
 exports.appendOnlyActions = exports.readOnlyActions.concat('create');
 exports.excludeUpdateActions = exports.appendOnlyActions.concat('remove');
 exports.exludeRemoveActions = exports.appendOnlyActions.concat('update');
 exports.genericActions = exports.excludeUpdateActions.concat('update');
+exports.relationActions = ['grant', 'revoke'];
 var makeAbleActionDef = function (initialState) { return ({
     stm: {
         enable: ['disabled', 'enabled'],

package/lib/base-app-domain/Modi/Schema.d.ts

@@ -141,7 +141,7 @@ export declare type UpdateOperationData = FormUpdateData<OpSchema> & {
     modiEntitys$modi?: OakOperation<"create", Omit<ModiEntity.CreateOperationData, "modi" | "modiId">[]> | Array<OakOperation<"create", Omit<ModiEntity.CreateOperationData, "modi" | "modiId">>>;
     operEntitys$entity?: OakOperation<"create", Omit<OperEntity.CreateOperationData, "entity" | "entityId">[]> | Array<OakOperation<"create", Omit<OperEntity.CreateOperationData, "entity" | "entityId">>>;
 };
-export declare type UpdateOperation = OakOperation<ParticularAction | "update" | string, UpdateOperationData, Filter, Sorter>;
+export declare type UpdateOperation = OakOperation<"update" | ParticularAction | string, UpdateOperationData, Filter, Sorter>;
 export declare type RemoveOperationData = {};
 export declare type RemoveOperation = OakOperation<"remove", RemoveOperationData, Filter, Sorter>;
 export declare type Operation = CreateOperation | UpdateOperation | RemoveOperation | SelectOperation;

package/lib/base-app-domain/User/Schema.d.ts

@@ -3,7 +3,7 @@ import { Q_DateValue, Q_StringValue, NodeId, MakeFilter, ExprOp, ExpressionKey }
 import { OneOf } from "../../types/Polyfill";
 import * as SubQuery from "../_SubQuery";
 import { FormCreateData, FormUpdateData, Operation as OakOperation, MakeAction as OakMakeAction } from "../../types/Entity";
-import { GenericAction } from "../../actions/action";
+import { GenericAction, RelationAction } from "../../actions/action";
 import * as Oper from "../Oper/Schema";
 import * as OperEntity from "../OperEntity/Schema";
 import * as ModiEntity from "../ModiEntity/Schema";
@@ -118,7 +118,7 @@ export declare type UpdateOperationData = FormUpdateData<OpSchema> & {
     operEntitys$entity?: OakOperation<"create", Omit<OperEntity.CreateOperationData, "entity" | "entityId">[]> | Array<OakOperation<"create", Omit<OperEntity.CreateOperationData, "entity" | "entityId">>>;
     modiEntitys$entity?: OakOperation<"create", Omit<ModiEntity.CreateOperationData, "entity" | "entityId">[]> | Array<OakOperation<"create", Omit<ModiEntity.CreateOperationData, "entity" | "entityId">>>;
 };
-export declare type UpdateOperation = OakOperation<"update" | string, UpdateOperationData, Filter, Sorter>;
+export declare type UpdateOperation = OakOperation<"update" | RelationAction | string, UpdateOperationData, Filter, Sorter>;
 export declare type RemoveOperationData = {};
 export declare type RemoveOperation = OakOperation<"remove", RemoveOperationData, Filter, Sorter>;
 export declare type Operation = CreateOperation | UpdateOperation | RemoveOperation | SelectOperation;
@@ -128,7 +128,7 @@ export declare type FullAttr = NativeAttr | `opers$${number}.${Oper.NativeAttr}`
 export declare type EntityDef = {
     Schema: Schema;
     OpSchema: OpSchema;
-    Action: OakMakeAction<GenericAction> | string;
+    Action: OakMakeAction<GenericAction | RelationAction> | string;
     Selection: Selection;
     Operation: Operation;
     Create: CreateOperation;

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

@@ -21,5 +21,5 @@ exports.desc = {
         }
     },
     actionType: "crud",
-    actions: action_1.genericActions
+    actions: action_1.genericActions.concat(action_1.relationActions)
 };

package/lib/compiler/schemalBuilder.js

@@ -24,6 +24,7 @@ var ActionImportStatements = function () { return [
         factory.createImportSpecifier(false, undefined, factory.createIdentifier("ReadOnlyAction")),
         factory.createImportSpecifier(false, undefined, factory.createIdentifier("ExcludeUpdateAction")),
         factory.createImportSpecifier(false, undefined, factory.createIdentifier("ExcludeRemoveAction")),
+        factory.createImportSpecifier(false, undefined, factory.createIdentifier("RelationAction")),
     ])), factory.createStringLiteral((0, env_1.ACTION_CONSTANT_IN_OAK_DOMAIN)()), undefined)
 ]; };
 var ActionAsts = {};
@@ -201,7 +202,7 @@ function getStringTextFromUnionStringLiterals(moduleName, filename, node, progra
         return [action];
     }
 }
-var RESERVED_ACTION_NAMES = ['GenericAction', 'ParticularAction', 'ExcludeRemoveAction', 'ExcludeUpdateAction', 'ReadOnlyAction', 'AppendOnlyAction'];
+var RESERVED_ACTION_NAMES = ['GenericAction', 'ParticularAction', 'ExcludeRemoveAction', 'ExcludeUpdateAction', 'ReadOnlyAction', 'AppendOnlyAction', 'RelationAction'];
 var action_1 = require("../actions/action");
 var DataType_1 = require("../types/DataType");
 var Entity_1 = require("../types/Entity");
@@ -212,8 +213,11 @@ var OriginActionDict = {
     'appendOnly': 'AppendOnlyAction',
     'readOnly': 'ReadOnlyAction',
 };
-function dealWithActions(moduleName, filename, node, program, sourceFile) {
+function dealWithActions(moduleName, filename, node, program, sourceFile, hasRelationDef) {
     var actionTexts = action_1.genericActions.map(function (ele) { return ele; });
+    if (hasRelationDef) {
+        actionTexts.push.apply(actionTexts, tslib_1.__spreadArray([], tslib_1.__read(action_1.relationActions), false));
+    }
     if (ts.isUnionTypeNode(node)) {
         var actionNames = node.types.map(function (ele) {
             if (ts.isTypeReferenceNode(ele) && ts.isIdentifier(ele.typeName)) {
@@ -494,13 +498,18 @@ function analyzeEntity(filename, path, program) {
                 hasActionDef = true;
                 var modifiers = [factory.createModifier(ts.SyntaxKind.ExportKeyword)];
                 pushStatementIntoActionAst(moduleName, factory.updateTypeAliasDeclaration(node, node.decorators, modifiers, factory.createIdentifier('ParticularAction'), node.typeParameters, node.type), sourceFile);
-                pushStatementIntoActionAst(moduleName, factory.createTypeAliasDeclaration(undefined, [factory.createModifier(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier("Action"), undefined, factory.createUnionTypeNode([
+                var actionDefNodes = [
                     factory.createTypeReferenceNode(OriginActionDict[actionType], undefined),
                     factory.createTypeReferenceNode('ParticularAction', undefined)
-                ])), sourceFile);
-                dealWithActions(moduleName, filename, node.type, program, sourceFile);
+                ];
+                if (hasRelationDef || moduleName === 'User') {
+                    actionDefNodes.push(factory.createTypeReferenceNode('RelationAction', undefined));
+                }
+                pushStatementIntoActionAst(moduleName, factory.createTypeAliasDeclaration(undefined, [factory.createModifier(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier("Action"), undefined, factory.createUnionTypeNode(actionDefNodes)), sourceFile);
+                dealWithActions(moduleName, filename, node.type, program, sourceFile, hasRelationDef || moduleName === 'User');
             }
             else if (node.name.text === 'Relation') {
+                (0, assert_1.default)(!hasActionDef, "\u3010".concat(filename, "\u3011action\u5B9A\u4E49\u987B\u5728Relation\u4E4B\u540E"));
                 (0, assert_1.default)(!localeDef, "\u3010".concat(filename, "\u3011locale\u5B9A\u4E49\u987B\u5728Relation\u4E4B\u540E"));
                 // 增加userXXX对象的描述
                 if (ts.isLiteralTypeNode(node.type)) {
@@ -783,6 +792,7 @@ function analyzeEntity(filename, path, program) {
         toModi: toModi,
         actionType: actionType,
         static: _static,
+        hasRelationDef: hasRelationDef,
     };
     if (hasFulltextIndex) {
         (0, lodash_1.assign)(schema, {
@@ -2244,12 +2254,13 @@ function constructActions(statements, entity) {
     }
     statements.push(factory.createTypeAliasDeclaration(undefined, [factory.createModifier(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier("UpdateOperationData"), undefined, factory.createIntersectionTypeNode(adNodes)));
     // UpdateOperation
-    var actionTypeNodes = ActionAsts[entity] ? [
-        factory.createTypeReferenceNode('ParticularAction'),
-        factory.createLiteralTypeNode(factory.createStringLiteral("update"))
-    ] : [
-        factory.createLiteralTypeNode(factory.createStringLiteral("update"))
-    ];
+    var actionTypeNodes = [factory.createLiteralTypeNode(factory.createStringLiteral("update"))];
+    if (ActionAsts[entity]) {
+        actionTypeNodes.push(factory.createTypeReferenceNode('ParticularAction'));
+    }
+    if (Schema[entity].hasRelationDef || entity === 'User') {
+        actionTypeNodes.push(factory.createTypeReferenceNode('RelationAction'));
+    }
     if (process.env.COMPLING_AS_LIB) {
         actionTypeNodes.push(factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword));
     }
@@ -2603,7 +2614,9 @@ function outputSchema(outputDir, printer) {
                     ])), moduleSpecifier, undefined));
                 }
             }
-            statements.push(factory.createImportDeclaration(undefined, undefined, factory.createImportClause(false, undefined, factory.createNamedImports(localActions.map(function (ele) { return factory.createImportSpecifier(false, undefined, factory.createIdentifier(ele)); }))), factory.createStringLiteral('./Action'), undefined));
+            statements.push(factory.createImportDeclaration(undefined, undefined, factory.createImportClause(false, undefined, factory.createNamedImports(localActions.map(function (ele) { return factory.createImportSpecifier(false, undefined, factory.createIdentifier(ele)); }))), factory.createStringLiteral('./Action'), undefined), factory.createImportDeclaration(undefined, undefined, factory.createImportClause(false, undefined, factory.createNamedImports([
+                factory.createImportSpecifier(false, undefined, factory.createIdentifier("RelationAction")),
+            ])), factory.createStringLiteral((0, env_1.ACTION_CONSTANT_IN_OAK_DOMAIN)()), undefined));
         }
         else {
             statements.push(factory.createImportDeclaration(undefined, undefined, factory.createImportClause(false, undefined, factory.createNamedImports([
@@ -2612,6 +2625,7 @@ function outputSchema(outputDir, printer) {
                 factory.createImportSpecifier(false, undefined, factory.createIdentifier("ReadOnlyAction")),
                 factory.createImportSpecifier(false, undefined, factory.createIdentifier("ExcludeUpdateAction")),
                 factory.createImportSpecifier(false, undefined, factory.createIdentifier("ExcludeRemoveAction")),
+                factory.createImportSpecifier(false, undefined, factory.createIdentifier("RelationAction")),
             ])), factory.createStringLiteral((0, env_1.ACTION_CONSTANT_IN_OAK_DOMAIN)()), undefined));
         }
         constructSchema(statements, entity);
@@ -2621,9 +2635,17 @@ function outputSchema(outputDir, printer) {
         constructActions(statements, entity);
         constructQuery(statements, entity);
         constructFullAttrs(statements, entity);
-        var actionTypeNode = factory.createTypeReferenceNode(factory.createIdentifier('OakMakeAction'), [
-            ActionAsts[entity] ? factory.createTypeReferenceNode('Action') : factory.createTypeReferenceNode(OriginActionDict[Schema[entity].actionType])
-        ]);
+        var makeActionArguments = [];
+        if (ActionAsts[entity]) {
+            makeActionArguments.push(factory.createTypeReferenceNode('Action'));
+        }
+        else {
+            makeActionArguments.push(factory.createTypeReferenceNode(OriginActionDict[Schema[entity].actionType]));
+        }
+        if (Schema[entity].hasRelationDef || entity === 'User') {
+            makeActionArguments.push(factory.createTypeReferenceNode('RelationAction'));
+        }
+        var actionTypeNode = factory.createTypeReferenceNode(factory.createIdentifier('OakMakeAction'), makeActionArguments.length === 1 ? makeActionArguments : [factory.createUnionTypeNode(makeActionArguments)]);
         var EntityDefAttrs = [
             factory.createPropertySignature(undefined, factory.createIdentifier("Schema"), undefined, factory.createTypeReferenceNode(factory.createIdentifier("Schema"), undefined)),
             factory.createPropertySignature(undefined, factory.createIdentifier("OpSchema"), undefined, factory.createTypeReferenceNode(factory.createIdentifier("OpSchema"), undefined)),
@@ -2906,17 +2928,18 @@ function outputStorage(outputDir, printer) {
             factory.createImportDeclaration(undefined, undefined, factory.createImportClause(false, undefined, factory.createNamedImports([factory.createImportSpecifier(false, undefined, factory.createIdentifier("StorageDesc"))])), factory.createStringLiteral("".concat((0, env_1.TYPE_PATH_IN_OAK_DOMAIN)(), "Storage")), undefined),
             factory.createImportDeclaration(undefined, undefined, factory.createImportClause(false, undefined, factory.createNamedImports([factory.createImportSpecifier(false, undefined, factory.createIdentifier("OpSchema"))])), factory.createStringLiteral("./Schema"), undefined)
         ];
+        var needImportActions = [];
         switch (actionType) {
             case 'readOnly': {
-                statements.push(factory.createImportDeclaration(undefined, undefined, factory.createImportClause(false, undefined, factory.createNamedImports([factory.createImportSpecifier(false, factory.createIdentifier("readOnlyActions"), factory.createIdentifier("actions"))])), factory.createStringLiteral((0, env_1.ACTION_CONSTANT_IN_OAK_DOMAIN)()), undefined));
+                needImportActions.push(factory.createImportSpecifier(false, factory.createIdentifier("readOnlyActions"), factory.createIdentifier("actions")));
                 break;
             }
             case 'appendOnly': {
-                statements.push(factory.createImportDeclaration(undefined, undefined, factory.createImportClause(false, undefined, factory.createNamedImports([factory.createImportSpecifier(false, factory.createIdentifier("appendOnlyActions"), factory.createIdentifier("actions"))])), factory.createStringLiteral((0, env_1.ACTION_CONSTANT_IN_OAK_DOMAIN)()), undefined));
+                needImportActions.push(factory.createImportSpecifier(false, factory.createIdentifier("appendOnlyActions"), factory.createIdentifier("actions")));
                 break;
             }
             case 'excludeUpdate': {
-                statements.push(factory.createImportDeclaration(undefined, undefined, factory.createImportClause(false, undefined, factory.createNamedImports([factory.createImportSpecifier(false, factory.createIdentifier("excludeUpdateActions"), factory.createIdentifier("actions"))])), factory.createStringLiteral((0, env_1.ACTION_CONSTANT_IN_OAK_DOMAIN)()), undefined));
+                needImportActions.push(factory.createImportSpecifier(false, factory.createIdentifier("excludeUpdateActions"), factory.createIdentifier("actions")));
                 break;
             }
             default: {
@@ -2924,10 +2947,16 @@ function outputStorage(outputDir, printer) {
                     statements.push(factory.createImportDeclaration(undefined, undefined, factory.createImportClause(false, undefined, factory.createNamedImports([factory.createImportSpecifier(false, undefined, factory.createIdentifier("actions"))])), factory.createStringLiteral("./Action"), undefined));
                 }
                 else {
-                    statements.push(factory.createImportDeclaration(undefined, undefined, factory.createImportClause(false, undefined, factory.createNamedImports([factory.createImportSpecifier(false, factory.createIdentifier("genericActions"), factory.createIdentifier("actions"))])), factory.createStringLiteral((0, env_1.ACTION_CONSTANT_IN_OAK_DOMAIN)()), undefined));
+                    needImportActions.push(factory.createImportSpecifier(false, factory.createIdentifier("genericActions"), factory.createIdentifier("actions")));
                 }
             }
         }
+        if (Schema[entity].hasRelationDef || entity === 'User') {
+            needImportActions.push(factory.createImportSpecifier(false, undefined, factory.createIdentifier("relationActions")));
+        }
+        if (needImportActions.length > 0) {
+            statements.push(factory.createImportDeclaration(undefined, undefined, factory.createImportClause(false, undefined, factory.createNamedImports(needImportActions)), factory.createStringLiteral((0, env_1.ACTION_CONSTANT_IN_OAK_DOMAIN)()), undefined));
+        }
         var propertyAssignments = [];
         var attributes = constructAttributes(entity);
         propertyAssignments.push(factory.createPropertyAssignment(factory.createIdentifier("attributes"), factory.createObjectLiteralExpression(attributes, true)));
@@ -2943,7 +2972,13 @@ function outputStorage(outputDir, printer) {
         if (_static || actionType === 'readOnly') {
             propertyAssignments.push(factory.createPropertyAssignment(factory.createIdentifier("static"), factory.createTrue()));
         }
-        propertyAssignments.push(factory.createPropertyAssignment(factory.createIdentifier("actionType"), factory.createStringLiteral(actionType)), factory.createShorthandPropertyAssignment(factory.createIdentifier("actions"), undefined));
+        propertyAssignments.push(factory.createPropertyAssignment(factory.createIdentifier("actionType"), factory.createStringLiteral(actionType)));
+        if (Schema[entity].hasRelationDef || entity === 'User') {
+            propertyAssignments.push(factory.createPropertyAssignment(factory.createIdentifier("actions"), factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("actions"), factory.createIdentifier("concat")), undefined, [factory.createIdentifier("relationActions")])));
+        }
+        else {
+            propertyAssignments.push(factory.createShorthandPropertyAssignment(factory.createIdentifier("actions"), undefined));
+        }
         if (indexExpressions.length > 0) {
             propertyAssignments.push(factory.createPropertyAssignment(factory.createIdentifier("indexes"), factory.createArrayLiteralExpression(indexExpressions, true)));
         }

package/lib/store/CascadeStore.js

@@ -680,9 +680,9 @@ var CascadeStore = /** @class */ (function (_super) {
                         }
                         _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, e_2, _j;
-                            return tslib_1.__generator(this, function (_k) {
-                                switch (_k.label) {
+                            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];
@@ -702,37 +702,50 @@ var CascadeStore = /** @class */ (function (_super) {
                                         }
                                         else if (action === 'create') {
                                             fkId = data.entityId, entity_1 = data.entity;
-                                            (0, assert_1.default)(typeof fkId === 'string' || entity_1 === attr); // A中data的entityId作为B中filter的主键
-                                            (0, assert_1.default)(filterMto.id && filterMto.id === fkId);
-                                            /* Object.assign(operationMto, {
-                                                filter: addFilterSegment({
-                                                    id: fkId,
-                                                }), filterMto,
-                                            }); */
+                                            (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')); // 这里不能再addFilterSegment，否则会造成后面判断不出来对应的id是多少。在实际情况中跑到这里应该不可能没有id
-                                            (0, assert_1.default)(filterMto.id && typeof filterMto.id === 'string');
-                                            /* Object.assign(operationMto, {
-                                                filter: addFilterSegment({
-                                                    id: {
-                                                        $in: {
-                                                            entity,
-                                                            data: {
-                                                                entityId: 1,
-                                                            },
-                                                            filter: addFilterSegment({
-                                                                entity: attr,
-                                                            } as any, filter),
-                                                        }
-                                                    },
-                                                }, filterMto),
-                                            }); */
+                                            (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 = _k.sent();
+                                        result2 = _l.sent();
                                         this_2.mergeOperationResult(result, result2);
                                         return [3 /*break*/, 16];
                                     case 3:
@@ -747,33 +760,45 @@ var CascadeStore = /** @class */ (function (_super) {
                                         else if (action === 'create') {
                                             _d = data, _e = "".concat(attr, "Id"), fkId = _d[_e];
                                             (0, assert_1.default)(typeof fkId === 'string');
-                                            (0, assert_1.default)((filterMto === null || filterMto === void 0 ? void 0 : filterMto.id) && filterMto.id === fkId); // 这里不能再addFilterSegment，否则会造成后面判断不出来对应的id是多少。在实际情况中跑到这里应该不可能没有id
-                                            /* Object.assign(operationMto, {
-                                                filter: addFilterSegment(filterMto || {}, {
-                                                    id: fkId,
-                                                }),
-                                            }); */
+                                            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")));
-                                            (0, assert_1.default)((filterMto === null || filterMto === void 0 ? void 0 : filterMto.id) && typeof filterMto.id === 'string'); // 这里不能再addFilterSegment，否则会造成后面判断不出来对应的id是多少。在实际情况中跑到这里应该不可能没有id
-                                            /* Object.assign(operationMto, {
-                                                filter: addFilterSegment(filterMto || {}, {
-                                                    id: {
-                                                        $in: {
-                                                            entity,
-                                                            data: {
-                                                                [`${attr}Id`]: 1,
-                                                            },
-                                                            filter,
-                                                        }
-                                                    },
-                                                }),
-                                            }); */
+                                            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 = _k.sent();
+                                        result2 = _l.sent();
                                         this_2.mergeOperationResult(result, result2);
                                         return [3 /*break*/, 16];
                                     case 5:
@@ -894,37 +919,37 @@ var CascadeStore = /** @class */ (function (_super) {
                                             });
                                         }); };
                                         if (!(otmOperations instanceof Array)) return [3 /*break*/, 14];
-                                        _k.label = 6;
+                                        _l.label = 6;
                                     case 6:
-                                        _k.trys.push([6, 11, 12, 13]);
+                                        _l.trys.push([6, 11, 12, 13]);
                                         otmOperations_1 = (e_2 = void 0, tslib_1.__values(otmOperations)), otmOperations_1_1 = otmOperations_1.next();
-                                        _k.label = 7;
+                                        _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:
-                                        _k.sent();
-                                        _k.label = 9;
+                                        _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 = _k.sent();
+                                        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 && (_j = otmOperations_1.return)) _j.call(otmOperations_1);
+                                            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:
-                                        _k.sent();
-                                        _k.label = 16;
+                                        _l.sent();
+                                        _l.label = 16;
                                     case 16: return [2 /*return*/];
                                 }
                             });

package/package.json

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