oak-domain 5.0.20 → 5.1.1

package/lib/store/triggers.js

@@ -0,0 +1,351 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logTriggers = exports.actionAuthTriggers = void 0;
+const tslib_1 = require("tslib");
+const types_1 = require("../types");
+const uuid_1 = require("../utils/uuid");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const filter_1 = require("./filter");
+exports.actionAuthTriggers = [
+    {
+        name: '当actionAuth的deActions被置空后，删除此条数据',
+        entity: 'actionAuth',
+        action: 'update',
+        fn: async ({ operation }, context, option) => {
+            const { data, filter } = operation;
+            if (data.deActions && data.deActions.length === 0) {
+                await context.operate('actionAuth', {
+                    id: await (0, uuid_1.generateNewIdAsync)(),
+                    action: 'remove',
+                    data: {},
+                    filter,
+                }, option);
+                return 1;
+            }
+            return 0;
+        },
+        when: 'after',
+    }
+];
+/**
+ * 回滚某条日志的修改
+ * @param log
+ * @param context
+ */
+async function undoLog(log, context) {
+    const { iState, oper$log } = log;
+    for (const oper of oper$log) {
+        const { action, targetEntity, filter, undoData, iState } = oper;
+        (0, assert_1.default)(iState === 'normal', '非正常状态的oper怎能回滚');
+        switch (action) {
+            case 'create': {
+                await context.operate(targetEntity, {
+                    id: 'dummy',
+                    action: 'remove',
+                    data: {},
+                    filter: filter,
+                }, {
+                    blockTrigger: true,
+                    dontCollect: true,
+                    dontCreateOper: true,
+                });
+                break;
+            }
+            case 'remove': {
+                const ids = (0, filter_1.getRelevantIds)(filter);
+                (0, assert_1.default)(ids.length > 0);
+                for (const id of ids) {
+                    await context.operate(targetEntity, {
+                        id: 'dummy',
+                        action: 'create',
+                        data: undoData[id],
+                    }, {
+                        blockTrigger: true,
+                        dontCollect: true,
+                        dontCreateOper: true,
+                    });
+                }
+                break;
+            }
+            default: {
+                // 全按update处理
+                const ids = (0, filter_1.getRelevantIds)(filter);
+                (0, assert_1.default)(ids.length > 0);
+                for (const id of ids) {
+                    await context.operate(targetEntity, {
+                        id: 'dummy',
+                        action: 'update',
+                        data: undoData[id],
+                        filter: {
+                            id,
+                        }
+                    }, {
+                        blockTrigger: true,
+                        dontCollect: true,
+                        dontCreateOper: true,
+                    });
+                }
+                break;
+            }
+        }
+    }
+    await context.operate('oper', {
+        id: 'dummy',
+        action: 'undo',
+        data: {
+            iState: 'rollbacked',
+        },
+        filter: {
+            id: {
+                $in: oper$log.map(ele => ele.id)
+            }
+        }
+    }, {
+        blockTrigger: true,
+        dontCollect: true,
+        dontCreateOper: true,
+    });
+}
+/**
+ * 重做某条日志的修改
+ * @param log
+ * @param context
+ */
+async function redoLog(log, context) {
+    const { oper$log } = log;
+    for (const oper of oper$log) {
+        const { action, targetEntity, filter, data, iState } = oper;
+        (0, assert_1.default)(iState === 'rollbacked', '非正常状态的oper怎能回滚');
+        switch (action) {
+            case 'create': {
+                await context.operate(targetEntity, {
+                    id: 'dummy',
+                    action: 'create',
+                    data: data,
+                }, {
+                    blockTrigger: true,
+                    dontCollect: true,
+                    dontCreateOper: true,
+                });
+                break;
+            }
+            case 'remove': {
+                await context.operate(targetEntity, {
+                    id: 'dummy',
+                    action: 'remove',
+                    data: {},
+                    filter: filter,
+                }, {
+                    blockTrigger: true,
+                    dontCollect: true,
+                    dontCreateOper: true,
+                });
+                break;
+            }
+            default: {
+                await context.operate(targetEntity, {
+                    id: 'dummy',
+                    action,
+                    data,
+                    filter: filter,
+                }, {
+                    blockTrigger: true,
+                    dontCollect: true,
+                    dontCreateOper: true,
+                });
+                break;
+            }
+        }
+    }
+    await context.operate('oper', {
+        id: 'dummy',
+        action: 'redo',
+        data: {
+            iState: 'normal',
+        },
+        filter: {
+            id: {
+                $in: oper$log.map(ele => ele.id)
+            }
+        }
+    }, {
+        blockTrigger: true,
+        dontCollect: true,
+        dontCreateOper: true,
+    });
+}
+exports.logTriggers = [
+    {
+        name: '当log被undo时，同一entity上所有在其之后的log全部回滚',
+        entity: 'log',
+        action: 'undo',
+        when: 'after',
+        fn: async ({ operation }, context) => {
+            const { filter } = operation;
+            (0, assert_1.default)(filter);
+            const ids = (0, filter_1.getRelevantIds)(filter);
+            (0, assert_1.default)(ids.length === 1);
+            const [log] = await context.select('log', {
+                data: {
+                    id: 1,
+                    oper$log: {
+                        $entity: 'oper',
+                        data: {
+                            id: 1,
+                            undoData: 1,
+                            action: 1,
+                            targetEntity: 1,
+                            filter: 1,
+                            [types_1.SeqAttribute]: 1,
+                        },
+                    },
+                    entity: 1,
+                    entityId: 1,
+                },
+                filter: {
+                    id: ids[0],
+                },
+            }, {});
+            const logs = await context.select('log', {
+                data: {
+                    id: 1,
+                    oper$log: {
+                        $entity: 'oper',
+                        data: {
+                            id: 1,
+                            undoData: 1,
+                            action: 1,
+                            targetEntity: 1,
+                            filter: 1,
+                        },
+                    },
+                },
+                filter: {
+                    iState: 'normal',
+                    entity: log.entity,
+                    entityId: log.entityId,
+                    [types_1.SeqAttribute]: {
+                        $gte: log[types_1.SeqAttribute],
+                    },
+                },
+                sorter: [
+                    {
+                        $attr: {
+                            [types_1.SeqAttribute]: 1,
+                        },
+                        $direction: 'desc',
+                    }
+                ]
+            }, { dontCollect: true });
+            (0, assert_1.default)(logs.length > 0);
+            for (const log2 of logs) {
+                await undoLog(log2, context);
+            }
+            return logs.length;
+        }
+    },
+    {
+        name: '当log被redo时，同一entity上所有在其之前的log全部重做',
+        entity: 'log',
+        action: 'redo',
+        when: 'after',
+        fn: async ({ operation }, context) => {
+            const { filter } = operation;
+            (0, assert_1.default)(filter);
+            const ids = (0, filter_1.getRelevantIds)(filter);
+            (0, assert_1.default)(ids.length === 1);
+            const [log] = await context.select('log', {
+                data: {
+                    id: 1,
+                    oper$log: {
+                        $entity: 'oper',
+                        data: {
+                            id: 1,
+                            data: 1,
+                            action: 1,
+                            targetEntity: 1,
+                            filter: 1,
+                            [types_1.SeqAttribute]: 1,
+                        },
+                    },
+                    iState: 1,
+                    entity: 1,
+                    entityId: 1,
+                },
+                filter: {
+                    id: ids[0],
+                },
+            }, {});
+            const logs = await context.select('log', {
+                data: {
+                    id: 1,
+                    oper$log: {
+                        $entity: 'oper',
+                        data: {
+                            id: 1,
+                            data: 1,
+                            action: 1,
+                            targetEntity: 1,
+                            filter: 1,
+                        },
+                    },
+                },
+                filter: {
+                    iState: 'rollbacked',
+                    entity: log.entity,
+                    entityId: log.entityId,
+                    [types_1.SeqAttribute]: {
+                        $lte: log[types_1.SeqAttribute],
+                    },
+                },
+                sorter: [
+                    {
+                        $attr: {
+                            [types_1.SeqAttribute]: 1,
+                        },
+                        $direction: 'asc',
+                    }
+                ]
+            }, { dontCollect: true, forUpdate: true });
+            (0, assert_1.default)(logs.length > 0);
+            for (const log2 of logs) {
+                await redoLog(log2, context);
+            }
+            return logs.length;
+        }
+    },
+    {
+        name: '当插入新的日志时，过去的rollbacked状态的日志可以删除',
+        entity: 'log',
+        action: 'create',
+        when: 'after',
+        fn: async ({ operation }, context, option) => {
+            const { data } = operation;
+            (0, assert_1.default)(!(data instanceof Array));
+            const { entity, entityId } = data;
+            const result = await context.operate('oper', {
+                id: 'dummy',
+                action: 'remove',
+                data: {},
+                filter: {
+                    iState: 'rollbacked',
+                    log: {
+                        entity: entity,
+                        entityId: entityId,
+                    },
+                },
+            }, {});
+            const result2 = await context.operate('log', {
+                id: 'dummy',
+                action: 'remove',
+                data: {},
+                filter: {
+                    entity: entity,
+                    entityId: entityId,
+                    iState: 'rollbacked',
+                },
+            }, {});
+            return (result.oper.remove || 0) + (result2.log.remove || 0);
+        }
+    }
+];

