oak-domain 5.1.14 → 5.1.16

package/lib/store/CascadeStore.js

@@ -1132,36 +1132,37 @@ class CascadeStore extends RowStore_1.RowStore {
         }
         // 说明没有已有的modi，必须要创建新的，此时应当在option中有相应的parentEntity/Id
         const { modiParentEntity, modiParentId } = option;
-        (0, assert_1.default)(modiParentEntity && modiParentId);
-        return {
-            id: 'dummy',
-            action: 'create',
-            data: {
-                id: operId,
-                targetEntity: entity,
-                entity: modiParentEntity,
-                entityId: modiParentId,
-                action,
-                data,
-                iState: 'active',
-                filter: ids.length > 0 ? {
-                    id: {
-                        $in: ids,
+        if (modiParentEntity && modiParentId) {
+            return {
+                id: 'dummy',
+                action: 'create',
+                data: {
+                    id: operId,
+                    targetEntity: entity,
+                    entity: modiParentEntity,
+                    entityId: modiParentId,
+                    action,
+                    data,
+                    iState: 'active',
+                    filter: ids.length > 0 ? {
+                        id: {
+                            $in: ids,
+                        },
+                    } : {
+                        id: ids[0],
                     },
-                } : {
-                    id: ids[0],
+                    modiEntity$modi: {
+                        id: 'dummy',
+                        action: 'create',
+                        data: await Promise.all(ids.map(async (id) => ({
+                            id: await (0, uuid_1.generateNewIdAsync)(),
+                            entity: entity,
+                            entityId: id,
+                        }))),
+                    }
                 },
-                modiEntity$modi: {
-                    id: 'dummy',
-                    action: 'create',
-                    data: await Promise.all(ids.map(async (id) => ({
-                        id: await (0, uuid_1.generateNewIdAsync)(),
-                        entity: entity,
-                        entityId: id,
-                    }))),
-                }
-            },
-        };
+            };
+        }
     }
     /**
      * 和具体的update过程无关的例程放在这里，包括对later动作的处理、对oper的记录以及对record的收集等
@@ -1396,25 +1397,37 @@ class CascadeStore extends RowStore_1.RowStore {
                 }
                 const createModi = async () => {
                     const modiOperation = await this.tryMergeModi(entity, operation, context, ids, option);
-                    const closeRootMode = context.openRootMode();
-                    await this.cascadeUpdateAsync('modi', modiOperation, context, option);
-                    closeRootMode();
-                    return {
-                        modi: {
-                            ['create']: 1,
-                        },
-                    };
+                    if (modiOperation) {
+                        const closeRootMode = context.openRootMode();
+                        await this.cascadeUpdateAsync('modi', modiOperation, context, option);
+                        closeRootMode();
+                        return {
+                            modi: {
+                                ['create']: 1,
+                            },
+                        };
+                    }
+                    console.warn(`destination includes modies can not be found here: [${entity}], [${JSON.stringify(operation)}]`);
+                    return {};
                 };
-                if (option.modiParentEntity && !['modi', 'modiEntity'].includes(entity)) {
-                    // 延时更新，变成对modi的操作
-                    if (action === 'update' && Object.keys(data).length === 0) {
-                        return {};
+                const saveRecordAndCreateOper = async () => {
+                    if (action === 'remove') {
+                        if (!option.dontCollect) {
+                            context.saveOpRecord(entity, {
+                                id: operId,
+                                action,
+                                data: data,
+                                filter: {
+                                    id: {
+                                        $in: ids,
+                                    }
+                                },
+                            });
+                        }
                     }
-                    return createModi();
-                }
-                else {
-                    const saveRecordAndCreateOper = async () => {
-                        if (action === 'remove') {
+                    else {
+                        const updateAttrCount = Object.keys(data).length;
+                        if (updateAttrCount > 0) {
                             if (!option.dontCollect) {
                                 context.saveOpRecord(entity, {
                                     id: operId,
@@ -1428,68 +1441,61 @@ class CascadeStore extends RowStore_1.RowStore {
                                 });
                             }
                         }
-                        else {
-                            const updateAttrCount = Object.keys(data).length;
-                            if (updateAttrCount > 0) {
-                                if (!option.dontCollect) {
-                                    context.saveOpRecord(entity, {
-                                        id: operId,
-                                        action,
-                                        data: data,
-                                        filter: {
-                                            id: {
-                                                $in: ids,
-                                            }
-                                        },
-                                    });
-                                }
-                            }
-                            else {
-                                return {};
-                            }
-                        }
-                        if (!option.dontCreateOper && !['oper', 'operEntity', 'modiEntity', 'modi', 'log'].includes(entity) && ids.length > 0) {
-                            // 按照框架要求生成Oper和OperEntity这两个内置的对象
-                            (0, assert_1.default)(operId);
-                            const operatorId = context.getCurrentUserId(true);
-                            const createOper = {
-                                id: 'dummy',
-                                action: 'create',
-                                data: {
-                                    id: operId,
-                                    action,
-                                    data,
-                                    targetEntity: entity,
-                                    bornAt,
-                                    operatorId,
-                                    operEntity$oper: {
-                                        id: 'dummy',
-                                        action: 'create',
-                                        data: await Promise.all(ids.map(async (ele) => ({
-                                            id: await (0, uuid_1.generateNewIdAsync)(),
-                                            entityId: ele,
-                                            entity: entity,
-                                        })))
-                                    },
-                                    filter: {
-                                        id: { $in: ids },
-                                    },
-                                    logId: entity === 'log' ? undefined : option.logId,
-                                    undoData,
+                    }
+                    if (!option.dontCreateOper && !['oper', 'operEntity', 'modiEntity', 'modi', 'log'].includes(entity) && ids.length > 0) {
+                        // 按照框架要求生成Oper和OperEntity这两个内置的对象
+                        (0, assert_1.default)(operId);
+                        const operatorId = context.getCurrentUserId(true);
+                        const createOper = {
+                            id: 'dummy',
+                            action: 'create',
+                            data: {
+                                id: operId,
+                                action,
+                                data,
+                                targetEntity: entity,
+                                bornAt,
+                                operatorId,
+                                operEntity$oper: {
+                                    id: 'dummy',
+                                    action: 'create',
+                                    data: await Promise.all(ids.map(async (ele) => ({
+                                        id: await (0, uuid_1.generateNewIdAsync)(),
+                                        entityId: ele,
+                                        entity: entity,
+                                    })))
                                 },
-                            };
-                            const closeRootMode = context.openRootMode();
-                            await this.cascadeUpdateAsync('oper', createOper, context, {
-                                dontCollect: !option.logId, // 如果是在创建log，则把oper收集回去
-                            });
-                            closeRootMode();
-                        }
-                        return {
-                            [entity]: {
-                                [action]: ids.length,
-                            }
+                                filter: {
+                                    id: { $in: ids },
+                                },
+                                logId: entity === 'log' ? undefined : option.logId,
+                                undoData,
+                            },
                         };
+                        const closeRootMode = context.openRootMode();
+                        await this.cascadeUpdateAsync('oper', createOper, context, {
+                            dontCollect: !option.logId, // 如果是在创建log，则把oper收集回去
+                        });
+                        closeRootMode();
+                    }
+                    return {
+                        [entity]: {
+                            [action]: ids.length,
+                        }
                     };
+                };
+                if (action !== 'remove' && Object.keys(data).length === 0) {
+                    if (action !== 'update') {
+                        // 如果不是update，这里还是记一条oper
+                        return saveRecordAndCreateOper();
+                    }
+                    return {};
+                }
+                if (option.modiParentEntity && !['modi', 'modiEntity'].includes(entity)) {
+                    // 延时更新，变成对modi的操作
+                    return createModi();
+                }
+                else {
                     const count = await this.updateAbjointRowAsync(entity, operation, context, option);
                     if (count === ids.length) {
                         return await saveRecordAndCreateOper();

package/lib/store/TriggerExecutor.js

@@ -352,11 +352,11 @@ class TriggerExecutor {
         const trigger = this.triggerNameMap[name];
         (0, assert_1.default)(trigger && trigger.when === 'commit');
         // assert(ids.length > 0);
-        const { fn } = trigger;
+        const { fn, cleanTriggerDataBySelf } = trigger;
         const closeRoot = trigger.asRoot && context.openRootMode();
         try {
             const callback = await fn({ ids }, context, option);
-            if (trigger.strict === 'makeSure' && ids.length) {
+            if (trigger.strict === 'makeSure' && ids.length && !cleanTriggerDataBySelf) {
                 // 这里开root模式，否则还可能有权限问题
                 const closeRoot2 = context.openRootMode();
                 try {
@@ -485,67 +485,10 @@ class TriggerExecutor {
     }
     async checkpoint(timestamp) {
         let result = 0;
-        for (const entity of this.volatileEntities) {
-            const filter = {
-                [Entity_1.TriggerUuidAttribute]: {
-                    $exists: true,
-                },
-                [Entity_1.UpdateAtAttribute]: {
-                    $lt: timestamp,
-                }
-            };
-            const context = this.contextBuilder();
-            await context.begin();
-            try {
-                const rows = await context.select(entity, {
-                    data: {
-                        id: 1,
-                    },
-                    filter,
-                }, {
-                    includedDeleted: true,
-                    dontCollect: true,
-                });
-                if (rows.length > 0) {
-                    // 要用id来再锁一次，不然会锁住filter的范围，影响并发性
-                    // by Xc 20240314，在haina-busi和haina-cn数据sync过程中发现这个问题
-                    const rows2 = await context.select(entity, {
-                        data: {
-                            id: 1,
-                            [Entity_1.TriggerDataAttribute]: 1,
-                            [Entity_1.TriggerUuidAttribute]: 1,
-                        },
-                        filter: {
-                            id: {
-                                $in: rows.map(ele => ele.id),
-                            },
-                        },
-                    }, {
-                        includedDeleted: true,
-                        dontCollect: true,
-                        forUpdate: 'skip locked', // 如果加不上锁就下次再处理，或者有可能应用自己在处理
-                    });
-                    const grouped = (0, lodash_1.groupBy)(rows2, Entity_1.TriggerUuidAttribute);
-                    for (const uuid in grouped) {
-                        const rs = grouped[uuid];
-                        const { [Entity_1.TriggerDataAttribute]: triggerData } = rs[0];
-                        const { name, cxtStr, option } = triggerData;
-                        await context.initialize(JSON.parse(cxtStr), true);
-                        await this.execVolatileTrigger(entity, name, rs.map(ele => ele.id), context, option);
-                    }
-                }
-                await context.commit();
-                result += rows.length;
-            }
-            catch (err) {
-                if (!(err instanceof types_1.OakPartialSuccess)) {
-                    await context.rollback();
-                    this.logger.error(`error in checkpoint on entity 「${entity}」`, err);
-                }
-                else {
-                    await context.commit();
-                    this.logger.error(`error in checkpoint on entity 「${entity}」`, err);
-                }
+        for (const name in this.triggerNameMap) {
+            const trigger = this.triggerNameMap[name];
+            if (trigger && trigger.when === 'commit') {
+                result += await this.independentCheckPoint(name, timestamp);
             }
         }
         return result;

package/lib/store/checker.js

@@ -44,7 +44,7 @@ function translateCheckerInAsyncContext(checker, schema) {
             };
         }
         case 'row': {
-            const { filter, errMsg, inconsistentRows } = checker;
+            const { filter, errMsg, err, inconsistentRows } = checker;
             const fn = (async ({ operation }, context, option) => {
                 const { filter: operationFilter, data, action, bornAt } = operation;
                 const filter2 = typeof filter === 'function' ? await filter(operation, context, option) : filter;
@@ -66,7 +66,7 @@ function translateCheckerInAsyncContext(checker, schema) {
                                 dontCollect: true,
                                 blockTrigger: true,
                             });
-                            const e = new Exception_1.OakRowInconsistencyException(errMsg);
+                            const e = new (err || (Exception_1.OakRowInconsistencyException))(errMsg);
                             e.addData(entity2, rows2, context.getSchema());
                             throw e;
                         }
@@ -81,7 +81,7 @@ function translateCheckerInAsyncContext(checker, schema) {
                                 dontCollect: true,
                                 blockTrigger: true,
                             }); */
-                            const e = new Exception_1.OakRowInconsistencyException(errMsg);
+                            const e = new (err || (Exception_1.OakRowInconsistencyException))(errMsg);
                             // e.addData(entity, rows2);
                             throw e;
                         }

