oak-domain 5.0.20 → 5.1.0

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;

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/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 {};

package/lib/types/Trigger.d.ts

@@ -4,6 +4,7 @@ import { AsyncContext } from "../store/AsyncRowStore";
 import { SyncContext } from "../store/SyncRowStore";
 import { EntityDict, OperateOption } from "../types/Entity";
 import { EntityShape } from "../types/Entity";
+import { EntityDict as BaseEntityDict } from '../base-app-domain';
 export type ModiTurn = 'create' | 'apply' | 'both';
 /**
  * 优先级越小，越早执行。定义在1～99之间
@@ -17,25 +18,25 @@ export declare const CHECKER_MAX_PRIORITY = 99;
  * 允许logicalData去改data中的值
  */
 export declare const CHECKER_PRIORITY_MAP: Record<CheckerType, number>;
-interface TriggerBase<ED extends EntityDict, T extends keyof ED> {
+interface TriggerBase<ED extends EntityDict & BaseEntityDict, T extends keyof ED> {
     checkerType?: CheckerType;
     entity: T;
     name: string;
     asRoot?: true;
     priority?: number;
 }
-export interface CreateTriggerBase<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> extends TriggerBase<ED, T> {
+export interface CreateTriggerBase<ED extends EntityDict & BaseEntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> extends TriggerBase<ED, T> {
     action: 'create';
     mt?: ModiTurn;
     check?: (operation: ED[T]['Create']) => boolean;
 }
-export interface CreateTriggerInTxn<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> extends CreateTriggerBase<ED, T, Cxt> {
+export interface CreateTriggerInTxn<ED extends EntityDict & BaseEntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> extends CreateTriggerBase<ED, T, Cxt> {
     when: 'before' | 'after';
     fn: (event: {
         operation: ED[T]['Create'];
     }, context: Cxt, option: OperateOption) => Promise<number> | number;
 }
-interface TriggerCrossTxn<ED extends EntityDict, Cxt extends AsyncContext<ED> | SyncContext<ED>> {
+interface TriggerCrossTxn<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED> | SyncContext<ED>> {
     when: 'commit';
     strict?: 'takeEasy' | 'makeSure';
     cs?: true;
@@ -45,72 +46,72 @@ interface TriggerCrossTxn<ED extends EntityDict, Cxt extends AsyncContext<ED> |
         ids: string[];
     }, context: Cxt, option: OperateOption) => Promise<((context: Cxt, option: OperateOption) => Promise<any>) | void>;
 }
-export interface CreateTriggerCrossTxn<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> extends CreateTriggerBase<ED, T, Cxt>, TriggerCrossTxn<ED, Cxt> {
+export interface CreateTriggerCrossTxn<ED extends EntityDict & BaseEntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> extends CreateTriggerBase<ED, T, Cxt>, TriggerCrossTxn<ED, Cxt> {
 }
-export type CreateTrigger<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = CreateTriggerInTxn<ED, T, Cxt> | CreateTriggerCrossTxn<ED, T, Cxt>;
+export type CreateTrigger<ED extends EntityDict & BaseEntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = CreateTriggerInTxn<ED, T, Cxt> | CreateTriggerCrossTxn<ED, T, Cxt>;
 /**
  * update trigger如果带有filter，说明只对存在限定条件的行起作用。此时系统在进行相应动作时，
  * 会判定当前动作的filter条件和trigger所定义的filter是否有交集（即有同时满足两个条件的行）
  * 只要有，就会触发trigger。要注意的是这个条件是exists而不是all
  */
-export interface UpdateTriggerBase<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> extends TriggerBase<ED, T> {
+export interface UpdateTriggerBase<ED extends EntityDict & BaseEntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> extends TriggerBase<ED, T> {
     action: Exclude<ED[T]['Action'], GenericAction> | 'update' | Array<Exclude<ED[T]['Action'], GenericAction> | 'update'>;
     attributes?: keyof ED[T]['OpSchema'] | Array<keyof ED[T]['OpSchema']>;
     mt?: ModiTurn;
     check?: (operation: ED[T]['Update']) => boolean;
     filter?: ED[T]['Update']['filter'] | ((operation: ED[T]['Update'], context: Cxt, option: OperateOption) => ED[T]['Update']['filter'] | Promise<ED[T]['Update']['filter']>);
 }
-export interface UpdateTriggerInTxn<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> extends UpdateTriggerBase<ED, T, Cxt> {
+export interface UpdateTriggerInTxn<ED extends EntityDict & BaseEntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> extends UpdateTriggerBase<ED, T, Cxt> {
     when: 'before' | 'after';
     fn: (event: {
         operation: ED[T]['Update'];
     }, context: Cxt, option: OperateOption) => Promise<number> | number;
 }
-export interface UpdateTriggerCrossTxn<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> extends UpdateTriggerBase<ED, T, Cxt>, TriggerCrossTxn<ED, Cxt> {
+export interface UpdateTriggerCrossTxn<ED extends EntityDict & BaseEntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> extends UpdateTriggerBase<ED, T, Cxt>, TriggerCrossTxn<ED, Cxt> {
 }
-export type UpdateTrigger<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = UpdateTriggerInTxn<ED, T, Cxt> | UpdateTriggerCrossTxn<ED, T, Cxt>;
+export type UpdateTrigger<ED extends EntityDict & BaseEntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = UpdateTriggerInTxn<ED, T, Cxt> | UpdateTriggerCrossTxn<ED, T, Cxt>;
 /**
  * 同update trigger一样，remove trigger如果带有filter，说明只对存在限定条件的行起作用。此时系统在进行相应动作时，
  * 会判定当前动作的filter条件和trigger所定义的filter是否有交集（即有同时满足两个条件的行）
  * 只要有，就会触发trigger。要注意的是这个条件是exists而不是all
  */
-export interface RemoveTriggerBase<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> extends TriggerBase<ED, T> {
+export interface RemoveTriggerBase<ED extends EntityDict & BaseEntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> extends TriggerBase<ED, T> {
     action: 'remove';
     mt?: ModiTurn;
     check?: (operation: ED[T]['Remove']) => boolean;
     filter?: ED[T]['Remove']['filter'] | ((operation: ED[T]['Remove'], context: Cxt, option: OperateOption) => ED[T]['Remove']['filter'] | Promise<ED[T]['Remove']['filter']>);
 }
-export interface RemoveTriggerInTxn<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> extends RemoveTriggerBase<ED, T, Cxt> {
+export interface RemoveTriggerInTxn<ED extends EntityDict & BaseEntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> extends RemoveTriggerBase<ED, T, Cxt> {
     when: 'before' | 'after';
     fn: (event: {
         operation: ED[T]['Remove'];
     }, context: Cxt, option: OperateOption) => Promise<number> | number;
 }
-export interface RemoveTriggerCrossTxn<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> extends RemoveTriggerBase<ED, T, Cxt>, TriggerCrossTxn<ED, Cxt> {
+export interface RemoveTriggerCrossTxn<ED extends EntityDict & BaseEntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> extends RemoveTriggerBase<ED, T, Cxt>, TriggerCrossTxn<ED, Cxt> {
 }
-export type RemoveTrigger<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = RemoveTriggerInTxn<ED, T, Cxt> | RemoveTriggerCrossTxn<ED, T, Cxt>;
-export interface SelectTriggerBase<ED extends EntityDict, T extends keyof ED> extends TriggerBase<ED, T> {
+export type RemoveTrigger<ED extends EntityDict & BaseEntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = RemoveTriggerInTxn<ED, T, Cxt> | RemoveTriggerCrossTxn<ED, T, Cxt>;
+export interface SelectTriggerBase<ED extends EntityDict & BaseEntityDict, T extends keyof ED> extends TriggerBase<ED, T> {
     action: 'select';
 }
 /**
  * selection似乎不需要支持跨事务？没想清楚
  * todo by Xc
  */
-export interface SelectTriggerBefore<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> extends SelectTriggerBase<ED, T> {
+export interface SelectTriggerBefore<ED extends EntityDict & BaseEntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> extends SelectTriggerBase<ED, T> {
     when: 'before';
     fn: (event: {
         operation: ED[T]['Selection'];
     }, context: Cxt, params?: SelectOption) => Promise<number> | number;
 }
-export interface SelectTriggerAfter<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> extends SelectTriggerBase<ED, T> {
+export interface SelectTriggerAfter<ED extends EntityDict & BaseEntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> extends SelectTriggerBase<ED, T> {
     when: 'after';
     fn: (event: {
         operation: ED[T]['Selection'];
         result: Partial<ED[T]['Schema']>[];
     }, context: Cxt, params?: SelectOption) => Promise<number> | number;
 }
-export type SelectTrigger<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = SelectTriggerBefore<ED, T, Cxt> | SelectTriggerAfter<ED, T, Cxt>;
-export type Trigger<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = CreateTrigger<ED, T, Cxt> | UpdateTrigger<ED, T, Cxt> | RemoveTrigger<ED, T, Cxt> | SelectTrigger<ED, T, Cxt>;
+export type SelectTrigger<ED extends EntityDict & BaseEntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = SelectTriggerBefore<ED, T, Cxt> | SelectTriggerAfter<ED, T, Cxt>;
+export type Trigger<ED extends EntityDict & BaseEntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = CreateTrigger<ED, T, Cxt> | UpdateTrigger<ED, T, Cxt> | RemoveTrigger<ED, T, Cxt> | SelectTrigger<ED, T, Cxt>;
 export interface TriggerEntityShape extends EntityShape {
     $$triggerData$$?: {
         name: string;
@@ -118,5 +119,5 @@ export interface TriggerEntityShape extends EntityShape {
     };
     $$triggerTimestamp$$?: number;
 }
-export type VolatileTrigger<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = CreateTriggerCrossTxn<ED, T, Cxt> | UpdateTriggerCrossTxn<ED, T, Cxt> | RemoveTriggerCrossTxn<ED, T, Cxt>;
+export type VolatileTrigger<ED extends EntityDict & BaseEntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = CreateTriggerCrossTxn<ED, T, Cxt> | UpdateTriggerCrossTxn<ED, T, Cxt> | RemoveTriggerCrossTxn<ED, T, Cxt>;
 export {};

package/lib/types/Watcher.d.ts

@@ -1,8 +1,9 @@
 import { ReadOnlyAction } from "../actions/action";
 import { AsyncContext } from "../store/AsyncRowStore";
 import { EntityDict, OperationResult } from "./Entity";
-type ActionData<ED extends EntityDict, T extends keyof ED> = ED[T]['Update']['data'] | ED[T]['Remove']['data'];
-export interface BBWatcher<ED extends EntityDict, T extends keyof ED> {
+import { EntityDict as BaseEntityDict } from '../base-app-domain';
+type ActionData<ED extends EntityDict & BaseEntityDict, T extends keyof ED> = ED[T]['Update']['data'] | ED[T]['Remove']['data'];
+export interface BBWatcher<ED extends EntityDict & BaseEntityDict, T extends keyof ED> {
     name: string;
     entity: T;
     filter: ED[T]['Selection']['filter'] | (() => ED[T]['Selection']['filter']);
@@ -10,7 +11,7 @@ export interface BBWatcher<ED extends EntityDict, T extends keyof ED> {
     actionData: ActionData<ED, T> | (() => Promise<ActionData<ED, T>>);
     singleton?: true;
 }
-export interface WBWatcher<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED>> {
+export interface WBWatcher<ED extends EntityDict & BaseEntityDict, T extends keyof ED, Cxt extends AsyncContext<ED>> {
     name: string;
     entity: T;
     filter: ED[T]['Selection']['filter'] | (() => Promise<ED[T]['Selection']['filter']>);
@@ -18,5 +19,5 @@ export interface WBWatcher<ED extends EntityDict, T extends keyof ED, Cxt extend
     fn: (context: Cxt, data: Partial<ED[T]['Schema']>[]) => Promise<OperationResult<ED>>;
     singleton?: true;
 }
-export type Watcher<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED>> = BBWatcher<ED, T> | WBWatcher<ED, T, Cxt>;
+export type Watcher<ED extends EntityDict & BaseEntityDict, T extends keyof ED, Cxt extends AsyncContext<ED>> = BBWatcher<ED, T> | WBWatcher<ED, T, Cxt>;
 export {};

package/lib/utils/assert.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 /**
  * 防止assert打包体积过大，从这里引用
  */

package/lib/utils/relationPath.js

@@ -60,7 +60,7 @@ function destructRelationPath(schema, entity, path, relationFilter, recursive) {
                         },
                         filter: relationFilter,
                     } // as ED['userRelation']['Selection']
-                }, // as ED[keyof ED]['Selection']['data'],
+                },
                 getData: (d) => {
                     return d.userRelation$entity;
                 },

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "oak-domain",
-    "version": "5.0.20",
+    "version": "5.1.0",
     "author": {
         "name": "XuChang"
     },

package/src/entities/Log.ts

@@ -0,0 +1,59 @@
+import { ActionDef } from '../types/Action';
+import { String, Int, Datetime, Image, Boolean, Text } from '../types/DataType';
+import { EntityShape } from '../types/Entity';
+import { EntityDesc } from '../types/EntityDesc';
+
+export interface Schema extends EntityShape {
+    entity: String<32>;             // 关联的目标对象
+    entityId: String<64>;           // 关联的目标对象id
+};
+
+export type IState = 'normal' | 'rollbacked';
+export type State = IState;
+export type IAction = 'undo' | 'redo';
+export type Action = IAction;
+export const IActionDef: ActionDef<IAction, IState> = {
+    stm: {
+        undo: ['normal', 'rollbacked'],
+        redo: ['rollbacked', 'normal'],
+    },
+    is: 'normal',
+};
+
+
+export const entityDesc: EntityDesc<Schema, Action, '', {
+    iState: IState,
+}> = {
+    locales: {
+        zh_CN: {
+            name: '日志',
+            attr: {
+                entity: '关联对象',
+                entityId: '关联对象ID',
+                iState: '状态'
+            },
+            action: {
+                undo: '回滚',
+                redo: '重做',
+            },
+            v: {
+                iState: {
+                    normal: '正常的',
+                    rollbacked: '已回滚',
+                }
+            }
+        },
+    },
+    style: {
+        icon: {
+            undo: '',
+            redo: '',
+        },
+        color: {
+            iState: {
+                normal: '#229954',
+                rollbacked: '#2C3E50',
+            },
+        },
+    },
+};

package/src/entities/Oper.ts

@@ -2,6 +2,8 @@ import { String, Int, Datetime, Image, Boolean, Text } from '../types/DataType';
 import { EntityShape } from '../types/Entity';
 import { Schema as User } from './User';
 import { EntityDesc } from '../types/EntityDesc';
+import { Schema as Log } from './Log';
+import { ActionDef } from '../types/Action';
 
 export interface Schema extends EntityShape {
     action: String<24>;
@@ -11,9 +13,26 @@ export interface Schema extends EntityShape {
     operator?: User;
     targetEntity: String<32>;
     bornAt?: Datetime;
+    log?: Log;
+    undoData?: Object;
 };
 
-const entityDesc: EntityDesc<Schema> = {
+
+export type IState = 'normal' | 'rollbacked';
+export type State = IState;
+export type IAction = 'undo' | 'redo';
+export type Action = IAction;
+export const IActionDef: ActionDef<IAction, IState> = {
+    stm: {
+        undo: ['normal', 'rollbacked'],
+        redo: ['rollbacked', 'normal'],
+    },
+    is: 'normal',
+};
+
+const entityDesc: EntityDesc<Schema, Action, '', {
+    iState: IState,
+}> = {
     locales: {
         zh_CN: {
             name: '操作',
@@ -24,12 +43,34 @@ const entityDesc: EntityDesc<Schema> = {
                 extra: '其它',
                 operator: '操作者',
                 targetEntity: '关联对象',
-                bornAt: '诞生时间'
+                bornAt: '诞生时间',
+                log: '关联日志',
+                undoData: '回滚数据',
+                iState: '状态',
             },
+            action: {
+                undo: '回滚',
+                redo: '重做',
+            },
+            v: {
+                iState: {
+                    normal: '正常的',
+                    rollbacked: '已回滚',
+                }
+            }
         },
     },
-    configuration: {
-        actionType: 'appendOnly',
+    style: {
+        icon: {
+            undo: '',
+            redo: '',
+        },
+        color: {
+            iState: {
+                normal: '#229954',
+                rollbacked: '#2C3E50',
+            },
+        },
     },
     indexes: [
         {

package/lib/store/actionAuth.d.ts

@@ -1,4 +0,0 @@
-import { EntityDict } from '../types/Entity';
-import { Trigger } from '../types';
-import { AsyncContext } from './AsyncRowStore';
-export declare const triggers: Trigger<EntityDict, 'actionAuth', AsyncContext<EntityDict>>[];

package/lib/store/actionAuth.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.triggers = void 0;
-const uuid_1 = require("../utils/uuid");
-exports.triggers = [
-    {
-        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',
-    }
-];