oak-domain 5.0.19 → 5.1.0

package/lib/store/CascadeStore.js

@@ -13,6 +13,7 @@ const AsyncRowStore_1 = require("./AsyncRowStore");
 const filter_2 = require("./filter");
 const uuid_1 = require("../utils/uuid");
 const entities_1 = require("../compiler/entities");
+const projection_1 = require("../utils/projection");
 /**这个用来处理级联的select和update，对不同能力的 */
 class CascadeStore extends RowStore_1.RowStore {
     constructor(storageSchema) {
@@ -676,12 +677,13 @@ class CascadeStore extends RowStore_1.RowStore {
      * @returns
      */
     destructCascadeUpdate(entity, action, data, context, option, cascadeUpdate, filter, bornAt) {
-        const modiAttr = this.getSchema()[entity].toModi;
+        const toModi = this.getSchema()[entity].toModi;
+        const toLog = this.getSchema()[entity].toLog;
         const option2 = Object.assign({}, option);
         const opData = {};
         const beforeFns = [];
         const afterFns = [];
-        if (modiAttr && action !== 'remove') {
+        if (toModi && action !== 'remove') {
             // create/update具有modi对象的对象，对其子对象的update行为全部是create modi对象（缓存动作）
             // delete此对象，所有的modi子对象应该通过触发器作废，这个目前先通过系统的trigger来实现
             (0, assert_1.default)(!option2.modiParentId && !option2.modiParentEntity);
@@ -696,6 +698,24 @@ class CascadeStore extends RowStore_1.RowStore {
                 option2.modiParentEntity = entity;
             }
         }
+        if (toLog && action !== 'create') {
+            // 此对象（及其下辖的cascade更新都需要记录log)            
+            (0, assert_1.default)(typeof filter.id === 'string');
+            (0, assert_1.default)(!option2.logId, 'undo无法支持嵌套');
+            const logId = (0, uuid_1.generateNewId)();
+            option2.logId = option.logId = logId;
+            Object.assign(data, {
+                log$entity: [
+                    {
+                        id: (0, uuid_1.generateNewId)(),
+                        data: {
+                            id: logId,
+                        },
+                        action: 'create',
+                    }
+                ]
+            });
+        }
         for (const attr in data) {
             const relation = (0, relation_1.judgeRelation)(this.storageSchema, entity, attr, !!bornAt);
             if (relation === 1) {
@@ -1150,7 +1170,7 @@ class CascadeStore extends RowStore_1.RowStore {
                     if (!option.dontCollect) {
                         context.saveOpRecord(entity, operation);
                     }
-                    if (!option.dontCreateOper && !['oper', 'operEntity', 'modiEntity', 'modi'].includes(entity)) {
+                    if (!option.dontCreateOper && !['oper', 'operEntity', 'modiEntity', 'modi', 'log'].includes(entity)) {
                         // 按照框架要求生成Oper和OperEntity这两个内置的对象
                         (0, assert_1.default)(operId);
                         const operatorId = context.getCurrentUserId(true);
@@ -1186,7 +1206,8 @@ class CascadeStore extends RowStore_1.RowStore {
                                         id: data instanceof Array ? {
                                             id: { $in: data.map(ele => ele.id) },
                                         } : data.id,
-                                    }
+                                    },
+                                    logId: entity === 'log' ? undefined : option.logId,
                                 },
                             };
                             const closeRootMode = context.openRootMode();
@@ -1206,10 +1227,19 @@ class CascadeStore extends RowStore_1.RowStore {
             default: {
                 // 这里要优化一下，显式的对id的update/remove不要去查了，节省数据库层的性能（如果这些row是建立在一个create的modi上也查不到）
                 const ids = (0, filter_2.getRelevantIds)(filter);
-                if (ids.length === 0) {
+                const undoProjection = action === 'remove' ? (0, projection_1.makeProjection)(entity, this.getSchema()) : (() => {
+                    const p = {};
+                    Object.keys(data).forEach((attr) => Object.assign(p, {
+                        [attr]: 1,
+                    }));
+                    return p;
+                })();
+                const undoData = {};
+                if (ids.length === 0 || option.logId) {
                     const selection = {
                         data: {
                             id: 1,
+                            ...undoProjection,
                         },
                         filter: operation.filter,
                         indexFrom: operation.indexFrom,
@@ -1219,7 +1249,12 @@ class CascadeStore extends RowStore_1.RowStore {
                         dontCollect: true,
                         forUpdate: true,
                     });
-                    ids.push(...(rows.map(ele => ele.id)));
+                    rows.forEach((row) => {
+                        ids.push(row.id);
+                        Object.assign(undoData, {
+                            [row.id]: action === 'remove' ? row : (0, lodash_1.omit)(row, [types_1.PrimaryKeyAttribute, Entity_1.CreateAtAttribute]),
+                        });
+                    });
                 }
                 if (data) {
                     this.preProcessDataUpdated(data);
@@ -1229,7 +1264,12 @@ class CascadeStore extends RowStore_1.RowStore {
                     // 变成对modi的插入
                     // 优化，这里如果是对同一个targetEntity反复update，则变成对最后一条create/update的modi进行update，以避免发布文章这样的需求时产生过多的modi
                     let modiUpsert;
-                    if (action !== 'remove') {
+                    if (action === 'update') {
+                        // 如果action本身是update，且没有实际update属性，这里可以忽略
+                        const updateAttrCount = Object.keys(data).length;
+                        if (updateAttrCount === 0) {
+                            return {};
+                        }
                         const upsertModis = await this.selectAbjointRowAsync('modi', {
                             data: {
                                 id: 1,
@@ -1312,7 +1352,7 @@ class CascadeStore extends RowStore_1.RowStore {
                 }
                 else {
                     const createOper = async () => {
-                        if (!option.dontCreateOper && !['oper', 'operEntity', 'modiEntity', 'modi'].includes(entity) && ids.length > 0) {
+                        if (!option.dontCreateOper && !['oper', 'operEntity', 'modiEntity', 'modi', 'log'].includes(entity) && ids.length > 0) {
                             // 按照框架要求生成Oper和OperEntity这两个内置的对象
                             (0, assert_1.default)(operId);
                             const operatorId = context.getCurrentUserId(true);
@@ -1337,7 +1377,9 @@ class CascadeStore extends RowStore_1.RowStore {
                                     },
                                     filter: {
                                         id: { $in: ids },
-                                    }
+                                    },
+                                    logId: entity === 'log' ? undefined : option.logId,
+                                    undoData,
                                 },
                             };
                             const closeRootMode = context.openRootMode();

package/lib/store/IntrinsicCheckers.js

@@ -329,9 +329,7 @@ function createAttrUpdateCheckers(schema, attrUpdateMatrix) {
                 }
                 const condition = attrs.map(ele => matrix[ele]);
                 const actions = condition.map(ele => ele.actions).filter(ele => !!ele);
-                const filters = condition.map(ele => ele.filter).filter(ele => !!ele);
                 const a = actions.length > 0 && (0, lodash_1.intersection)(actions.flat());
-                const f = filters.length > 0 && (0, filter_1.combineFilters)(entity, schema, filters);
                 if (a) {
                     if (!a.includes(action)) {
                         // 找到不满足的那个attr
@@ -339,6 +337,13 @@ function createAttrUpdateCheckers(schema, attrUpdateMatrix) {
                         throw new types_1.OakAttrCantUpdateException(entity, attrsIllegal, `${attrsIllegal.join(',')}不允许被${action}动作更新`);
                     }
                 }
+                const filters = condition.map(ele => {
+                    if (typeof ele.filter === 'function') {
+                        return ele.filter(action || 'select');
+                    }
+                    return ele.filter;
+                }).filter(ele => !!ele);
+                const f = filters.length > 0 && (0, filter_1.combineFilters)(entity, schema, filters);
                 if (f) {
                     const result = (0, filter_1.checkFilterContains)(entity, context, f, filter, true);
                     if (result instanceof Promise) {

package/lib/store/IntrinsicLogics.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeIntrinsicLogics = void 0;
-const actionAuth_1 = require("./actionAuth");
+const triggers_1 = require("./triggers");
 const modi_1 = require("./modi");
 const IntrinsicCheckers_1 = require("./IntrinsicCheckers");
 function createExpiredWatchers(schema) {
@@ -34,7 +34,7 @@ function createExpiredWatchers(schema) {
 function makeIntrinsicLogics(schema, actionDefDict, attrUpdateMatrix) {
     const checkers = (0, IntrinsicCheckers_1.makeIntrinsicCheckers)(schema, actionDefDict, attrUpdateMatrix);
     const triggers = (0, modi_1.createModiRelatedTriggers)(schema);
-    triggers.push(...actionAuth_1.triggers);
+    triggers.push(...triggers_1.actionAuthTriggers, ...triggers_1.logTriggers);
     const watchers = createExpiredWatchers(schema);
     return {
         triggers,

package/lib/store/SyncRowStore.d.ts

@@ -1,5 +1,6 @@
 import { EntityDict, RowStore, OperateOption, OperationResult, SelectOption, TxnOption, Context, AggregationResult } from "../types";
-export declare abstract class SyncContext<ED extends EntityDict> implements Context {
+import { EntityDict as BaseEntityDict } from '../base-app-domain';
+export declare abstract class SyncContext<ED extends EntityDict & BaseEntityDict> implements Context {
     rowStore: SyncRowStore<ED, this>;
     private uuid?;
     constructor(rowStore: SyncRowStore<ED, SyncContext<ED>>);
@@ -18,7 +19,7 @@ export declare abstract class SyncContext<ED extends EntityDict> implements Cont
     mergeMultipleResults(toBeMerged: OperationResult<ED>[]): OperationResult<ED>;
     abstract allowUserUpdate(): boolean;
 }
-export interface SyncRowStore<ED extends EntityDict, Cxt extends SyncContext<ED>> extends RowStore<ED> {
+export interface SyncRowStore<ED extends EntityDict & BaseEntityDict, Cxt extends SyncContext<ED>> extends RowStore<ED> {
     operate<T extends keyof ED, OP extends OperateOption>(entity: T, operation: ED[T]['Operation'], context: Cxt, option: OP): OperationResult<ED>;
     select<T extends keyof ED, OP extends SelectOption>(entity: T, selection: ED[T]['Selection'], context: Cxt, option: OP): Partial<ED[T]['Schema']>[];
     count<T extends keyof ED, OP extends SelectOption>(entity: T, selection: Pick<ED[T]['Selection'], 'filter' | 'count'>, context: Cxt, option: OP): number;

package/lib/store/triggers.d.ts

@@ -0,0 +1,6 @@
+import { EntityDict as BaseEntityDict } from '../base-app-domain';
+import { EntityDict } from '../types/Entity';
+import { Trigger } from '../types';
+import { AsyncContext } from './AsyncRowStore';
+export declare const actionAuthTriggers: Trigger<EntityDict & BaseEntityDict, 'actionAuth', AsyncContext<EntityDict & BaseEntityDict>>[];
+export declare const logTriggers: Trigger<EntityDict & BaseEntityDict, 'log', AsyncContext<EntityDict & BaseEntityDict>>[];

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';
 /**
  * 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;