package/lib/store/modi.js

@@ -73,42 +73,79 @@ function createModiRelatedCheckers(schema) {
             continue;
         }
         const restActions = (0, lodash_1.difference)(actions, action_1.appendOnlyActions);
-        checkers.push({
-            entity,
-            action: restActions,
-            type: 'row',
-            filter: (operation, context, option) => {
-                /**
-                 * 只有一种情况可以通过，即当前是在更新和active的modi所指向同一个父更新对象。
-                 * 比如：先申请了一个公司（company），再申请修改公司（companyApplyment），这时所有的active modi都指向此条companyApplyment
-                 *      这时：
-                 *          1）再申请一条新的修改公司（create companyApplyment），应被拒绝
-                 *          2）申请修改原来的companyApplyment(update companyApplyment)，可以通过
-                 *          3）在其它路径上对此company对象进行直接的更新，应被拒绝
-                 */
-                if (option.modiParentEntity) {
-                    const { modiParentEntity, modiParentId } = option;
-                    (0, assert_1.default)(modiParentEntity);
-                    (0, assert_1.default)(modiParentId);
+        if (!process.env.OAK_DISABLE_MODI_LOCK) {
+            checkers.push({
+                entity,
+                action: restActions,
+                type: 'row',
+                filter: (operation, context, option) => {
+                    /**
+                     * 只有一种情况可以通过，即当前是在更新和active的modi所指向同一个父更新对象。
+                     * 比如：先申请了一个公司（company），再申请修改公司（companyApplyment），这时所有的active modi都指向此条companyApplyment
+                     *      这时：
+                     *          1）再申请一条新的修改公司（create companyApplyment），应被拒绝
+                     *          2）申请修改原来的companyApplyment(update companyApplyment)，可以通过
+                     *          3）在其它路径上对此company对象进行直接的更新，应被拒绝
+                     */
+                    if (option.modiParentEntity) {
+                        const { modiParentEntity, modiParentId } = option;
+                        (0, assert_1.default)(modiParentEntity);
+                        (0, assert_1.default)(modiParentId);
+                        return {
+                            modiEntity$entity: {
+                                '#sqp': 'not in',
+                                entity,
+                                modi: {
+                                    iState: 'active',
+                                    $or: [
+                                        {
+                                            entity: {
+                                                $ne: modiParentEntity,
+                                            },
+                                        },
+                                        {
+                                            entityId: {
+                                                $ne: modiParentId,
+                                            },
+                                        }
+                                    ],
+                                },
+                            },
+                            /* id: {
+                                $nin: {
+                                    entity: 'modiEntity',
+                                    data: {
+                                        entityId: 1,
+                                    },
+                                    filter: {
+                                        entity,
+                                        modi: {
+                                            iState: 'active',
+                                            $or: [
+                                                {
+                                                    entity: {
+                                                        $ne: modiParentEntity,
+                                                    },
+                                                },
+                                                {
+                                                    entityId: {
+                                                        $ne: modiParentId,
+                                                    },
+                                                }
+                                            ],
+                                        },
+                                    },
+                                },
+                            } */
+                        };
+                    }
                     return {
                         modiEntity$entity: {
                             '#sqp': 'not in',
                             entity,
                             modi: {
                                 iState: 'active',
-                                $or: [
-                                    {
-                                        entity: {
-                                            $ne: modiParentEntity,
-                                        },
-                                    },
-                                    {
-                                        entityId: {
-                                            $ne: modiParentId,
-                                        },
-                                    }
-                                ],
-                            },
+                            }
                         },
                         /* id: {
                             $nin: {
@@ -120,50 +157,15 @@ function createModiRelatedCheckers(schema) {
                                     entity,
                                     modi: {
                                         iState: 'active',
-                                        $or: [
-                                            {
-                                                entity: {
-                                                    $ne: modiParentEntity,
-                                                },
-                                            },
-                                            {
-                                                entityId: {
-                                                    $ne: modiParentId,
-                                                },
-                                            }
-                                        ],
-                                    },
+                                    }
                                 },
                             },
                         } */
                     };
-                }
-                return {
-                    modiEntity$entity: {
-                        '#sqp': 'not in',
-                        entity,
-                        modi: {
-                            iState: 'active',
-                        }
-                    },
-                    /* id: {
-                        $nin: {
-                            entity: 'modiEntity',
-                            data: {
-                                entityId: 1,
-                            },
-                            filter: {
-                                entity,
-                                modi: {
-                                    iState: 'active',
-                                }
-                            },
-                        },
-                    } */
-                };
-            },
-            errMsg: '您请求的更新对象上还有正在申请的更新，请等该更新结束后再试',
-        });
+                },
+                errMsg: '您请求的更新对象上还有正在申请的更新，请等该更新结束后再试',
+            });
+        }
     }
     return checkers;
 }

