oak-domain 5.1.15 → 5.1.17

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/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

@@ -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";
@@ -23,13 +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;
@@ -38,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']>);
         };
     };
 };

package/lib/types/Exception.d.ts

@@ -3,12 +3,15 @@ import { EntityDict, OpRecord } from "./Entity";
 import { EntityDict as BaseEntityDict } from '../base-app-domain';
 export declare class OakException<ED extends EntityDict & BaseEntityDict> extends Error {
     opRecords: OpRecord<ED>[];
-    constructor(message?: string);
+    module?: string;
+    params?: Record<string, any>;
+    constructor(message?: string, module?: string, params?: Record<string, any>);
     addData<T extends keyof ED>(entity: T, rows: Partial<ED[T]['Schema']>[], schema: StorageSchema<ED>): void;
     setOpRecords(opRecords: OpRecord<ED>[]): void;
     getSerialData(): {
         name: string;
         message: string;
+        module: string | undefined;
         opRecords: OpRecord<ED>[];
         tag1: string | undefined;
         tag2: boolean | undefined;
@@ -20,7 +23,7 @@ export declare class OakException<ED extends EntityDict & BaseEntityDict> extend
     tag3?: any;
 }
 export declare class OakRequestTimeoutException<ED extends EntityDict & BaseEntityDict> extends OakException<ED> {
-    constructor(message?: string);
+    constructor(message?: string, ns?: string, params?: Record<string, any>);
 }
 export declare class OakMakeSureByMySelfException<ED extends EntityDict & BaseEntityDict> extends OakException<ED> {
 }
@@ -31,7 +34,7 @@ export declare class OakDataException<ED extends EntityDict & BaseEntityDict> ex
 export declare class OakNoRelationDefException<ED extends EntityDict & BaseEntityDict, T extends keyof ED> extends OakDataException<ED> {
     entity: T;
     actions: ED[T]['Action'][];
-    constructor(entity: T, actions: ED[T]['Action'][], msg?: string);
+    constructor(entity: T, actions: ED[T]['Action'][], msg?: string, module?: string, params?: Record<string, any>);
     toString(): string;
 }
 export declare class OakOperExistedException<ED extends EntityDict & BaseEntityDict> extends OakDataException<ED> {
@@ -41,7 +44,7 @@ export declare class OakRowUnexistedException<ED extends EntityDict & BaseEntity
     constructor(rows: Array<{
         entity: any;
         selection: any;
-    }>);
+    }>, msg?: string, module?: string, params?: Record<string, any>);
     toString(): string;
     getRows(): {
         entity: any;
@@ -61,12 +64,12 @@ export declare class OakUniqueViolationException<ED extends EntityDict & BaseEnt
     constructor(rows: Array<{
         id?: string;
         attrs: string[];
-    }>, message?: string);
+    }>, message?: string, module?: string, params?: Record<string, any>);
 }
 export declare class OakImportDataParseException<ED extends EntityDict & BaseEntityDict> extends OakUserException<ED> {
     line: number;
     header?: string;
-    constructor(message: string, line: number, header?: string);
+    constructor(message: string, line: number, header?: string, module?: string, params?: Record<string, any>);
 }
 /**
  * 网络中断异常
@@ -78,7 +81,7 @@ export declare class OakServerProxyException<ED extends EntityDict & BaseEntityD
 export declare class OakClockDriftException<ED extends EntityDict & BaseEntityDict> extends OakException<ED> {
 }
 export declare class OakSignatureVerificationException<ED extends EntityDict & BaseEntityDict> extends OakException<ED> {
-    constructor(message?: string);
+    constructor(message?: string, module?: string, params?: Record<string, any>);
 }
 /**
  * 数据不一致异常，系统认为现有的数据不允许相应的动作时抛此异常
@@ -93,7 +96,7 @@ export declare class OakRowInconsistencyException<ED extends EntityDict & BaseEn
 export declare class OakInputIllegalException<ED extends EntityDict & BaseEntityDict> extends OakUserException<ED> {
     private attributes;
     private entity;
-    constructor(entity: keyof ED, attributes: string[], message?: string);
+    constructor(entity: keyof ED, attributes: string[], message?: string, module?: string, params?: Record<string, any>);
     getEntity(): keyof ED;
     getAttributes(): string[];
     addAttributesPrefix(prefix: string): void;
@@ -103,43 +106,43 @@ export declare class OakInputIllegalException<ED extends EntityDict & BaseEntity
  * 属性为空时抛的异常
  */
 export declare class OakAttrNotNullException<ED extends EntityDict & BaseEntityDict> extends OakInputIllegalException<ED> {
-    constructor(entity: keyof ED, attributes: string[], message?: string);
+    constructor(entity: keyof ED, attributes: string[], message?: string, module?: string, params?: Record<string, any>);
 }
 /**
  * 属性不允许更新抛的异常，前端可以用这个异常来处理update时对应属性的露出
  */
 export declare class OakAttrCantUpdateException<ED extends EntityDict & BaseEntityDict> extends OakInputIllegalException<ED> {
-    constructor(entity: keyof ED, attributes: string[], message?: string);
+    constructor(entity: keyof ED, attributes: string[], message?: string, module?: string, params?: Record<string, any>);
 }
 /**
  * 用户权限不够时抛的异常
  */
