oak-domain 5.1.16 → 5.1.18

package/lib/data/i18n.d.ts

@@ -0,0 +1,3 @@
+import { CreateOperationData as I18n } from "../base-app-domain/I18n/Schema";
+declare const i18ns: I18n[];
+export default i18ns;

package/lib/data/i18n.js

@@ -0,0 +1,32 @@
+"use strict";
+// 本文件为自动编译产生，请勿直接修改
+Object.defineProperty(exports, "__esModule", { value: true });
+const i18ns = [
+    {
+        id: "78c237bf2064a36fe73d943ccbbe22d5",
+        namespace: "oak-domain-l-error",
+        language: "zh-CN",
+        module: "oak-domain",
+        position: "locales/error",
+        data: {
+            "requestTimeout": "请求超时",
+            "noRelationDef": "对象[%{entity}]的操作${%{action}}找不到有效的relation定义",
+            "rowUnexisted": "查询对象[%{entity}]时发现了空指针，请检查数据一致性",
+            "uniqViolation": "您更新的数据违反了唯一性约束",
+            "signatureFailed": "验签失败",
+            "attributesNull": "属性[%{attributes}]不允许为空",
+            "attributesCantUpdate": "属性[%{attributes}]不能更新",
+            "operationUnpermitted": "用户操作权限不足",
+            "dataInvisible": "用户查询权限不足",
+            "unLoggedIn": "用户未登录",
+            "rowLocked": "该行数据当前处于被锁定状态",
+            "congrentRowExists": "相同的行数据已经存在",
+            "deadlock": "发现死锁",
+            "preconditionUnset": "前置条件未满足",
+            "externalException": "外部接口调用异常",
+            "socketConnectException": "连接出现问题，请尝试刷新页面",
+            "importedDataParseError": "import的数据存在异常"
+        }
+    }
+];
+exports.default = i18ns;

package/lib/store/CascadeStore.d.ts

@@ -25,8 +25,8 @@ export declare abstract class CascadeStore<ED extends EntityDict & BaseEntityDic
     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 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"];
+    protected destructCascadeSelect<T extends keyof ED, OP extends SelectOption, Cxt extends SyncContext<ED> | AsyncContext<ED>>(entity: T, projection2: ED[T]['Projection'], 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]["Projection"];
         cascadeSelectionFns: ((result: Partial<ED[T]['Schema']>[]) => Promise<void> | void)[];
     };
     /**
@@ -61,7 +61,7 @@ export declare abstract class CascadeStore<ED extends EntityDict & BaseEntityDic
      * @param filter
      * @returns
      */
-    protected destructCascadeUpdate<T extends keyof ED, Cxt extends SyncContext<ED> | AsyncContext<ED>, OP extends OperateOption, R>(entity: T, action: ED[T]['Action'], data: ED[T]['CreateSingle']['data'] | ED[T]['Update']['data'] | ED[T]['Remove']['data'], context: Cxt, option: OP, cascadeUpdate: <T2 extends keyof ED>(entity: T2, operation: ED[T2]['Operation'], context: Cxt, option: OP) => R, filter?: ED[T]['Update']['filter'], bornAt?: number): {
+    protected destructCascadeUpdate<T extends keyof ED, Cxt extends SyncContext<ED> | AsyncContext<ED>, OP extends OperateOption, R>(entity: T, action: ED[T]['Action'], data: ED[T]['CreateOperationData'] | ED[T]['Update']['data'] | ED[T]['Remove']['data'], context: Cxt, option: OP, cascadeUpdate: <T2 extends keyof ED>(entity: T2, operation: ED[T2]['Operation'], context: Cxt, option: OP) => R, filter?: ED[T]['Filter'], bornAt?: number): {
         data: Record<string, any>;
         beforeFns: (() => R)[];
         afterFns: (() => R)[];

package/lib/store/CascadeStore.js

@@ -996,6 +996,7 @@ class CascadeStore extends RowStore_1.RowStore {
                     }
                 }
                 else {
+                    console.warn('一对多的cascadeUpdate即将全部升级为数组格式，请及时修正。by Xc 20250120');
                     dealWithOneToMany(otmOperations);
                 }
             }