package/lib/types/Auth.d.ts

@@ -1,4 +1,4 @@
-import { CascadeActionAuth, CascadeRelationAuth, ActionOnRemove, SyncOrAsync } from ".";
+import { CascadeActionAuth, CascadeRelationAuth, ActionOnRemove, SyncOrAsync, OakException } from ".";
 import { AsyncContext } from "../store/AsyncRowStore";
 import { SyncContext } from "../store/SyncRowStore";
 import { EntityDict, OperateOption, SelectOption } from "../types/Entity";
@@ -25,6 +25,7 @@ export type RowChecker<ED extends EntityDict & BaseEntityDict, T extends keyof E
     action: ED[T]['Action'] | Array<ED[T]['Action']>;
     filter: ED[T]['Selection']['filter'] | ((operation: ED[T]['Operation'] | ED[T]['Selection'], context: Cxt, option: OperateOption | SelectOption) => SyncOrAsync<ED[T]['Selection']['filter']>);
     errMsg?: string;
+    err?: new (msg?: string) => OakException<ED>;
     inconsistentRows?: {
         entity: keyof ED;
         selection: (filter?: ED[T]['Selection']['filter']) => ED[keyof ED]['Selection'];

package/lib/types/Trigger.d.ts

@@ -40,6 +40,7 @@ interface TriggerCrossTxn<ED extends EntityDict & BaseEntityDict, Cxt extends As
     when: 'commit';
     strict?: 'takeEasy' | 'makeSure';
     cs?: true;
+    cleanTriggerDataBySelf?: true;
     singleton?: true;
     grouped?: true;
     fn: (event: {

package/lib/utils/SimpleConnector.js

@@ -78,8 +78,7 @@ class SimpleConnector {
     ;
     async parseAspectResult(response) {
         if (response.status > 299) {
-            const err = new types_1.OakServerProxyException(`网络请求返回status是${response.status}`);
-            throw this.makeException(err);
+            throw new types_1.OakServerProxyException(`网络请求返回status是${response.status}`);
         }
         const message = response.headers.get('oak-message');
         const responseType = response.headers.get('Content-Type') ||
@@ -120,14 +119,10 @@ class SimpleConnector {
         }
         catch (err) {
             // fetch返回异常一定是网络异常
-            let exception = err;
             if (err instanceof types_1.OakRequestTimeoutException) {
-                exception = new types_1.OakNetworkException(`接口请求超时`);
+                throw new types_1.OakNetworkException(`接口请求超时`);
             }
-            else {
-                exception = new types_1.OakNetworkException(`接口请求时发生网络异常`);
-            }
-            throw this.makeException(exception);
+            throw new types_1.OakNetworkException(`接口请求时发生网络异常`);
         }
         return this.parseAspectResult(response);
     }
@@ -149,18 +144,13 @@ class SimpleConnector {
             response = await this.fetchWithTimeout(this.serverSubscribePointUrl, {}, this.timeout);
         }
         catch (err) {
-            let exception = err;
             if (err instanceof types_1.OakRequestTimeoutException) {
-                exception = new types_1.OakNetworkException(`接口请求超时`);
-            }
-            else {
-                exception = new types_1.OakNetworkException(`接口请求时发生网络异常`);
+                throw new types_1.OakNetworkException(`接口请求超时`);
             }
-            throw this.makeException(exception);
+            throw new types_1.OakNetworkException(`接口请求时发生网络异常`);
         }
         if (response.status > 299) {
-            const err = new types_1.OakServerProxyException(`网络请求返回status是${response.status}`);
-            throw this.makeException(err);
+            throw new types_1.OakServerProxyException(`网络请求返回status是${response.status}`);
         }
         const message = response.headers.get('oak-message');
         const responseType = response.headers.get('Content-Type') ||

package/lib/utils/row.d.ts

@@ -1,6 +1,14 @@
 import { EntityDict } from '../types/Entity';
 import { EntityDict as BaseEntityDict } from '../base-app-domain';
 import { StorageSchema } from '../types';
+/**
+ * 比较两行是否完全相等
+ * @param schema
+ * @param entity
+ * @param row1
+ * @param row2
+ * @returns 相等返回true，否则返回false
+ */
 export declare function compareRow<ED extends EntityDict & BaseEntityDict, T extends keyof ED>(schema: StorageSchema<ED>, entity: T, row1: Partial<ED[T]['Schema']>, row2: Partial<ED[T]['Schema']>): boolean;
 /**
  * 比较两行数据是否完全相等

package/lib/utils/row.js

@@ -5,6 +5,14 @@ const tslib_1 = require("tslib");
 const lodash_1 = require("./lodash");
 const relation_1 = require("../store/relation");
 const assert_1 = tslib_1.__importDefault(require("assert"));
+/**
+ * 比较两行是否完全相等
+ * @param schema
+ * @param entity
+ * @param row1
+ * @param row2
+ * @returns 相等返回true，否则返回false
+ */
 function compareRow(schema, entity, row1, row2) {
     const attrs1 = Object.keys(row1 || {}).filter(ele => !ele.startsWith('$$'));
     const attrs2 = Object.keys(row2 || {}).filter(ele => !ele.startsWith('$$'));

package/package.json

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