oak-domain 1.1.14 → 2.0.1

package/lib/types/AppLoader.d.ts

@@ -1,11 +1,11 @@
-import { Context, RowStore } from ".";
+import { AsyncContext, AsyncRowStore } from "../store/AsyncRowStore";
 import { EntityDict } from "./Entity";
-export declare abstract class AppLoader<ED extends EntityDict, Cxt extends Context<ED>> {
+export declare abstract class AppLoader<ED extends EntityDict, Cxt extends AsyncContext<ED>> {
     protected path: string;
     constructor(path: string);
     abstract execAspect(name: string, context: Cxt, params?: any): Promise<any>;
     abstract initialize(dropIfExists?: boolean): Promise<void>;
     abstract mount(): Promise<void>;
     abstract unmount(): Promise<void>;
-    abstract getStore(): RowStore<ED, Cxt>;
+    abstract getStore(): AsyncRowStore<ED, Cxt>;
 }

package/lib/types/Aspect.d.ts

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

package/lib/types/Auth.d.ts

@@ -1,28 +1,31 @@
-import { EntityDict } from "../types/Entity";
-import { Context } from "./Context";
-import { CreateTriggerBase, RemoveTriggerBase, UpdateTriggerBase, CheckerType, SelectTriggerBefore } from "./Trigger";
-export declare type CreateChecker<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>> = {
-    type: CheckerType;
-    action: 'create';
+import { AsyncContext } from "../store/AsyncRowStore";
+import { SyncContext } from "../store/SyncRowStore";
+import { EntityDict, OperateOption, SelectOption } from "../types/Entity";
+export declare type DataChecker<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = {
+    priority?: number;
+    type: 'data';
     entity: T;
-    checker: CreateTriggerBase<ED, T, Cxt>['fn'];
+    action: Omit<ED[T]['Action'], 'remove'>;
+    checker: (data: ED[T]['Create']['data'] | ED[T]['Update']['data'], context: Cxt) => void;
 };
-export declare type UpdateChecker<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>> = {
-    type: CheckerType;
-    action: UpdateTriggerBase<ED, T, Cxt>['action'];
+export declare type RowChecker<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = {
+    priority?: number;
+    type: 'row';
     entity: T;
-    checker: UpdateTriggerBase<ED, T, Cxt>['fn'];
+    action: Omit<ED[T]['Action'], 'create'> | Array<Omit<ED[T]['Action'], 'create'>>;
+    filter: ED[T]['Selection']['filter'] | ((context: Cxt, option: OperateOption | SelectOption) => ED[T]['Selection']['filter']);
+    errMsg?: string;
+    inconsistentRows?: {
+        entity: keyof ED;
+        selection: (filter?: ED[T]['Selection']['filter']) => ED[keyof ED]['Selection'];
+    };
 };
-export declare type RemoveChecker<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>> = {
-    type: CheckerType;
-    action: 'remove';
+export declare type RelationChecker<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = {
+    priority?: number;
+    type: 'relation';
     entity: T;
-    checker: RemoveTriggerBase<ED, T, Cxt>['fn'];
+    action: Omit<ED[T]['Action'], 'create'> | Array<Omit<ED[T]['Action'], 'create'>>;
+    relationFilter: (context: Cxt, option: OperateOption | SelectOption) => ED[T]['Selection']['filter'];
+    errMsg: string;
 };
-export declare type SelectChecker<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>> = {
-    type: CheckerType;
-    action: 'select';
-    entity: T;
-    checker: SelectTriggerBefore<ED, T, Cxt>['fn'];
-};
-export declare type Checker<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>> = CreateChecker<ED, T, Cxt> | UpdateChecker<ED, T, Cxt> | RemoveChecker<ED, T, Cxt> | SelectChecker<ED, T, Cxt>;
+export declare type Checker<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = DataChecker<ED, T, Cxt> | RowChecker<ED, T, Cxt> | RelationChecker<ED, T, Cxt>;

package/lib/types/Connector.d.ts

@@ -1,21 +1,21 @@
 /// <reference types="node" />
 import { IncomingHttpHeaders } from "http";
-import { RowStore } from ".";
-import { Context } from "./Context";
+import { AsyncContext, AsyncRowStore } from "../store/AsyncRowStore";
+import { SyncContext } from "../store/SyncRowStore";
 import { EntityDict, OpRecord } from "./Entity";
 import { OakException } from "./Exception";
-export declare abstract class Connector<ED extends EntityDict, Cxt extends Context<ED>> {
-    abstract callAspect(name: string, params: any, context: Cxt): Promise<{
+export declare abstract class Connector<ED extends EntityDict, BackCxt extends AsyncContext<ED>, FrontCxt extends SyncContext<ED>> {
+    abstract callAspect(name: string, params: any, context: FrontCxt): Promise<{
         result: any;
         opRecords: OpRecord<ED>[];
     }>;
     abstract getRouter(): string;
-    abstract parseRequest(headers: IncomingHttpHeaders, body: any, store: RowStore<ED, Cxt>): Promise<{
+    abstract parseRequest(headers: IncomingHttpHeaders, body: any, store: AsyncRowStore<ED, BackCxt>): Promise<{
         name: string;
         params: any;
-        context: Cxt;
+        context: BackCxt;
     }>;
-    abstract serializeResult(result: any, context: Cxt, headers: IncomingHttpHeaders, body: any): {
+    abstract serializeResult(result: any, context: BackCxt, headers: IncomingHttpHeaders, body: any): {
         body: any;
         headers?: Record<string, any>;
     };

package/lib/types/Context.d.ts

@@ -1,16 +1,6 @@
-import { EntityDict, OpRecord } from './Entity';
-import { RowStore } from './RowStore';
-export interface Context<ED extends EntityDict> {
-    opRecords: OpRecord<ED>[];
-    rowStore: RowStore<ED, this>;
-    begin(options?: object): Promise<void>;
-    commit(): Promise<void>;
-    rollback(): Promise<void>;
+export interface Context {
     getCurrentTxnId(): string | undefined;
-    on(event: 'commit' | 'rollback', callback: () => Promise<void>): void;
-    toString(): Promise<string>;
-    getScene(): string | undefined;
-    setScene(scene?: string): void;
-    getCurrentUserId(allowUnloggedIn?: boolean): Promise<string | undefined>;
-    getHeader(key: string): string | string[] | undefined;
+    getCurrentUserId(allowUnloggedIn?: boolean): string | undefined;
+    isRoot(): boolean;
+    toString(): string;
 }

package/lib/types/Entity.d.ts

@@ -1,11 +1,22 @@
 import { GenericAction } from '../actions/action';
-import { ExpressionKey, ExprOp, MakeFilter, NodeId } from './Demand';
-import { OneOf, OptionalKeys } from './Polyfill';
+import { ExprOp, MakeFilter, NodeId } from './Demand';
+import { OneOf } from './Polyfill';
 import { PrimaryKey, Sequence } from './DataType';
-export declare type TriggerDataAttribute = '$$triggerData$$';
-export declare type TriggerTimestampAttribute = '$$triggerTimestamp$$';
-declare type PrimaryKeyAttribute = 'id';
-export declare type InstinctiveAttributes = PrimaryKeyAttribute | '$$createAt$$' | '$$updateAt$$' | '$$deleteAt$$' | TriggerDataAttribute | TriggerTimestampAttribute | '$$seq$$';
+declare type TriggerDataAttributeType = '$$triggerData$$';
+declare type TriggerTimestampAttributeType = '$$triggerTimestamp$$';
+declare type PrimaryKeyAttributeType = 'id';
+declare type CreateAtAttributeType = '$$createAt$$';
+declare type UpdateAtAttributeType = '$$updateAt$$';
+declare type DeleteAtAttributeType = '$$deleteAt$$';
+declare type SeqAttributeType = '$$seq$$';
+export declare const TriggerDataAttribute = "$$triggerData$$";
+export declare const TriggerTimestampAttribute = "$$triggerTimestamp$$";
+export declare const PrimaryKeyAttribute = "id";
+export declare const CreateAtAttribute = "$$createAt$$";
+export declare const UpdateAtAttribute = "$$updateAt$$";
+export declare const DeleteAtAttribute = "$$deleteAt$$";
+export declare const SeqAttribute = "$$seq$$";
+export declare type InstinctiveAttributes = PrimaryKeyAttributeType | CreateAtAttributeType | UpdateAtAttributeType | DeleteAtAttributeType | TriggerDataAttributeType | TriggerTimestampAttributeType | SeqAttributeType;
 export declare const initinctiveAttributes: string[];
 export declare type Filter<A extends string, F extends Object | undefined = undefined> = {
     filter?: A extends 'create' ? undefined : F;
@@ -78,14 +89,14 @@ export interface OtmSubProjection extends Omit<DeduceSelection<any>, 'action'> {
 declare type DeduceProjection<SH extends GeneralEntityShape> = {
     '#id'?: NodeId;
 } & {
-    [K in keyof SH]?: 1 | OtmSubProjection | any;
+    [K in keyof SH]?: number | OtmSubProjection | any;
 } & Partial<ExprOp<keyof SH>>;
 export declare type AttrFilter<SH extends GeneralEntityShape> = {
     [K in keyof SH]: any;
 };
 export declare type DeduceFilter<SH extends GeneralEntityShape> = MakeFilter<AttrFilter<SH> & ExprOp<keyof SH>>;
 export declare type DeduceSorterAttr<SH extends GeneralEntityShape> = OneOf<{
-    [K: string]: 1 | object | undefined;
+    [K: string]: number | object | undefined;
 } & ExprOp<keyof SH>>;
 export declare type DeduceSorterItem<SH extends GeneralEntityShape> = {
     $attr: DeduceSorterAttr<SH>;
@@ -109,7 +120,7 @@ export declare type DeduceRemoveOperationData<SH extends GeneralEntityShape> = {
     [A in keyof Omit<SH, InstinctiveAttributes>]?: any;
 };
 export declare type DeduceRemoveOperation<SH extends GeneralEntityShape> = Operation<'remove', DeduceRemoveOperationData<SH>, DeduceFilter<SH>, DeduceSorter<SH>>;
-export declare type DeduceOperation<SH extends GeneralEntityShape> = DeduceCreateOperation<SH> | DeduceUpdateOperation<SH> | DeduceRemoveOperation<SH> | DeduceSelection<SH>;
+export declare type DeduceOperation<SH extends GeneralEntityShape> = DeduceCreateOperation<SH> | DeduceUpdateOperation<SH> | DeduceRemoveOperation<SH>;
 export declare type CreateOpResult<ED extends EntityDict, T extends keyof ED> = {
     a: 'c';
     e: T;
@@ -140,12 +151,6 @@ export declare type OperationResult<ED extends EntityDict> = {
         [A in ED[K]['Action']]?: number;
     };
 };
-export declare type SelectRowShape<E extends GeneralEntityShape, P extends DeduceProjection<GeneralEntityShape>> = {
-    [K in keyof P]: K extends ExpressionKey ? any : (K extends keyof E ? (P[K] extends 1 | undefined ? E[K] : (P[K] extends OtmSubProjection ? SelectRowShape<Required<E>[K][0], P[K]['data']>[] | Array<never> : (K extends OptionalKeys<E> ? SelectRowShape<NonNullable<Required<E>[K]>, P[K]> | null : SelectRowShape<NonNullable<Required<E>[K]>, P[K]>))) : never);
-};
-export declare type SelectionResult<E extends GeneralEntityShape, P extends DeduceProjection<GeneralEntityShape>> = {
-    result: Array<SelectRowShape<E, P>>;
-};
 export declare type ActionType = 'readOnly' | 'appendOnly' | 'excludeUpdate' | 'excludeRemove' | 'crud';
 export declare type Configuration = {
     actionType?: ActionType;

package/lib/types/Entity.js

@@ -1,7 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.initinctiveAttributes = void 0;
-exports.initinctiveAttributes = ['id', '$$createAt$$', '$$updateAt$$', '$$deleteAt$$', '$$triggerData$$', '$$triggerTimestamp$$', '$$seq$$'];
+exports.initinctiveAttributes = exports.SeqAttribute = exports.DeleteAtAttribute = exports.UpdateAtAttribute = exports.CreateAtAttribute = exports.PrimaryKeyAttribute = exports.TriggerTimestampAttribute = exports.TriggerDataAttribute = void 0;
+exports.TriggerDataAttribute = '$$triggerData$$';
+exports.TriggerTimestampAttribute = '$$triggerTimestamp$$';
+exports.PrimaryKeyAttribute = 'id';
+exports.CreateAtAttribute = '$$createAt$$';
+exports.UpdateAtAttribute = '$$updateAt$$';
+exports.DeleteAtAttribute = '$$deleteAt$$';
+exports.SeqAttribute = '$$seq$$';
+exports.initinctiveAttributes = [exports.PrimaryKeyAttribute, exports.TriggerDataAttribute, exports.TriggerTimestampAttribute, exports.CreateAtAttribute, exports.UpdateAtAttribute, exports.DeleteAtAttribute, exports.SeqAttribute];
 ;
 ;
 ;

package/lib/types/Exception.js

@@ -212,37 +212,37 @@ exports.OakDeadlock = OakDeadlock;
 function makeException(data) {
     var name = data.name;
     switch (name) {
-        case OakException.name: {
+        case 'OakException': {
             return new OakException(data.message);
         }
-        case OakUserException.name: {
+        case 'OakUserException': {
             return new OakUserException(data.message);
         }
-        case OakExternalException.name: {
+        case 'OakExternalException': {
             return new OakExternalException(data.message);
         }
-        case OakRowInconsistencyException.name: {
+        case 'OakRowInconsistencyException': {
             return new OakRowInconsistencyException(data.data, data.message);
         }
-        case OakInputIllegalException.name: {
+        case 'OakInputIllegalException': {
             return new OakInputIllegalException(data.entity, data.attributes, data.message);
         }
-        case OakUserUnpermittedException.name: {
+        case 'OakUserUnpermittedException': {
             return new OakUserUnpermittedException(data.message);
         }
-        case OakUnloggedInException.name: {
+        case 'OakUnloggedInException': {
             return new OakUnloggedInException(data.message);
         }
-        case OakCongruentRowExists.name: {
+        case 'OakCongruentRowExists': {
             return new OakCongruentRowExists(data.entity, data.data, data.message);
         }
-        case OakRowLockedException.name: {
+        case 'OakRowLockedException': {
             return new OakRowLockedException(data.message);
         }
-        case OakRowUnexistedException.name: {
+        case 'OakRowUnexistedException': {
             return new OakRowUnexistedException(data.rows);
         }
-        case OakDeadlock.name: {
+        case 'OakDeadlock': {
             return new OakDeadlock(data.message);
         }
         default:

package/lib/types/RowStore.d.ts

@@ -1,22 +1,11 @@
-import { OperationResult, OperateOption, EntityDict, SelectionResult } from './Entity';
-import { Context } from './Context';
+import { OperationResult, EntityDict } from './Entity';
 import { StorageSchema } from './Storage';
-import { OakErrorDefDict } from '../OakError';
-import { SelectOption } from '.';
 export declare type TxnOption = {
     isolationLevel: 'repeatable read' | 'serializable';
 };
-export declare abstract class RowStore<ED extends EntityDict, Cxt extends Context<ED>> {
-    static $$LEVEL: string;
-    static $$CODES: OakErrorDefDict;
+export declare abstract class RowStore<ED extends EntityDict> {
     protected storageSchema: StorageSchema<ED>;
-    abstract operate<T extends keyof ED, OP extends OperateOption>(entity: T, operation: ED[T]['Operation'], context: Cxt, option: OP): Promise<OperationResult<ED>>;
-    abstract select<T extends keyof ED, S extends ED[T]['Selection'], OP extends SelectOption>(entity: T, selection: S, context: Cxt, option: OP): Promise<SelectionResult<ED[T]['Schema'], S['data']>>;
-    abstract count<T extends keyof ED, OP extends SelectOption>(entity: T, selection: Pick<ED[T]['Selection'], 'filter' | 'count'>, context: Cxt, option: OP): Promise<number>;
     constructor(storageSchema: StorageSchema<ED>);
-    abstract begin(option?: TxnOption): Promise<string>;
-    abstract commit(txnId: string): Promise<void>;
-    abstract rollback(txnId: string): Promise<void>;
     getSchema(): StorageSchema<ED>;
     mergeOperationResult(result: OperationResult<ED>, toBeMerged: OperationResult<ED>): void;
     mergeMultipleResults(toBeMerged: OperationResult<ED>[]): OperationResult<ED>;

package/lib/types/RowStore.js

@@ -28,12 +28,7 @@ var RowStore = /** @class */ (function () {
         toBeMerged.forEach(function (ele) { return _this.mergeOperationResult(result, ele); });
         return result;
     };
-    RowStore.$$LEVEL = 'store';
-    RowStore.$$CODES = {
-        primaryKeyConfilict: [1, '主键重复'],
-        expressionUnresolved: [2, '表达式无法计算完成'],
-        nodeIdRepeated: [3, '查询或投影中的nodeId重复'],
-    };
     return RowStore;
 }());
 exports.RowStore = RowStore;
+;

package/lib/types/Trigger.d.ts

@@ -1,89 +1,84 @@
-import { SelectOption, SelectRowShape } from ".";
+import { SelectOption } from ".";
 import { GenericAction } from "../actions/action";
+import { AsyncContext } from "../store/AsyncRowStore";
+import { SyncContext } from "../store/SyncRowStore";
 import { EntityDict, OperateOption } from "../types/Entity";
-import { EntityShape, TriggerDataAttribute, TriggerTimestampAttribute } from "../types/Entity";
-import { Context } from "./Context";
-export declare type CheckerType = 'user' | 'row' | 'data';
-export interface CreateTriggerBase<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>> {
+import { EntityShape } from "../types/Entity";
+export declare type CheckerType = 'relation' | 'row' | 'data';
+interface TriggerBase<ED extends EntityDict, T extends keyof ED> {
     checkerType?: CheckerType;
     entity: T;
     name: string;
+    priority?: number;
+}
+export interface CreateTriggerBase<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> extends TriggerBase<ED, T> {
     action: 'create';
     check?: (operation: ED[T]['Create']) => boolean;
     fn: (event: {
         operation: ED[T]['Create'];
-    }, context: Cxt, option: OperateOption) => Promise<number>;
+    }, context: Cxt, option: OperateOption) => Promise<number> | number;
 }
-export interface CreateTriggerInTxn<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>> extends CreateTriggerBase<ED, T, Cxt> {
+export interface CreateTriggerInTxn<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> extends CreateTriggerBase<ED, T, Cxt> {
     when: 'before' | 'after';
 }
-export interface CreateTriggerCrossTxn<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>> extends CreateTriggerBase<ED, T, Cxt> {
+export interface CreateTriggerCrossTxn<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> extends CreateTriggerBase<ED, T, Cxt> {
     when: 'commit';
     strict?: 'takeEasy' | 'makeSure';
 }
-export declare type CreateTrigger<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>> = CreateTriggerInTxn<ED, T, Cxt> | CreateTriggerCrossTxn<ED, T, Cxt>;
-export interface UpdateTriggerBase<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>> {
-    checkerType?: CheckerType;
-    entity: T;
-    name: string;
+export declare type CreateTrigger<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = CreateTriggerInTxn<ED, T, Cxt> | CreateTriggerCrossTxn<ED, T, Cxt>;
+export interface UpdateTriggerBase<ED extends EntityDict, 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']>;
     check?: (operation: ED[T]['Update']) => boolean;
     fn: (event: {
         operation: ED[T]['Update'];
-    }, context: Cxt, option: OperateOption) => Promise<number>;
+    }, context: Cxt, option: OperateOption) => Promise<number> | number;
 }
-export interface UpdateTriggerInTxn<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>> extends UpdateTriggerBase<ED, T, Cxt> {
+export interface UpdateTriggerInTxn<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> extends UpdateTriggerBase<ED, T, Cxt> {
     when: 'before' | 'after';
 }
-export interface UpdateTriggerCrossTxn<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>> extends UpdateTriggerBase<ED, T, Cxt> {
+export interface UpdateTriggerCrossTxn<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> extends UpdateTriggerBase<ED, T, Cxt> {
     when: 'commit';
     strict?: 'takeEasy' | 'makeSure';
 }
-export declare type UpdateTrigger<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>> = UpdateTriggerInTxn<ED, T, Cxt> | UpdateTriggerCrossTxn<ED, T, Cxt>;
-export interface RemoveTriggerBase<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>> {
-    checkerType?: CheckerType;
-    entity: T;
-    name: string;
+export declare type UpdateTrigger<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = UpdateTriggerInTxn<ED, T, Cxt> | UpdateTriggerCrossTxn<ED, T, Cxt>;
+export interface RemoveTriggerBase<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> extends TriggerBase<ED, T> {
     action: 'remove';
     check?: (operation: ED[T]['Remove']) => boolean;
     fn: (event: {
         operation: ED[T]['Remove'];
-    }, context: Cxt, option: OperateOption) => Promise<number>;
+    }, context: Cxt, option: OperateOption) => Promise<number> | number;
 }
-export interface RemoveTriggerInTxn<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>> extends RemoveTriggerBase<ED, T, Cxt> {
+export interface RemoveTriggerInTxn<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> extends RemoveTriggerBase<ED, T, Cxt> {
     when: 'before' | 'after';
 }
-export interface RemoveTriggerCrossTxn<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>> extends RemoveTriggerBase<ED, T, Cxt> {
+export interface RemoveTriggerCrossTxn<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> extends RemoveTriggerBase<ED, T, Cxt> {
     when: 'commit';
     strict?: 'takeEasy' | 'makeSure';
 }
-export declare type RemoveTrigger<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>> = RemoveTriggerInTxn<ED, T, Cxt> | RemoveTriggerCrossTxn<ED, T, Cxt>;
-export interface SelectTriggerBase<ED extends EntityDict, T extends keyof ED> {
-    checkerType?: undefined;
-    entity: T;
-    name: string;
+export declare 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> {
     action: 'select';
 }
 /**
  * selection似乎不需要支持跨事务？没想清楚
  * todo by Xc
  */
-export interface SelectTriggerBefore<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>> extends SelectTriggerBase<ED, T> {
+export interface SelectTriggerBefore<ED extends EntityDict, 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>;
+    }, context: Cxt, params?: SelectOption) => Promise<number> | number;
 }
-export interface SelectTriggerAfter<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>> extends SelectTriggerBase<ED, T> {
+export interface SelectTriggerAfter<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> extends SelectTriggerBase<ED, T> {
     when: 'after';
     fn: (event: {
         operation: ED[T]['Selection'];
-        result: SelectRowShape<ED[T]['Schema'], ED[T]['Selection']['data']>[];
-    }, context: Cxt, params?: SelectOption) => Promise<number>;
+        result: Partial<ED[T]['Schema']>[];
+    }, context: Cxt, params?: SelectOption) => Promise<number> | number;
 }
-export declare type SelectTrigger<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>> = SelectTriggerBefore<ED, T, Cxt> | SelectTriggerAfter<ED, T, Cxt>;
-export declare type Trigger<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>> = CreateTrigger<ED, T, Cxt> | UpdateTrigger<ED, T, Cxt> | RemoveTrigger<ED, T, Cxt> | SelectTrigger<ED, T, Cxt>;
+export declare type SelectTrigger<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = SelectTriggerBefore<ED, T, Cxt> | SelectTriggerAfter<ED, T, Cxt>;
+export declare 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 interface TriggerEntityShape extends EntityShape {
     $$triggerData$$?: {
         name: string;
@@ -91,15 +86,4 @@ export interface TriggerEntityShape extends EntityShape {
     };
     $$triggerTimestamp$$?: number;
 }
-export declare abstract class Executor<ED extends EntityDict, Cxt extends Context<ED>> {
-    static dataAttr: TriggerDataAttribute;
-    static timestampAttr: TriggerTimestampAttribute;
-    abstract registerTrigger<T extends keyof ED>(trigger: Trigger<ED, T, Cxt>): void;
-    abstract preOperation<T extends keyof ED>(entity: T, operation: ED[T]['Operation'] | ED[T]['Selection'] & {
-        action: 'select';
-    }, context: Cxt, option: OperateOption | SelectOption): Promise<void>;
-    abstract postOperation<T extends keyof ED>(entity: T, operation: ED[T]['Operation'] | ED[T]['Selection'] & {
-        action: 'select';
-    }, context: Cxt, option: OperateOption | SelectOption, result?: SelectRowShape<ED[T]['Schema'], ED[T]['Selection']['data']>[]): Promise<void>;
-    abstract checkpoint(context: Cxt, timestamp: number): Promise<number>;
-}
+export {};

package/lib/types/Trigger.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Executor = void 0;
 ;
 ;
 ;
@@ -14,11 +13,27 @@ exports.Executor = void 0;
 ;
 ;
 ;
-var Executor = /** @class */ (function () {
-    function Executor() {
-    }
-    Executor.dataAttr = '$$triggerData$$';
-    Executor.timestampAttr = '$$triggerTimestamp$$';
-    return Executor;
-}());
-exports.Executor = Executor;
+;
+/* export abstract class Executor<ED extends EntityDict, Cxt extends AsyncContext<ED>> {
+    static dataAttr: TriggerDataAttribute = '$$triggerData$$';
+    static timestampAttr: TriggerTimestampAttribute = '$$triggerTimestamp$$';
+
+    abstract registerTrigger<T extends keyof ED>(trigger: Trigger<ED, T>): void;
+
+    abstract preOperation<T extends keyof ED>(
+        entity: T,
+        operation: ED[T]['Operation'] | ED[T]['Selection'] & { action: 'select' },
+        context: Cxt,
+        option: OperateOption | SelectOption
+    ): Promise<void>;
+
+    abstract postOperation<T extends keyof ED>(
+        entity: T,
+        operation: ED[T]['Operation'] | ED[T]['Selection'] & { action: 'select' },
+        context: Cxt,
+        option: OperateOption | SelectOption,
+        result?: SelectRowShape<ED[T]['Schema'], ED[T]['Selection']['data']>[]
+    ): Promise<void>;
+
+    abstract checkpoint(context: Cxt, timestamp: number): Promise<number>;    // 将所有在timestamp之前存在不一致的数据进行恢复
+} */

package/lib/types/Watcher.d.ts

@@ -1,20 +1,19 @@
-import { SelectRowShape } from ".";
-import { Context } from "./Context";
+import { AsyncContext } from "../store/AsyncRowStore";
 import { EntityDict, OperationResult } from "./Entity";
 declare 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> {
     name: string;
     entity: T;
-    filter: ED[T]['Selection']['filter'] | (() => Promise<ED[T]['Selection']['filter']>);
+    filter: ED[T]['Selection']['filter'] | (() => ED[T]['Selection']['filter']);
     action: ED[T]['Operation']['action'];
-    actionData: ActionData<ED, T> | (() => Promise<ActionData<ED, T>>);
+    actionData: ActionData<ED, T> | (() => ActionData<ED, T>);
 }
-export interface WBWatcher<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>, Proj extends ED[T]['Selection']['data'] = ED[T]['Selection']['data']> {
+export interface WBWatcher<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED>> {
     name: string;
     entity: T;
     filter: ED[T]['Selection']['filter'] | (() => Promise<ED[T]['Selection']['filter']>);
-    projection: Proj | (() => Promise<Proj>);
-    fn: (context: Cxt, data: SelectRowShape<ED[T]['Schema'], Proj>[]) => Promise<OperationResult<ED>>;
+    projection: ED[T]['Selection']['data'] | (() => Promise<ED[T]['Selection']['data']>);
+    fn: (context: Cxt, data: Partial<ED[T]['Schema']>[]) => Promise<OperationResult<ED>>;
 }
-export declare type Watcher<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>> = BBWatcher<ED, T> | WBWatcher<ED, T, Cxt>;
+export declare type Watcher<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED>> = BBWatcher<ED, T> | WBWatcher<ED, T, Cxt>;
 export {};

package/lib/utils/SimpleConnector.d.ts

@@ -1,24 +1,25 @@
 /// <reference types="node" />
 import { IncomingHttpHeaders } from "http";
-import { UniversalContext } from "../store/UniversalContext";
-import { Connector, EntityDict, OakException, OpRecord, RowStore } from "../types";
-export declare class SimpleConnector<ED extends EntityDict, Cxt extends UniversalContext<ED>> extends Connector<ED, Cxt> {
+import { AsyncContext, AsyncRowStore } from '../store/AsyncRowStore';
+import { SyncContext } from '../store/SyncRowStore';
+import { Connector, EntityDict, OakException, OpRecord } from "../types";
+export declare class SimpleConnector<ED extends EntityDict, BackCxt extends AsyncContext<ED>, FrontCxt extends SyncContext<ED>> extends Connector<ED, BackCxt, FrontCxt> {
     static ROUTER: string;
     private serverUrl;
     private makeException;
     private contextBuilder;
-    constructor(serverUrl: string, makeException: (exceptionData: any) => OakException, contextBuilder: (str: string | undefined) => (store: RowStore<ED, Cxt>) => Promise<Cxt>);
-    callAspect(name: string, params: any, context: Cxt): Promise<{
+    constructor(serverUrl: string, makeException: (exceptionData: any) => OakException, contextBuilder: (str: string | undefined) => (store: AsyncRowStore<ED, BackCxt>) => Promise<BackCxt>);
+    callAspect(name: string, params: any, context: FrontCxt): Promise<{
         result: any;
         opRecords: OpRecord<ED>[];
     }>;
     getRouter(): string;
-    parseRequest(headers: IncomingHttpHeaders, body: any, store: RowStore<ED, Cxt>): Promise<{
+    parseRequest(headers: IncomingHttpHeaders, body: any, store: AsyncRowStore<ED, BackCxt>): Promise<{
         name: string;
         params: any;
-        context: Cxt;
+        context: BackCxt;
     }>;
-    serializeResult(result: any, context: Cxt, headers: IncomingHttpHeaders, body: any): {
+    serializeResult(result: any, context: BackCxt, headers: IncomingHttpHeaders, body: any): {
         body: any;
         headers?: Record<string, any> | undefined;
     };

package/lib/utils/SimpleConnector.js

@@ -24,9 +24,8 @@ var SimpleConnector = /** @class */ (function (_super) {
             var cxtStr, _a, contentType, body, response, err, _b, exception, result, opRecords;
             return tslib_1.__generator(this, function (_c) {
                 switch (_c.label) {
-                    case 0: return [4 /*yield*/, context.toString()];
-                    case 1:
-                        cxtStr = _c.sent();
+                    case 0:
+                        cxtStr = context.toString();
                         _a = makeContentTypeAndBody(params), contentType = _a.contentType, body = _a.body;
                         return [4 /*yield*/, global.fetch(this.serverUrl, {
                                 method: 'POST',
@@ -37,14 +36,14 @@ var SimpleConnector = /** @class */ (function (_super) {
                                 },
                                 body: body,
                             })];
-                    case 2:
+                    case 1:
                         response = _c.sent();
                         if (response.status > 299) {
                             err = new types_1.OakExternalException("\u7F51\u7EDC\u8BF7\u6C42\u8FD4\u56DE\u5F02\u5E38\uFF0Cstatus\u662F".concat(response.status));
                             throw err;
                         }
                         return [4 /*yield*/, response.json()];
-                    case 3:
+                    case 2:
                         _b = _c.sent(), exception = _b.exception, result = _b.result, opRecords = _b.opRecords;
                         if (exception) {
                             throw this.makeException(exception);

package/lib/utils/random/random.d.ts

@@ -0,0 +1 @@
+export declare function getRandomValues(length: number): Promise<Uint8Array>;

package/lib/utils/random/random.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRandomValues = void 0;
+var tslib_1 = require("tslib");
+var node_crypto_1 = require("node:crypto");
+function getRandomValues(length) {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        return tslib_1.__generator(this, function (_a) {
+            if (length > 65536) {
+                throw new Error('Can only request a maximum of 65536 bytes');
+            }
+            return [2 /*return*/, new Promise(function (resolve, reject) {
+                    (0, node_crypto_1.randomBytes)(length, function (err, buf) {
+                        if (err) {
+                            reject(err);
+                            return;
+                        }
+                        resolve(new Uint8Array(buf));
+                    });
+                })];
+        });
+    });
+}
+exports.getRandomValues = getRandomValues;