@@ -1151,15 +1152,15 @@ class CascadeStore extends RowStore_1.RowStore {
                     } : {
                         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,
+                            }))),
+                        }]
                 },
             };
         }
@@ -1317,15 +1318,15 @@ class CascadeStore extends RowStore_1.RowStore {
                                     operatorId,
                                     targetEntity: entity,
                                     bornAt,
-                                    operEntity$oper: data instanceof Array ? {
-                                        id: 'dummy',
-                                        action: 'create',
-                                        data: await Promise.all(data.map(async (ele) => ({
-                                            id: await (0, uuid_1.generateNewIdAsync)(),
-                                            entityId: ele.id,
-                                            entity: entity,
-                                        }))),
-                                    } : [{
+                                    operEntity$oper: data instanceof Array ? [{
+                                            id: 'dummy',
+                                            action: 'create',
+                                            data: await Promise.all(data.map(async (ele) => ({
+                                                id: await (0, uuid_1.generateNewIdAsync)(),
+                                                entityId: ele.id,
+                                                entity: entity,
+                                            }))),
+                                        }] : [{
                                             id: 'dummy',
                                             action: 'create',
                                             data: {
@@ -1456,15 +1457,15 @@ class CascadeStore extends RowStore_1.RowStore {
                                 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,
-                                    })))
-                                },
+                                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 },
                                 },

package/lib/store/RelationAuth.d.ts