-export declare class OakUserUnpermittedException<ED extends EntityDict & BaseEntityDict, T extends keyof ED> extends OakUserException<ED> {
+export declare class OakOperationUnpermittedException<ED extends EntityDict & BaseEntityDict, T extends keyof ED> extends OakUserException<ED> {
     private entity;
     private operation;
-    constructor(entity: T, operation: ED[T]['Selection'] | ED[T]['Operation'], message?: string);
+    constructor(entity: T, operation: ED[T]['Selection'] | ED[T]['Operation'], message?: string, module?: string, params?: Record<string, any>);
     toString(): string;
 }
 /**
  * 用户查询权限不够抛出异常
  */
-export declare class OakUserInvisibleException<ED extends EntityDict & BaseEntityDict, T extends keyof ED> extends OakUserException<ED> {
+export declare class OakDataInvisibleException<ED extends EntityDict & BaseEntityDict, T extends keyof ED> extends OakUserException<ED> {
     private entity;
     private operation;
-    constructor(entity: T, operation: ED[T]['Selection'] | ED[T]['Operation'], message?: string);
+    constructor(entity: T, operation: ED[T]['Selection'] | ED[T]['Operation'], message?: string, module?: string, params?: Record<string, any>);
     toString(): string;
 }
 /**
  * 用户未登录抛的异常
  */
 export declare class OakUnloggedInException<ED extends EntityDict & BaseEntityDict> extends OakUserException<ED> {
-    constructor(message?: string);
+    constructor(message?: string, module?: string, params?: Record<string, any>);
 }
 /**
  * 行数据被锁抛的异常
  */
 export declare class OakRowLockedException<ED extends EntityDict & BaseEntityDict> extends OakUserException<ED> {
-    constructor(message?: string);
+    constructor(message?: string, module?: string, params?: Record<string, any>);
 }
 /**
  * 要插入行时，发现已经有相同的行数据
@@ -147,7 +150,7 @@ export declare class OakRowLockedException<ED extends EntityDict & BaseEntityDic
 export declare class OakCongruentRowExists<ED extends EntityDict & BaseEntityDict, T extends keyof ED> extends OakUserException<ED> {
     private data;
     private entity;
-    constructor(entity: T, data: ED[T]['OpSchema'], message?: string);
+    constructor(entity: T, data: ED[T]['OpSchema'], message?: string, module?: string, params?: Record<string, any>);
     getData(): ED[T]["OpSchema"];
     getEntity(): T;
     toString(): string;
@@ -156,7 +159,7 @@ export declare class OakCongruentRowExists<ED extends EntityDict & BaseEntityDic
  * 死锁抛的异常
  */
 export declare class OakDeadlock<ED extends EntityDict & BaseEntityDict> extends OakUserException<ED> {
-    constructor(message?: string | undefined);
+    constructor(message?: string, module?: string, params?: Record<string, any>);
 }
 /**
  * 前置条件不满足抛的异常
@@ -164,7 +167,7 @@ export declare class OakDeadlock<ED extends EntityDict & BaseEntityDict> extends
 export declare class OakPreConditionUnsetException<ED extends EntityDict & BaseEntityDict> extends OakUserException<ED> {
     entity?: keyof ED;
     code?: string;
-    constructor(message?: string | undefined, entity?: keyof ED | undefined, code?: string | undefined);
+    constructor(message?: string, entity?: keyof ED, code?: string, module?: string, params?: Record<string, any>);
     toString(): string;
 }
 /**
@@ -174,18 +177,20 @@ export declare class OakExternalException<ED extends EntityDict & BaseEntityDict
     code?: string;
     source: string;
     data?: any;
-    constructor(source: string, code?: string, message?: string, data?: any);
+    constructor(source: string, code?: string, message?: string, data?: any, module?: string, params?: Record<string, any>);
     toString(): string;
 }
 /**
  * socket连接异常
  */
 export declare class OakSocketConnectException<ED extends EntityDict & BaseEntityDict> extends OakUserException<ED> {
-    constructor(message?: string);
+    constructor(message?: string, module?: string, params?: Record<string, any>);
 }
 export declare function makeException<ED extends EntityDict & BaseEntityDict>(data: {
     name: string;
     message?: string;
+    module?: string;
+    params?: Record<string, any>;
     opRecords: OpRecord<ED>[];
     [A: string]: any;
 }): OakException<ED> | undefined;