oak-domain 4.0.0 → 4.0.1

package/lib/store/AsyncRowStore.d.ts

@@ -1,13 +1,17 @@
 /// <reference types="node" />
 import { EntityDict, RowStore, OperateOption, OperationResult, SelectOption, Context, TxnOption, OpRecord, AggregationResult, ClusterInfo } from "../types";
 import { IncomingHttpHeaders } from "http";
+/**
+ * 服务器端执行的异步环境的底层抽象
+ */
 export declare abstract class AsyncContext<ED extends EntityDict> implements Context {
     rowStore: AsyncRowStore<ED, this>;
-    clusterInfo?: ClusterInfo;
     private uuid?;
     opRecords: OpRecord<ED>[];
     private scene?;
-    private headers?;
+    headers?: IncomingHttpHeaders;
+    clusterInfo?: ClusterInfo;
+    opResult: OperationResult<ED>;
     private message?;
     events: {
         commit: Array<() => Promise<void>>;
@@ -17,13 +21,14 @@ export declare abstract class AsyncContext<ED extends EntityDict> implements Con
      * 在返回结果前调用，对数据行进行一些预处理，比如将一些敏感的列隐藏
      */
     abstract refineOpRecords(): Promise<void>;
-    constructor(store: AsyncRowStore<ED, AsyncContext<ED>>, headers?: IncomingHttpHeaders, clusterInfo?: ClusterInfo);
-    setHeaders(headers: IncomingHttpHeaders): void;
+    constructor(store: AsyncRowStore<ED, AsyncContext<ED>>);
+    restartToExecute(routine: (context: this) => Promise<any>): Promise<void>;
     getHeader(key: string): string | string[] | undefined;
     getScene(): string | undefined;
     setScene(scene?: string): void;
     private resetEvents;
     on(event: 'commit' | 'rollback', callback: () => Promise<void>): void;
+    saveOpRecord<T extends keyof ED>(entity: T, operation: ED[T]['Operation']): void;
     /**
      * 一个context中不应该有并发的事务，这里将事务串行化，使用的时候千万要注意不要自己等自己
      * @param options

package/lib/store/AsyncRowStore.js

@@ -2,30 +2,53 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AsyncContext = void 0;
 const tslib_1 = require("tslib");
+const action_1 = require("../actions/action");
 const assert_1 = tslib_1.__importDefault(require("assert"));
+/**
+ * 服务器端执行的异步环境的底层抽象
+ */
 class AsyncContext {
     rowStore;
-    clusterInfo;
     uuid;
     opRecords;
     scene;
     headers;
+    clusterInfo;
+    opResult;
     message;
     events;
-    constructor(store, headers, clusterInfo) {
+    constructor(store) {
         this.rowStore = store;
-        this.clusterInfo = clusterInfo;
         this.opRecords = [];
         this.events = {
             commit: [],
             rollback: [],
         };
-        if (headers) {
-            this.headers = headers;
+        this.opResult = {};
+    }
+    // 使一个上下文重新开始事务执行，清除历史数据（定时器中使用）
+    async restartToExecute(routine) {
+        const newContext = !this.uuid ? this : {
+            ...this,
+        }; // 这里可能有问题，继承的context对象中如果有对象属性会变成指针公用，但是估计目前是跑不到的。by Xc 20231215
+        if (newContext !== this) {
+            console.warn('restartToExecute跑出了非重用当前context的情况，请仔细调试');
+        }
+        newContext.opRecords = [];
+        newContext.events = {
+            commit: [],
+            rollback: [],
+        };
+        newContext.opResult = {};
+        await newContext.begin();
+        try {
+            await routine(newContext);
+            await newContext.commit();
+        }
+        catch (err) {
+            await newContext.rollback();
+            throw err;
         }
-    }
-    setHeaders(headers) {
-        this.headers = headers;
     }
     getHeader(key) {
         if (this.headers) {
@@ -47,6 +70,39 @@ class AsyncContext {
     on(event, callback) {
         this.uuid && this.events[event].push(callback);
     }
+    saveOpRecord(entity, operation) {
+        const { action, data, filter, id } = operation;
+        switch (action) {
+            case 'create': {
+                this.opRecords.push({
+                    id,
+                    a: 'c',
+                    e: entity,
+                    d: data
+                });
+                break;
+            }
+            case 'remove': {
+                this.opRecords.push({
+                    id,
+                    a: 'r',
+                    e: entity,
+                    f: filter,
+                });
+                break;
+            }
+            default: {
+                (0, assert_1.default)(!action_1.readOnlyActions.includes(action));
+                this.opRecords.push({
+                    id,
+                    a: 'u',
+                    e: entity,
+                    d: data,
+                    f: filter,
+                });
+            }
+        }
+    }
     /**
      * 一个context中不应该有并发的事务，这里将事务串行化，使用的时候千万要注意不要自己等自己
      * @param options
@@ -82,8 +138,10 @@ class AsyncContext {
             }
         }
     }
-    operate(entity, operation, option) {
-        return this.rowStore.operate(entity, operation, this, option);
+    async operate(entity, operation, option) {
+        const result = await this.rowStore.operate(entity, operation, this, option);
+        this.opResult = this.mergeMultipleResults([this.opResult, result]);
+        return result;
     }
     select(entity, selection, option) {
         return this.rowStore.select(entity, selection, this, option);

package/lib/store/CascadeStore.d.ts

@@ -15,15 +15,15 @@ export declare abstract class CascadeStore<ED extends EntityDict & BaseEntityDic
     private reinforceSelectionSync;
     private reinforceSelectionInner;
     private reinforceOperation;
-    registerOperationRewriter(rewriter: OperationRewriter<ED, AsyncContext<ED> | SyncContext<ED>>): void;
-    registerSelectionRewriter(rewriter: SelectionRewriter<ED, AsyncContext<ED> | SyncContext<ED>>): void;
+    registerOperationRewriter(rewriter: OperationRewriter<ED, AsyncContext<ED> | SyncContext<ED>, OperateOption>): void;
+    registerSelectionRewriter(rewriter: SelectionRewriter<ED, AsyncContext<ED> | SyncContext<ED>, SelectOption>): void;
     protected abstract selectAbjointRow<T extends keyof ED, OP extends SelectOption, Cxt extends SyncContext<ED>>(entity: T, selection: ED[T]['Selection'], context: Cxt, option: OP): Partial<ED[T]['Schema']>[];
     protected abstract updateAbjointRow<T extends keyof ED, OP extends OperateOption, Cxt extends SyncContext<ED>>(entity: T, operation: ED[T]['Operation'], context: Cxt, option: OP): number;
     protected abstract selectAbjointRowAsync<T extends keyof ED, OP extends SelectOption, Cxt extends AsyncContext<ED>>(entity: T, selection: ED[T]['Selection'], context: Cxt, option: OP): Promise<Partial<ED[T]['Schema']>[]>;
     protected abstract countAsync<T extends keyof ED, OP extends SelectOption, Cxt extends AsyncContext<ED>>(entity: T, selection: Pick<ED[T]['Selection'], 'filter' | 'count'>, context: Cxt, option: OP): Promise<number>;
     protected abstract updateAbjointRowAsync<T extends keyof ED, OP extends OperateOption, Cxt extends AsyncContext<ED>>(entity: T, operation: ED[T]['Create'] | ED[T]['Update'] | ED[T]['Remove'], context: Cxt, option: OP): Promise<number>;
-    protected abstract aggregateSync<T extends keyof ED, OP extends SelectOption, Cxt extends SyncContext<ED>>(entity: T, aggregation: ED[T]['Aggregation'], context: Cxt, option: OP): AggregationResult<ED[T]['Schema']>;
-    protected abstract aggregateAsync<T extends keyof ED, OP extends SelectOption, Cxt extends AsyncContext<ED>>(entity: T, aggregation: ED[T]['Aggregation'], context: Cxt, option: OP): Promise<AggregationResult<ED[T]['Schema']>>;
+    protected abstract aggregateAbjointRowSync<T extends keyof ED, OP extends SelectOption, Cxt extends SyncContext<ED>>(entity: T, aggregation: ED[T]['Aggregation'], context: Cxt, option: OP): AggregationResult<ED[T]['Schema']>;
+    protected abstract aggregateAbjointRowAsync<T extends keyof ED, OP extends SelectOption, Cxt extends AsyncContext<ED>>(entity: T, aggregation: ED[T]['Aggregation'], context: Cxt, option: OP): Promise<AggregationResult<ED[T]['Schema']>>;
     protected destructCascadeSelect<T extends keyof ED, OP extends SelectOption, Cxt extends SyncContext<ED> | AsyncContext<ED>>(entity: T, projection2: ED[T]['Selection']['data'], context: Cxt, cascadeSelectFn: <T2 extends keyof ED>(entity2: T2, selection: ED[T2]['Selection'], context: Cxt, op: OP) => Partial<ED[T2]['Schema']>[] | Promise<Partial<ED[T2]['Schema']>[]>, aggregateFn: <T2 extends keyof ED>(entity2: T2, aggregation: ED[T2]['Aggregation'], context: Cxt, op: OP) => AggregationResult<ED[T2]['Schema']> | Promise<AggregationResult<ED[T2]['Schema']>>, option: OP): {
         projection: ED[T]["Selection"]["data"];
         cascadeSelectionFns: ((result: Partial<ED[T]['Schema']>[]) => Promise<void> | void)[];
@@ -97,6 +97,8 @@ export declare abstract class CascadeStore<ED extends EntityDict & BaseEntityDic
     private addToResultSelections;
     private addSingleRowToResultSelections;
     protected cascadeSelectAsync<T extends keyof ED, OP extends SelectOption, Cxt extends AsyncContext<ED>>(entity: T, selection: ED[T]['Selection'], context: Cxt, option: OP): Promise<Partial<ED[T]['Schema']>[]>;
+    protected aggregateAsync<T extends keyof ED, OP extends SelectOption, Cxt extends AsyncContext<ED>>(entity: T, aggregation: ED[T]['Aggregation'], context: Cxt, option: OP): Promise<AggregationResult<ED[T]['Schema']>>;
+    protected aggregateSync<T extends keyof ED, OP extends SelectOption, Cxt extends SyncContext<ED>>(entity: T, aggregation: ED[T]['Aggregation'], context: Cxt, option: OP): AggregationResult<ED[T]['Schema']>;
     protected selectAsync<T extends keyof ED, OP extends SelectOption, Cxt extends AsyncContext<ED>>(entity: T, selection: ED[T]['Selection'], context: Cxt, option: OP): Promise<Partial<ED[T]['Schema']>[]>;
     protected selectSync<T extends keyof ED, OP extends SelectOption, Cxt extends SyncContext<ED>>(entity: T, selection: ED[T]['Selection'], context: Cxt, option: OP): Partial<ED[T]['Schema']>[];
     protected operateSync<T extends keyof ED, Cxt extends SyncContext<ED>, OP extends OperateOption>(entity: T, operation: ED[T]['Operation'], context: Cxt, option: OP): OperationResult<ED>;

package/lib/store/CascadeStore.js

@@ -20,17 +20,21 @@ class CascadeStore extends RowStore_1.RowStore {
     }
     selectionRewriters = [];
     operationRewriters = [];
-    async reinforceSelectionAsync(entity, selection, context, option) {
-        this.reinforceSelectionInner(entity, selection, context);
-        const rewriterPromises = this.selectionRewriters.map(ele => ele(this.getSchema(), entity, selection, context));
+    async reinforceSelectionAsync(entity, selection, context, option, isAggr) {
+        if (!isAggr && !selection.distinct) {
+            this.reinforceSelectionInner(entity, selection, context);
+        }
+        const rewriterPromises = this.selectionRewriters.map(ele => ele(this.getSchema(), entity, selection, context, option, isAggr));
         if (rewriterPromises.length > 0) {
             await Promise.all(rewriterPromises);
         }
     }
-    reinforceSelectionSync(entity, selection, context, option) {
-        this.reinforceSelectionInner(entity, selection, context);
+    reinforceSelectionSync(entity, selection, context, option, isAggr) {
+        if (!isAggr && !selection.distinct) {
+            this.reinforceSelectionInner(entity, selection, context);
+        }
         this.selectionRewriters.forEach(ele => {
-            const result = ele(this.getSchema(), entity, selection, context);
+            const result = ele(this.getSchema(), entity, selection, context, option);
             (0, assert_1.default)(!(result instanceof Promise));
         });
     }
@@ -312,8 +316,8 @@ class CascadeStore extends RowStore_1.RowStore {
             });
         }
     }
-    async reinforceOperation(entity, operation, context) {
-        await Promise.all(this.operationRewriters.map(ele => ele(this.getSchema(), entity, operation, context)));
+    async reinforceOperation(entity, operation, context, option) {
+        await Promise.all(this.operationRewriters.map(ele => ele(this.getSchema(), entity, operation, context, option)));
     }
     registerOperationRewriter(rewriter) {
         this.operationRewriters.push(rewriter);
@@ -682,12 +686,14 @@ class CascadeStore extends RowStore_1.RowStore {
             (0, assert_1.default)(!option2.modiParentId && !option2.modiParentEntity);
             if (action === 'create') {
                 option2.modiParentId = data.id;
+                option2.modiParentEntity = entity;
             }
-            else {
-                (0, assert_1.default)(filter?.id && typeof filter.id === 'string');
+            else if (filter?.id && typeof filter.id === 'string') {
+                // 如果是对toModi对象进行cascadeUpdate操作，必然带有id，如果没有则认为不是modi相关的操作
+                // 批量通过或者拒绝applyment应该就会出现
                 option2.modiParentId = filter.id;
+                option2.modiParentEntity = entity;
             }
-            option2.modiParentEntity = entity;
         }
         for (const attr in data) {
             const relation = (0, relation_1.judgeRelation)(this.storageSchema, entity, attr);
@@ -1037,14 +1043,18 @@ class CascadeStore extends RowStore_1.RowStore {
                     const closeRootMode = context.openRootMode();
                     await this.cascadeUpdateAsync('modi', modiCreate, context, option);
                     closeRootMode();
-                    return 1;
+                    return {
+                        'modi': {
+                            create: 1,
+                        }
+                    };
                 }
                 else {
                     this.preProcessDataCreated(entity, data);
                     let result = 0;
                     const createInner = async (operation2) => {
                         try {
-                            result += await this.updateAbjointRowAsync(entity, operation2, context, option);
+                            await this.updateAbjointRowAsync(entity, operation2, context, option);
                         }
                         catch (e) {
                             /* 这段代码是处理插入时有重复的行，现在看有问题，等实际需求出现再写
@@ -1114,6 +1124,7 @@ class CascadeStore extends RowStore_1.RowStore {
                         }
                     };
                     if (data instanceof Array) {
+                        result = data.length;
                         const multipleCreate = this.supportMultipleCreate();
                         if (multipleCreate) {
                             await createInner(operation);
@@ -1130,14 +1141,16 @@ class CascadeStore extends RowStore_1.RowStore {
                         }
                     }
                     else {
+                        result = 1;
                         await createInner(operation);
                     }
                     if (!option.dontCollect) {
-                        context.opRecords.push({
+                        context.saveOpRecord(entity, operation);
+                        /* context.opRecords.push({
                             a: 'c',
                             e: entity,
-                            d: data,
-                        });
+                            d: data as ED[T]['OpSchema'] | ED[T]['OpSchema'][],
+                        }); */
                     }
                     if (!option.dontCreateOper && !['oper', 'operEntity', 'modiEntity', 'modi'].includes(entity)) {
                         // 按照框架要求生成Oper和OperEntity这两个内置的对象
@@ -1180,7 +1193,11 @@ class CascadeStore extends RowStore_1.RowStore {
                             closeRootMode();
                         }
                     }
-                    return result;
+                    return {
+                        [entity]: {
+                            ['create']: result,
+                        }
+                    };
                 }
             }
             default: {
@@ -1283,7 +1300,11 @@ class CascadeStore extends RowStore_1.RowStore {
                     const closeRootMode = context.openRootMode();
                     await this.cascadeUpdateAsync('modi', modiUpsert, context, option);
                     closeRootMode();
-                    return 1;
+                    return {
+                        modi: {
+                            ['create']: 1,
+                        },
+                    };
                 }
                 else {
                     const createOper = async () => {
@@ -1319,7 +1340,17 @@ class CascadeStore extends RowStore_1.RowStore {
                     };
                     if (action === 'remove') {
                         if (!option.dontCollect) {
-                            context.opRecords.push({
+                            context.saveOpRecord(entity, {
+                                id: operId,
+                                action,
+                                data: {},
+                                filter: {
+                                    id: {
+                                        $in: ids,
+                                    }
+                                }
+                            });
+                            /* context.opRecords.push({
                                 a: 'r',
                                 e: entity,
                                 f: {
@@ -1327,7 +1358,7 @@ class CascadeStore extends RowStore_1.RowStore {
                                         $in: ids,
                                     }
                                 },
-                            });
+                            }); */
                         }
                     }
                     else {
@@ -1338,30 +1369,44 @@ class CascadeStore extends RowStore_1.RowStore {
                                 $$updateAt$$: now,
                             });
                             if (!option.dontCollect) {
-                                context.opRecords.push({
+                                context.saveOpRecord(entity, {
+                                    id: operId,
+                                    action,
+                                    data: data,
+                                    filter: {
+                                        id: {
+                                            $in: ids,
+                                        }
+                                    },
+                                });
+                                /* context.opRecords.push({
                                     a: 'u',
                                     e: entity,
-                                    d: data,
+                                    d: data as ED[T]['Update']['data'],
                                     f: {
                                         id: {
                                             $in: ids,
                                         }
                                     },
-                                });
+                                }); */
                             }
                         }
                         else if (action !== 'update') {
                             // 如果不是update动作而是用户自定义的动作，这里还是要记录oper
                             await createOper();
-                            return 0;
+                            return {};
                         }
                         else {
-                            return 0;
+                            return {};
                         }
                     }
-                    const result = await this.updateAbjointRowAsync(entity, operation, context, option);
+                    await this.updateAbjointRowAsync(entity, operation, context, option);
                     await createOper();
-                    return result;
+                    return {
+                        [entity]: {
+                            [action]: ids.length,
+                        }
+                    };
                 }
             }
         }
@@ -1467,7 +1512,6 @@ class CascadeStore extends RowStore_1.RowStore {
         let opData;
         const wholeBeforeFns = [];
         const wholeAfterFns = [];
-        const result = {};
         if (['create', 'create-l'].includes(action) && data instanceof Array) {
             opData = [];
             for (const d of data) {
@@ -1486,29 +1530,29 @@ class CascadeStore extends RowStore_1.RowStore {
         const operation2 = Object.assign({}, operation, {
             data: opData,
         });
+        let result = {};
         for (const before of wholeBeforeFns) {
-            await before();
+            const result2 = await before();
+            result = this.mergeMultipleResults([result, result2]);
         }
-        const count = await this.doUpdateSingleRowAsync(entity, operation2, context, option);
-        this.mergeOperationResult(result, {
-            [entity]: {
-                [operation2.action]: count,
-            }
-        });
+        const resultMe = await this.doUpdateSingleRowAsync(entity, operation2, context, option);
+        result = this.mergeMultipleResults([result, resultMe]);
         for (const after of wholeAfterFns) {
-            await after();
+            const result2 = await after();
+            result = this.mergeMultipleResults([result, result2]);
         }
         return result;
     }
     cascadeSelect(entity, selection, context, option) {
-        const { data, filter, indexFrom, count, sorter } = selection;
+        const { data, filter, indexFrom, count, sorter, distinct } = selection;
         const { projection, cascadeSelectionFns } = this.destructCascadeSelect(entity, data, context, this.cascadeSelect, this.aggregateSync, option);
         const rows = this.selectAbjointRow(entity, {
             data: projection,
             filter,
             indexFrom,
             count,
-            sorter
+            sorter,
+            distinct
         }, context, option);
         if (cascadeSelectionFns.length > 0) {
             const ruException = [];
@@ -1574,8 +1618,7 @@ class CascadeStore extends RowStore_1.RowStore {
             const entityBranch = lastOperation.d[entity];
             if (entityBranch) {
                 rows.forEach((row) => {
-                    if (row) {
-                        (0, assert_1.default)(row.id);
+                    if (row && row.id) { // 如果没有row.id就不加入结果集了
                         const { id } = row;
                         if (!entityBranch[id]) {
                             Object.assign(entityBranch, {
@@ -1611,12 +1654,13 @@ class CascadeStore extends RowStore_1.RowStore {
         });
     }
     async cascadeSelectAsync(entity, selection, context, option) {
-        const { data, filter, indexFrom, count, sorter, total, randomRange } = selection;
+        const { data, filter, indexFrom, count, sorter, total, randomRange, distinct } = selection;
         const { projection, cascadeSelectionFns } = this.destructCascadeSelect(entity, data, context, this.cascadeSelectAsync, this.aggregateAsync, option);
         const rows2 = await this.selectAbjointRowAsync(entity, {
             data: projection,
             filter,
             indexFrom,
+            distinct,
             count: randomRange || count,
             sorter
         }, context, option);
@@ -1668,6 +1712,14 @@ class CascadeStore extends RowStore_1.RowStore {
         }
         return rows;
     }
+    async aggregateAsync(entity, aggregation, context, option) {
+        await this.reinforceSelectionAsync(entity, aggregation, context, option, true);
+        return this.aggregateAbjointRowAsync(entity, aggregation, context, option);
+    }
+    aggregateSync(entity, aggregation, context, option) {
+        this.reinforceSelectionSync(entity, aggregation, context, option, true);
+        return this.aggregateAbjointRowSync(entity, aggregation, context, option);
+    }
     async selectAsync(entity, selection, context, option) {
         await this.reinforceSelectionAsync(entity, selection, context, option);
         return this.cascadeSelectAsync(entity, selection, context, option);
@@ -1681,7 +1733,7 @@ class CascadeStore extends RowStore_1.RowStore {
         return this.cascadeUpdate(entity, operation, context, option);
     }
     async operateAsync(entity, operation, context, option) {
-        await this.reinforceOperation(entity, operation, context);
+        await this.reinforceOperation(entity, operation, context, option);
         return this.cascadeUpdateAsync(entity, operation, context, option);
     }
 }

package/lib/store/TriggerExecutor.d.ts

@@ -2,7 +2,7 @@ import { EntityDict, OperateOption, SelectOption } from "../types/Entity";
 import { EntityDict as BaseEntityDict } from '../base-app-domain';
 import { Logger } from "../types/Logger";
 import { Checker } from '../types/Auth';
-import { Trigger } from "../types/Trigger";
+import { Trigger, VolatileTrigger } from "../types/Trigger";
 import { AsyncContext } from './AsyncRowStore';
 /**
  * update可能会传入多种不同的action，此时都需要检查update trigger
@@ -14,15 +14,18 @@ export declare class TriggerExecutor<ED extends EntityDict & BaseEntityDict, Cxt
     private volatileEntities;
     private logger;
     private contextBuilder;
-    constructor(contextBuilder: (cxtString?: string) => Promise<Cxt>, logger?: Logger);
+    private onVolatileTrigger;
+    constructor(contextBuilder: (cxtString?: string) => Promise<Cxt>, logger?: Logger, onVolatileTrigger?: <T extends keyof ED>(entity: T, trigger: VolatileTrigger<ED, T, Cxt>, ids: string[], cxtStr: string, option: OperateOption) => Promise<void>);
+    setOnVolatileTrigger(onVolatileTrigger: <T extends keyof ED>(entity: T, trigger: VolatileTrigger<ED, T, Cxt>, ids: string[], cxtStr: string, option: OperateOption) => Promise<void>): void;
     registerChecker<T extends keyof ED>(checker: Checker<ED, T, Cxt>): void;
     registerTrigger<T extends keyof ED>(trigger: Trigger<ED, T, Cxt>): void;
     unregisterTrigger<T extends keyof ED>(trigger: Trigger<ED, T, Cxt>): void;
     private preCommitTrigger;
+    private postCommitTrigger;
     preOperation<T extends keyof ED>(entity: T, operation: ED[T]['Operation'] | ED[T]['Selection'] & {
         action: 'select';
     }, context: Cxt, option: OperateOption | SelectOption): Promise<void> | void;
-    private execVolatileTrigger;
+    execVolatileTrigger<T extends keyof ED>(entity: T, name: string, ids: string[], context: Cxt, option: OperateOption): Promise<void>;
     /**
      * 判断一个trigger和当前modi上下文是否符合
      * trigger的默认行为是：如果是commit时机的trigger，不显式声明则只能在modi apply时执行（create时不执行）；非commit时机的trigger，不显式声明则只在modi create时执行