@@ -89,7 +89,7 @@ export declare class RelationAuth<ED extends EntityDict & BaseEntityDict> {
  */
 export declare function getUserRelationsByActions<ED extends EntityDict & BaseEntityDict, T extends keyof ED, Cxt extends AsyncContext<ED>>(params: {
     entity: T;
-    filter: ED[T]['Selection']['filter'];
+    filter: ED[T]['Filter'];
     actions: ED[T]['Action'][];
     overlap?: boolean;
 }, context: Cxt): Promise<{

package/lib/store/RelationAuth.js

@@ -462,7 +462,7 @@ class RelationAuth {
             if (!hasOneToMany) {
                 leafSelections.push({
                     entity: entity2,
-                    filter,
+                    filter: filter,
                 });
             }
         };
@@ -513,7 +513,7 @@ class RelationAuth {
             return true;
         };
         const destructInner = (entity, operation, 
-        // extraFilter?: ED[T2]['Selection']['filter'],
+        // extraFilter?: ED[T2]['Filter'],
         path, child, hasParent, extraFilter) => {
             const { action, data, filter } = operation;
             const filter2 = action === 'create' ? makeCreateFilter(entity, operation) : filter ? (0, lodash_1.cloneDeep)(filter) : {};
@@ -1118,12 +1118,12 @@ class RelationAuth {
             if (result instanceof Promise) {
                 return result.then((r) => {
                     if (!r) {
-                        throw new types_1.OakUserInvisibleException(entity, operation);
+                        throw new types_1.OakDataInvisibleException(entity, operation);
                     }
                 });
             }
             if (!result) {
-                throw new types_1.OakUserInvisibleException(entity, operation);
+                throw new types_1.OakDataInvisibleException(entity, operation);
             }
         }
         else {
@@ -1131,12 +1131,12 @@ class RelationAuth {
             if (result instanceof Promise) {
                 return result.then((r) => {
                     if (!r) {
-                        throw new types_1.OakUserUnpermittedException(entity, operation);
+                        throw new types_1.OakOperationUnpermittedException(entity, operation);
                     }
                 });
             }
             if (!result) {
-                throw new types_1.OakUserUnpermittedException(entity, operation);
+                throw new types_1.OakOperationUnpermittedException(entity, operation);
             }
         }
     }

package/lib/store/TriggerExecutor.js

@@ -186,11 +186,15 @@ class TriggerExecutor {
                 default: {
                     const { filter } = operation;
                     // 此时要保证更新或者删除的行上没有跨事务约束
-                    const filter2 = (0, filter_1.combineFilters)(entity, context.getSchema(), [{
+                    const filter2 = filter ? (0, filter_1.combineFilters)(entity, context.getSchema(), [{
                             [Entity_1.TriggerUuidAttribute]: {
                                 $exists: true,
                             },
-                        }, filter]);
+                        }, filter]) : {
+                        [Entity_1.TriggerUuidAttribute]: {
+                            $exists: true,
+                        }
+                    };
                     const count = await context.count(entity, {
                         filter: filter2
                     }, {});
@@ -516,9 +520,11 @@ class TriggerExecutor {
             },
         };
         if (instanceCount) {
-            filter.$$seq$$ = {
-                $mod: [instanceCount, instanceId]
-            };
+            Object.assign(filter, {
+                $$seq$$: {
+                    $mod: [instanceCount, instanceId]
+                }
+            });
         }
         const context = this.contextBuilder();
         await context.begin();

package/lib/store/checker.js

@@ -52,7 +52,7 @@ function translateCheckerInAsyncContext(checker, schema) {
                     return 0;
                 }
                 if (['select', 'count', 'stat'].includes(action)) {
-                    operation.filter = (0, filter_1.combineFilters)(entity, context.getSchema(), [operationFilter, filter2]);
+                    operation.filter = operationFilter ? (0, filter_1.combineFilters)(entity, context.getSchema(), [operationFilter, filter2]) : filter2;
                     return 0;
                 }
                 else {

package/lib/store/filter.d.ts

@@ -2,11 +2,11 @@ import { EntityDict as BaseEntityDict, StorageSchema } from '../types';
 import { EntityDict } from "../base-app-domain";
 import { AsyncContext } from './AsyncRowStore';
 import { SyncContext } from './SyncRowStore';
-export declare function translateCreateDataToFilter<ED extends EntityDict & BaseEntityDict, T extends keyof ED>(schema: StorageSchema<ED>, entity: T, data: ED[T]['CreateSingle']['data'], allowUnrecoganized: boolean): ED[T]["Selection"]["filter"];
-export declare function combineFilters<ED extends EntityDict & BaseEntityDict, T extends keyof ED>(entity: T, schema: StorageSchema<ED>, filters: Array<ED[T]['Selection']['filter']>, union?: true): ED[T]["Selection"]["filter"] | undefined;
+export declare function translateCreateDataToFilter<ED extends EntityDict & BaseEntityDict, T extends keyof ED>(schema: StorageSchema<ED>, entity: T, data: ED[T]['CreateOperationData'], allowUnrecoganized: boolean): ED[T]["Filter"];
+export declare function combineFilters<ED extends EntityDict & BaseEntityDict, T extends keyof ED>(entity: T, schema: StorageSchema<ED>, filters: Array<ED[T]['Filter']>, union?: true): ED[T]["Filter"] | undefined;
 type DeducedFilter<ED extends EntityDict & BaseEntityDict, T extends keyof ED> = {
     entity: T;
-    filter: ED[T]['Selection']['filter'];
+    filter: ED[T]['Filter'];
 };
 type DeducedFilterCombination<ED extends EntityDict & BaseEntityDict> = {
     $or?: (DeducedFilterCombination<ED> | DeducedFilter<ED, keyof ED>)[];
@@ -56,7 +56,7 @@ export declare function judgeValueRelation(value1: any, value2: any, contained:
  * totalAndDeducedFilters包含的是判定过程中推论的相容的充分条件（and关系）
  * totalOrDeducedFilters包含的是判定过程中推论的相斥的充分条件（or关系）
  */
-export declare function analyzeFilterRelation<ED extends EntityDict & BaseEntityDict, T extends keyof ED>(entity: T, schema: StorageSchema<ED>, filter: NonNullable<ED[T]['Selection']['filter']>, compared: NonNullable<ED[T]['Selection']['filter']>, contained: boolean): boolean | {
+export declare function analyzeFilterRelation<ED extends EntityDict & BaseEntityDict, T extends keyof ED>(entity: T, schema: StorageSchema<ED>, filter: NonNullable<ED[T]['Filter']>, compared: NonNullable<ED[T]['Filter']>, contained: boolean): boolean | {
     totalAndDeducedFilters: (DeducedFilterCombination<ED> | DeducedFilter<ED, T>)[];
     totalOrDeducedFilters: (DeducedFilterCombination<ED> | DeducedFilter<ED, T>)[];
     uncertainAttributes: string[];
@@ -80,13 +80,13 @@ export declare function analyzeFilterRelation<ED extends EntityDict & BaseEntity
  * @param contained
  * @returns
  */
-export declare function contains<ED extends EntityDict & BaseEntityDict, T extends keyof ED>(entity: T, schema: StorageSchema<ED>, filter: ED[T]['Selection']['filter'], contained: ED[T]['Selection']['filter']): boolean | DeducedFilterCombination<ED>;
+export declare function contains<ED extends EntityDict & BaseEntityDict, T extends keyof ED>(entity: T, schema: StorageSchema<ED>, filter: ED[T]['Filter'], contained: ED[T]['Filter']): boolean | DeducedFilterCombination<ED>;
 /**
  * 从filter中判断是否有确定的id对象，如果有则返回这些id，没有返回空数组
  * @param filter
  * @returns
  */
-export declare function getRelevantIds<ED extends EntityDict & BaseEntityDict, T extends keyof ED>(filter: ED[T]['Selection']['filter']): string[];
+export declare function getRelevantIds<ED extends EntityDict & BaseEntityDict, T extends keyof ED>(filter?: ED[T]['Filter']): string[];
 /**
  * 判断两个过滤条件是否完全一致
  * @param entity
@@ -94,7 +94,7 @@ export declare function getRelevantIds<ED extends EntityDict & BaseEntityDict, T
  * @param filter1
  * @param filter2
  */
-export declare function same<ED extends EntityDict & BaseEntityDict, T extends keyof ED>(entity: T, schema: StorageSchema<ED>, filter1: ED[T]['Selection']['filter'], filter2: ED[T]['Selection']['filter']): boolean;
+export declare function same<ED extends EntityDict & BaseEntityDict, T extends keyof ED>(entity: T, schema: StorageSchema<ED>, filter1: ED[T]['Filter'], filter2: ED[T]['Filter']): boolean;
 /**
  * 寻找在树形结构中满足条件的数据行的上层数据
  * 例如在area表中，如果“杭州市”满足这一条件，则希望查到更高层的“浙江省”和“中国”，即可构造出满足条件的filter
@@ -103,7 +103,7 @@ export declare function same<ED extends EntityDict & BaseEntityDict, T extends k
  * @param filter 查询当前行的条件
  * @param level
  */
-export declare function makeTreeAncestorFilter<ED extends EntityDict & BaseEntityDict, T extends keyof ED>(entity: T, parentKey: string, filter: ED[T]['Selection']['filter'], level?: number, includeAll?: boolean, includeSelf?: boolean): ED[T]['Selection']['filter'];
+export declare function makeTreeAncestorFilter<ED extends EntityDict & BaseEntityDict, T extends keyof ED>(entity: T, parentKey: string, filter: ED[T]['Filter'], level?: number, includeAll?: boolean, includeSelf?: boolean): ED[T]['Filter'];
 /**
  * 寻找在树形结构中满足条件的数据行的下层数据
  * 例如在area表中，如果“杭州市”满足这一条件，则希望查到更低层的“西湖区”，即可构造出满足条件的filter
@@ -112,7 +112,7 @@ export declare function makeTreeAncestorFilter<ED extends EntityDict & BaseEntit
  * @param filter 查询当前行的条件
  * @param level
  */
-export declare function makeTreeDescendantFilter<ED extends EntityDict & BaseEntityDict, T extends keyof ED>(entity: T, parentKey: string, filter: ED[T]['Selection']['filter'], level?: number, includeAll?: boolean, includeSelf?: boolean): ED[T]['Selection']['filter'];
+export declare function makeTreeDescendantFilter<ED extends EntityDict & BaseEntityDict, T extends keyof ED>(entity: T, parentKey: string, filter: ED[T]['Filter'], level?: number, includeAll?: boolean, includeSelf?: boolean): ED[T]['Filter'];
 /**
  * 检查filter是否包含contained（filter查询的数据是contained查询数据的子集）
  * @param entity
@@ -122,8 +122,8 @@ export declare function makeTreeDescendantFilter<ED extends EntityDict & BaseEnt
  * @param dataCompare
  * @returns
  */
-export declare function checkFilterContains<ED extends EntityDict & BaseEntityDict, T extends keyof ED, Cxt extends SyncContext<ED> | AsyncContext<ED>>(entity: T, context: Cxt, contained: ED[T]['Selection']['filter'], filter?: ED[T]['Selection']['filter'], dataCompare?: true, warningOnDataCompare?: true): boolean | Promise<boolean>;
-export declare function checkFilterRepel<ED extends EntityDict & BaseEntityDict, T extends keyof ED, Cxt extends SyncContext<ED> | AsyncContext<ED>>(entity: T, context: Cxt, filter1: ED[T]['Selection']['filter'], filter2: ED[T]['Selection']['filter'], dataCompare?: true, warningOnDataCompare?: true): boolean | Promise<boolean>;
+export declare function checkFilterContains<ED extends EntityDict & BaseEntityDict, T extends keyof ED, Cxt extends SyncContext<ED> | AsyncContext<ED>>(entity: T, context: Cxt, contained: ED[T]['Filter'], filter?: ED[T]['Filter'], dataCompare?: true, warningOnDataCompare?: true): boolean | Promise<boolean>;
+export declare function checkFilterRepel<ED extends EntityDict & BaseEntityDict, T extends keyof ED, Cxt extends SyncContext<ED> | AsyncContext<ED>>(entity: T, context: Cxt, filter1: ED[T]['Filter'], filter2: ED[T]['Filter'], dataCompare?: true, warningOnDataCompare?: true): boolean | Promise<boolean>;
 /**
  * 有的场景下将filter当成非结构化属性存储，又想支持对其查询，此时必须将查询的filter进行转换，处理其中$开头的escape
  * 只要filter是查询数据的标准子集，查询应当能返回true

package/lib/store/filter.js

@@ -51,13 +51,17 @@ function addFilterSegment(entity, schema, ...filters) {
             filter.$and.push(f);
         }
         else {
-            filter.$and = [f];
+            Object.assign(filter, {
+                $and: [f],
+            });
         }
     };
     const addSingleAttr = (attr, value) => {
         (0, assert_1.default)(filter);
         if (!filter[attr]) {
-            filter[attr] = value;
+            Object.assign(filter, {
+                [attr]: value
+            });
         }
         // 优化两个都等值且相等
         else if (filter[attr] === value) {
@@ -68,7 +72,9 @@ function addFilterSegment(entity, schema, ...filters) {
         }, {
             [attr]: filter[attr],
         }) === true) {
-            filter[attr] = value;
+            Object.assign(filter, {
+                [attr]: value,
+            });
         }
         // 当前查询被value所定义的查询包含
         else if (contains(entity, schema, {
@@ -1677,17 +1683,17 @@ function translateFilterToObjectPredicate(filter) {
 }
 exports.translateFilterToObjectPredicate = translateFilterToObjectPredicate;
 /* export function getCascadeEntityFilter<ED extends EntityDict & BaseEntityDict, T extends keyof ED>(
-    filter: NonNullable<ED[T]['Selection']['filter']>,
-    attr: keyof NonNullable<ED[T]['Selection']['filter']>
-): ED[keyof ED]['Selection']['filter'] {
-    const filters: ED[keyof ED]['Selection']['filter'][] = [];
+    filter: NonNullable<ED[T]['Filter']>,
+    attr: keyof NonNullable<ED[T]['Filter']>
+): ED[keyof ED]['Filter'] {
+    const filters: ED[keyof ED]['Filter'][] = [];
     if (filter![attr]) {
         assert(typeof filter![attr] === 'object');
         filters.push(filter![attr]);
     }
     if (filter.$and) {
         filter.$and.forEach(
-            (ele: NonNullable<ED[T]['Selection']['filter']>) => {
+            (ele: NonNullable<ED[T]['Filter']>) => {
                 const f2 = getCascadeEntityFilter(ele, attr);
                 if (f2) {
                     filters.push(f2)

package/lib/store/modi.d.ts

@@ -7,7 +7,7 @@ export declare function createOperationsFromModies(modies: Modi[]): Array<{
     operation: Operation<string, Object, Object>;
     entity: string;
 }>;
-export declare function applyModis<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>, Op extends OperateOption>(filter: ED['modi']['Selection']['filter'], context: Cxt, option: Op): Promise<import("../types").OperationResult<ED>>;
-export declare function abandonModis<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>, Op extends OperateOption>(filter: ED['modi']['Selection']['filter'], context: Cxt, option: Op): Promise<import("../types").OperationResult<ED>>;
+export declare function applyModis<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>, Op extends OperateOption>(filter: ED['modi']['Filter'], context: Cxt, option: Op): Promise<import("../types").OperationResult<ED>>;
+export declare function abandonModis<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>, Op extends OperateOption>(filter: ED['modi']['Filter'], context: Cxt, option: Op): Promise<import("../types").OperationResult<ED>>;
 export declare function createModiRelatedCheckers<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED> | SyncContext<ED>>(schema: StorageSchema<ED>): RowChecker<ED, keyof ED, Cxt>[];
 export declare function createModiRelatedTriggers<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED> | SyncContext<ED>>(schema: StorageSchema<ED>): Trigger<ED, keyof ED, Cxt>[];

package/lib/store/triggers.js

@@ -91,13 +91,13 @@ async function undoLog(log, context) {
         action: 'undo',
         data: {
             iState: 'rollbacked',
-            oper$log: {
-                id: 'dummy',
-                action: 'undo',
-                data: {
-                    iState: 'rollbacked',
-                },
-            },
+            oper$log: [{
+                    id: 'dummy',
+                    action: 'undo',
+                    data: {
+                        iState: 'rollbacked',
+                    },
+                }],
         },
         filter: {
             id: log.id,
@@ -160,13 +160,13 @@ async function redoLog(log, context) {
         action: 'redo',
         data: {
             iState: 'normal',
-            oper$log: {
-                id: 'dummy',
-                action: 'redo',
-                data: {
-                    iState: 'normal',
-                },
-            },
+            oper$log: [{
+                    id: 'dummy',
+                    action: 'redo',
+                    data: {
+                        iState: 'normal',
+                    },
+                }],
         },
         filter: {
             id: log.id,

package/lib/timers/vaccum.d.ts

@@ -3,7 +3,7 @@ import { EntityDict as BaseEntityDict } from '../base-app-domain';
 import { AsyncContext } from '../store/AsyncRowStore';
 type VaccumOptionEntity<ED extends EntityDict & BaseEntityDict, T extends keyof ED> = {
     entity: T;
-    filter?: ED[T]['Selection']['filter'];
+    filter?: ED[T]['Filter'];
     aliveLine: number;
 };
 type VaccumOption<ED extends EntityDict & BaseEntityDict> = {

package/lib/types/Auth.d.ts

@@ -23,14 +23,14 @@ export type RowChecker<ED extends EntityDict & BaseEntityDict, T extends keyof E
     entity: T;
     mt?: ModiTurn;
     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']>);
+    filter: ED[T]['Filter'] | ((operation: ED[T]['Operation'] | ED[T]['Selection'], context: Cxt, option: OperateOption | SelectOption) => SyncOrAsync<ED[T]['Filter'] | undefined>);
     errMsg?: string;
     err?: new (msg?: string) => OakException<ED>;
     inconsistentRows?: {
         entity: keyof ED;
-        selection: (filter?: ED[T]['Selection']['filter']) => ED[keyof ED]['Selection'];
+        selection: (filter?: ED[T]['Filter']) => ED[keyof ED]['Selection'];
     };
-    conditionalFilter?: ED[T]['Update']['filter'] | ((operation: ED[T]['Operation'], context: Cxt, option: OperateOption) => SyncOrAsync<ED[T]['Update']['filter']>);
+    conditionalFilter?: ED[T]['Filter'] | ((operation: ED[T]['Operation'], context: Cxt, option: OperateOption) => SyncOrAsync<ED[T]['Filter']>);
 };
 export type LogicalChecker<ED extends EntityDict & BaseEntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = {
     priority?: number;
@@ -39,7 +39,7 @@ export type LogicalChecker<ED extends EntityDict & BaseEntityDict, T extends key
     entity: T;
     action: ED[T]['Action'] | Array<ED[T]['Action']>;
     checker: (operation: ED[T]['Operation'] | ED[T]['Selection'], context: Cxt, option: OperateOption | SelectOption) => SyncOrAsync<any>;
-    conditionalFilter?: ED[T]['Update']['filter'] | ((operation: ED[T]['Operation'], context: Cxt, option: OperateOption) => SyncOrAsync<ED[T]['Update']['filter']>);
+    conditionalFilter?: ED[T]['Filter'] | ((operation: ED[T]['Operation'], context: Cxt, option: OperateOption) => SyncOrAsync<ED[T]['Filter']>);
 };
 export type Checker<ED extends EntityDict & BaseEntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = DataChecker<ED, T, Cxt> | RowChecker<ED, T, Cxt> | LogicalChecker<ED, T, Cxt>;
 export type AuthDef<ED extends EntityDict & BaseEntityDict, T extends keyof ED> = {

package/lib/types/Cluster.d.ts

@@ -2,4 +2,5 @@ export type ClusterInfo = {
     usingCluster: boolean;
     instanceId?: number;
     instanceCount?: number;
+    enableRedis?: boolean;
 };

package/lib/types/Configuration.d.ts

@@ -3,6 +3,14 @@ import { EntityDict as BaseEntityDict } from "../base-app-domain";
 import { AttrUpdateMatrix } from './EntityDesc';
 import { ActionDefDict } from './Action';
 import { StyleDict } from './Style';
+/**
+ * redis连接信息，如果是Redis集群，可以配置多个
+ */
+export type RedisConfiguration = {
+    host: string;
+    port: number;
+    password?: string;
+};
 /**
  *  后台配置
  */
@@ -17,6 +25,7 @@ export type ServerConfiguration = {
         connectionLimit: number;
         charset: "utf8mb4_general_ci";
     };
+    redis?: RedisConfiguration | RedisConfiguration[];
     workDir: {
         path: string;
     };

package/lib/types/Entity.d.ts

@@ -85,12 +85,16 @@ export interface EntityDef {
     Selection: Selection<'select', Projection, Filter, Sorter>;
     Aggregation: DeduceAggregation<Projection, Filter, Sorter>;
     Operation: CUDOperation;
+    CreateOperationData: CreateOperationData;
     Create: CreateOperation;
     CreateSingle: CreateSingleOperation;
     CreateMulti: CreateMultipleOperation;
     Update: UpdateOperation;
     Remove: RemoveOperation;
     Relation?: string;
+    Filter: Filter;
+    Projection: Projection;
+    Sorter: Sorter;
 }
 export interface EntityDict {
     [E: string]: EntityDef;
@@ -207,6 +211,6 @@ export type OtmKey<K extends string> = K | `${K}$${number}`;
 export interface SubDataDef<ED extends EntityDict, T extends keyof ED> {
     id: string;
     entity: T;
-    filter: ED[T]['Selection']['filter'];
+    filter: ED[T]['Filter'];
 }
 export {};

package/lib/types/EntityDesc.d.ts

@@ -18,7 +18,7 @@ export type AttrUpdateMatrix<ED extends EntityDict> = {
     [T in keyof ED]?: {
         [A in keyof ED[T]['Update']['data']]?: {
             actions?: ED[T]['Action'][];
-            filter?: (NonNullable<ED[T]['Selection']['filter']>) | ((action: ED[T]['Action']) => NonNullable<ED[T]['Selection']['filter']>);
+            filter?: (NonNullable<ED[T]['Filter']>) | ((action: ED[T]['Action']) => NonNullable<ED[T]['Filter']>);
         };
     };
 };