package/lib/types/AppLoader.d.ts

@@ -2,7 +2,8 @@
 import { IncomingHttpHeaders } from "http";
 import { AsyncContext, AsyncRowStore } from "../store/AsyncRowStore";
 import { EntityDict, OpRecord } from "./Entity";
-export declare abstract class AppLoader<ED extends EntityDict, Cxt extends AsyncContext<ED>> {
+import { EntityDict as BaseEntityDict } from '../base-app-domain';
+export declare abstract class AppLoader<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>> {
     protected path: string;
     constructor(path: string);
     abstract execAspect(name: string, header?: IncomingHttpHeaders, contextString?: string, params?: any): Promise<{

package/lib/types/Aspect.d.ts

@@ -1,10 +1,11 @@
 import { EntityDict } from "./Entity";
+import { EntityDict as BaseEntityDict } from '../base-app-domain';
 import { OpRecord } from "./Entity";
 import { AsyncContext } from "../store/AsyncRowStore";
-export interface Aspect<ED extends EntityDict, Cxt extends AsyncContext<ED>> {
+export interface Aspect<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>> {
     (params: any, context: Cxt): Promise<any>;
 }
-export interface AspectWrapper<ED extends EntityDict, Cxt extends AsyncContext<ED>, AD extends Record<string, Aspect<ED, Cxt>>> {
+export interface AspectWrapper<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>, AD extends Record<string, Aspect<ED, Cxt>>> {
     exec: <T extends keyof AD>(name: T, params: Parameters<AD[T]>[0], ignoreContext?: true) => Promise<{
         result: Awaited<ReturnType<AD[T]>>;
         opRecords?: OpRecord<ED>[];

package/lib/types/Auth.d.ts

@@ -2,13 +2,14 @@ import { CascadeActionAuth, CascadeRelationAuth, ActionOnRemove, SyncOrAsync } f
 import { AsyncContext } from "../store/AsyncRowStore";
 import { SyncContext } from "../store/SyncRowStore";
 import { EntityDict, OperateOption, SelectOption } from "../types/Entity";
+import { EntityDict as BaseEntityDict } from '../base-app-domain';
 import { ModiTurn } from './Trigger';
-export type CheckerType = 'row' | 'data' | 'logical' | 'logicalData';
+export type CheckerType = 'row' | 'data' | 'logical' | 'logicalData' | 'relation';
 /**
  * conditionalFilter是指该action发生时，operation所操作的行中有满足conditionalFilter的行
  * 被转化成trigger的filter条件，详细可看trigger中的说明
  */
-export type DataChecker<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = {
+export type DataChecker<ED extends EntityDict & BaseEntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = {
     priority?: number;
     type: 'data';
     entity: T;
@@ -16,7 +17,7 @@ export type DataChecker<ED extends EntityDict, T extends keyof ED, Cxt extends A
     action: Omit<ED[T]['Action'], 'remove'> | Array<Omit<ED[T]['Action'], 'remove'>>;
     checker: (data: Readonly<ED[T]['Create']['data'] | ED[T]['Update']['data']>, context: Cxt) => SyncOrAsync<any>;
 };
-export type RowChecker<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = {
+export type RowChecker<ED extends EntityDict & BaseEntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = {
     priority?: number;
     type: 'row';
     entity: T;
@@ -30,7 +31,7 @@ export type RowChecker<ED extends EntityDict, T extends keyof ED, Cxt extends As
     };
     conditionalFilter?: ED[T]['Update']['filter'] | ((operation: ED[T]['Operation'], context: Cxt, option: OperateOption) => SyncOrAsync<ED[T]['Update']['filter']>);
 };
-export type LogicalChecker<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = {
+export type LogicalChecker<ED extends EntityDict & BaseEntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = {
     priority?: number;
     type: 'logical' | 'logicalData';
     mt?: ModiTurn;
@@ -39,19 +40,19 @@ export type LogicalChecker<ED extends EntityDict, T extends keyof ED, Cxt extend
     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']>);
 };
-export type Checker<ED extends EntityDict, 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, T extends keyof ED> = {
+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> = {
     relationAuth?: CascadeRelationAuth<NonNullable<ED[T]['Relation']>>;
     actionAuth?: CascadeActionAuth<ED[T]['Action']>;
     cascadeRemove?: {
         [E in (keyof ED | keyof ED[T]['Schema'] | '@entity')]?: ActionOnRemove;
     };
 };
-export type CascadeRemoveDefDict<ED extends EntityDict> = {
+export type CascadeRemoveDefDict<ED extends EntityDict & BaseEntityDict> = {
     [T in keyof ED]?: {
         [E in (keyof ED | keyof ED[T]['Schema'] | '@entity')]?: ActionOnRemove;
     };
 };
-export type AuthDefDict<ED extends EntityDict> = {
+export type AuthDefDict<ED extends EntityDict & BaseEntityDict> = {
     [K in keyof ED]?: AuthDef<ED, K>;
 };

package/lib/types/Endpoint.d.ts

@@ -2,10 +2,11 @@
 import { IncomingHttpHeaders, IncomingMessage } from "http";
 import { AsyncContext } from "../store/AsyncRowStore";
 import { EntityDict } from "./Entity";
-export interface EndpointItem<ED extends EntityDict, BackCxt extends AsyncContext<ED>> {
+import { EntityDict as BaseEntityDict } from '../base-app-domain';
+export interface EndpointItem<ED extends EntityDict & BaseEntityDict, BackCxt extends AsyncContext<ED>> {
     name: string;
     params?: string[];
     method: 'get' | 'post' | 'put' | 'delete';
     fn: (context: BackCxt, params: Record<string, string>, headers: IncomingHttpHeaders, req: IncomingMessage, body?: any) => Promise<any>;
 }
-export type Endpoint<ED extends EntityDict, BackCxt extends AsyncContext<ED>> = EndpointItem<ED, BackCxt> | EndpointItem<ED, BackCxt>[];
+export type Endpoint<ED extends EntityDict & BaseEntityDict, BackCxt extends AsyncContext<ED>> = EndpointItem<ED, BackCxt> | EndpointItem<ED, BackCxt>[];

package/lib/types/Entity.d.ts

@@ -39,6 +39,7 @@ export type OperateOption = {
     allowExists?: boolean;
     modiParentId?: string;
     modiParentEntity?: string;
+    logId?: string;
     deletePhysically?: boolean;
     applyingModi?: boolean;
     dummy?: 1;
@@ -161,6 +162,9 @@ export type UpdateOpResult<ED extends EntityDict, T extends keyof ED> = {
 export type RemoveOpResult<ED extends EntityDict, T extends keyof ED> = {
     id: string;
     a: 'r';
+    d: {
+        [DeleteAtAttribute]: number;
+    };
     e: T;
     f?: Filter;
 };

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']>;
+            filter?: (NonNullable<ED[T]['Selection']['filter']>) | ((action: ED[T]['Action']) => NonNullable<ED[T]['Selection']['filter']>);
         };
     };
 };

package/lib/types/Exception.d.ts

@@ -169,6 +169,12 @@ export declare class OakExternalException<ED extends EntityDict & BaseEntityDict
     constructor(source: string, code?: string, message?: string, data?: any);
     toString(): string;
 }
+/**
+ * socket连接异常
+ */
+export declare class OakSocketConnectException<ED extends EntityDict & BaseEntityDict> extends OakUserException<ED> {
+    constructor(message?: string);
+}
 export declare function makeException<ED extends EntityDict & BaseEntityDict>(data: {
     name: string;
     message?: string;

package/lib/types/Exception.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeException = exports.OakExternalException = exports.OakPreConditionUnsetException = exports.OakDeadlock = exports.OakCongruentRowExists = exports.OakRowLockedException = exports.OakUnloggedInException = exports.OakUserInvisibleException = exports.OakUserUnpermittedException = exports.OakAttrCantUpdateException = exports.OakAttrNotNullException = exports.OakInputIllegalException = exports.OakRowInconsistencyException = exports.OakServerProxyException = exports.OakNetworkException = exports.OakImportDataParseException = exports.OakUniqueViolationException = exports.OakUserException = exports.OakRowUnexistedException = exports.OakOperExistedException = exports.OakNoRelationDefException = exports.OakDataException = exports.OakPartialSuccess = exports.OakMakeSureByMySelfException = exports.OakException = void 0;
+exports.makeException = exports.OakSocketConnectException = exports.OakExternalException = exports.OakPreConditionUnsetException = exports.OakDeadlock = exports.OakCongruentRowExists = exports.OakRowLockedException = exports.OakUnloggedInException = exports.OakUserInvisibleException = exports.OakUserUnpermittedException = exports.OakAttrCantUpdateException = exports.OakAttrNotNullException = exports.OakInputIllegalException = exports.OakRowInconsistencyException = exports.OakServerProxyException = exports.OakNetworkException = exports.OakImportDataParseException = exports.OakUniqueViolationException = exports.OakUserException = exports.OakRowUnexistedException = exports.OakOperExistedException = exports.OakNoRelationDefException = exports.OakDataException = exports.OakPartialSuccess = exports.OakMakeSureByMySelfException = exports.OakException = void 0;
 const relation_1 = require("../store/relation");
 const lodash_1 = require("../utils/lodash");
 class OakException extends Error {
@@ -385,6 +385,16 @@ class OakExternalException extends OakUserException {
     }
 }
 exports.OakExternalException = OakExternalException;
+/**
+ * socket连接异常
+ */
+class OakSocketConnectException extends OakUserException {
+    constructor(message) {
+        super(message || '连接出现问题，请尝试刷新页面');
+    }
+}
+exports.OakSocketConnectException = OakSocketConnectException;
+;
 function makeException(data) {
     const { name } = data;
     let e = undefined;
@@ -473,6 +483,10 @@ function makeException(data) {
             e = new OakServerProxyException(data.message);
             break;
         }
+        case 'OakSocketConnectException': {
+            e = new OakSocketConnectException(data.message);
+            break;
+        }
         default:
             return;
     }

package/lib/types/Port.d.ts

@@ -1,6 +1,7 @@
 import { AsyncContext } from "../store/AsyncRowStore";
 import { EntityDict } from "./Entity";
-export type Exportation<ED extends EntityDict, T extends keyof ED, K extends string, Cxt extends AsyncContext<ED>> = {
+import { EntityDict as BaseEntityDict } from '../base-app-domain';
+export type Exportation<ED extends EntityDict & BaseEntityDict, T extends keyof ED, K extends string, Cxt extends AsyncContext<ED>> = {
     name: string;
     id: string;
     entity: T;
@@ -9,7 +10,7 @@ export type Exportation<ED extends EntityDict, T extends keyof ED, K extends str
     makeHeaders?: (dataList: Partial<ED[T]['Schema']>[]) => string[];
     fn: (data: ED[T]['Schema'], context?: Cxt, properties?: Record<string, any>) => Promise<Partial<Record<string, string | number | boolean | null>>> | Partial<Record<string, string | number | boolean | null>>;
 };
-export type Importation<ED extends EntityDict, T extends keyof ED, K extends string, Cxt extends AsyncContext<ED>> = {
+export type Importation<ED extends EntityDict & BaseEntityDict, T extends keyof ED, K extends string, Cxt extends AsyncContext<ED>> = {
     name: string;
     id: string;
     entity: T;

package/lib/types/RowStore.d.ts

@@ -3,12 +3,13 @@ import { StorageSchema } from './Storage';
 import { AsyncContext } from '../store/AsyncRowStore';
 import { SyncContext } from '../store/SyncRowStore';
 import { OperateOption, SelectOption } from '.';
+import { EntityDict as BaseEntityDict } from '../base-app-domain';
 export type TxnOption = {
     isolationLevel: 'repeatable read' | 'serializable';
 };
-export type SelectionRewriter<ED extends EntityDict, Cxt extends AsyncContext<ED> | SyncContext<ED>, Op extends SelectOption> = (schema: StorageSchema<ED>, entity: keyof ED, selection: ED[keyof ED]['Selection'] | ED[keyof ED]['Aggregation'], context: Cxt, option: Op, isAggr?: true) => void | Promise<void>;
-export type OperationRewriter<ED extends EntityDict, Cxt extends AsyncContext<ED> | SyncContext<ED>, Op extends OperateOption> = (schema: StorageSchema<ED>, entity: keyof ED, operate: ED[keyof ED]['Operation'], context: Cxt, option: Op) => void | Promise<void>;
-export declare abstract class RowStore<ED extends EntityDict> {
+export type SelectionRewriter<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED> | SyncContext<ED>, Op extends SelectOption> = (schema: StorageSchema<ED>, entity: keyof ED, selection: ED[keyof ED]['Selection'] | ED[keyof ED]['Aggregation'], context: Cxt, option: Op, isAggr?: true) => void | Promise<void>;
+export type OperationRewriter<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED> | SyncContext<ED>, Op extends OperateOption> = (schema: StorageSchema<ED>, entity: keyof ED, operate: ED[keyof ED]['Operation'], context: Cxt, option: Op) => void | Promise<void>;
+export declare abstract class RowStore<ED extends EntityDict & BaseEntityDict> {
     protected storageSchema: StorageSchema<ED>;
     constructor(storageSchema: StorageSchema<ED>);
     abstract registerOperationRewriter(rewriter: OperationRewriter<ED, AsyncContext<ED> | SyncContext<ED>, SelectOption>): void;

package/lib/types/Storage.d.ts

@@ -46,6 +46,7 @@ export interface StorageDesc<SH extends EntityShape> {
     config?: EntityConfig;
     toModi?: true;
     inModi?: true;
+    toLog?: true;
     static?: true;
     actions: string[];
     actionType: ActionType;

package/lib/types/Timer.d.ts

@@ -1,21 +1,22 @@
 import { RecurrenceRule, RecurrenceSpecDateRange, RecurrenceSpecObjLit } from 'node-schedule';
 import { EntityDict } from './Entity';
+import { EntityDict as BaseEntityDict } from '../base-app-domain';
 import { AsyncContext } from '../store/AsyncRowStore';
 import { Watcher } from './Watcher';
 import { OperationResult } from '.';
-type FreeOperateFn<ED extends EntityDict, Cxt extends AsyncContext<ED>> = (context: Cxt) => Promise<OperationResult<ED>>;
-export type FreeRoutine<ED extends EntityDict, Cxt extends AsyncContext<ED>> = {
+type FreeOperateFn<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>> = (context: Cxt) => Promise<OperationResult<ED>>;
+export type FreeRoutine<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>> = {
     name: string;
     routine: FreeOperateFn<ED, Cxt>;
 };
-export type FreeTimer<ED extends EntityDict, Cxt extends AsyncContext<ED>> = {
+export type FreeTimer<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>> = {
     name: string;
     cron: RecurrenceRule | RecurrenceSpecDateRange | RecurrenceSpecObjLit | Date | string | number;
     timer: FreeOperateFn<ED, Cxt>;
     singleton?: true;
 };
-export type Routine<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED>> = FreeRoutine<ED, Cxt> | Watcher<ED, T, Cxt>;
-export type Timer<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED>> = FreeTimer<ED, Cxt> | Watcher<ED, T, Cxt> & {
+export type Routine<ED extends EntityDict & BaseEntityDict, T extends keyof ED, Cxt extends AsyncContext<ED>> = FreeRoutine<ED, Cxt> | Watcher<ED, T, Cxt>;
+export type Timer<ED extends EntityDict & BaseEntityDict, T extends keyof ED, Cxt extends AsyncContext<ED>> = FreeTimer<ED, Cxt> | Watcher<ED, T, Cxt> & {
     cron: RecurrenceRule | RecurrenceSpecDateRange | RecurrenceSpecObjLit | Date | string | number;
 };
 export {};