oak-domain 1.1.13 → 2.0.1

package/lib/triggers/modi.js

@@ -16,7 +16,7 @@ var triggers = [
                     switch (_c.label) {
                         case 0:
                             filter = operation.filter;
-                            return [4 /*yield*/, context.rowStore.select('modi', {
+                            return [4 /*yield*/, context.select('modi', {
                                     data: {
                                         id: 1,
                                         action: 1,
@@ -25,9 +25,9 @@ var triggers = [
                                         targetEntity: 1,
                                     },
                                     filter: filter,
-                                }, context, option)];
+                                }, option)];
                         case 1:
-                            modies = (_c.sent()).result;
+                            modies = _c.sent();
                             _c.label = 2;
                         case 2:
                             _c.trys.push([2, 7, 8, 9]);
@@ -37,12 +37,12 @@ var triggers = [
                             if (!!modies_1_1.done) return [3 /*break*/, 6];
                             modi = modies_1_1.value;
                             targetEntity = modi.targetEntity, id = modi.id, action = modi.action, data = modi.data, filter_1 = modi.filter;
-                            return [4 /*yield*/, context.rowStore.operate(targetEntity, {
+                            return [4 /*yield*/, context.operate(targetEntity, {
                                     id: id,
                                     action: action,
                                     data: data,
                                     filter: filter_1,
-                                }, context, Object.assign({}, option, {
+                                }, Object.assign({}, option, {
                                     blockTrigger: true,
                                 }))];
                         case 4:

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(): Promise<string | undefined>;
-    getHeader(key: string): string | string[] | undefined;
+    getCurrentUserId(allowUnloggedIn?: boolean): string | undefined;
+    isRoot(): boolean;
+    toString(): string;
 }

package/lib/types/DataType.d.ts

@@ -11,6 +11,7 @@ export declare type Datetime = number | Date;
 export declare type Boolean = boolean;
 export declare type PrimaryKey = string;
 export declare type ForeignKey<E extends string> = string;
+export declare type Sequence = string;
 export { Geo, SingleGeo } from './Geo';
 export declare type DataTypes = number | string | Datetime | Geo | Object | SingleGeo;
 export declare const types: string[];

package/lib/types/Entity.d.ts

@@ -1,10 +1,22 @@
 import { GenericAction } from '../actions/action';
-import { ExpressionKey, ExprOp, MakeFilter, NodeId } from './Demand';
-import { OneOf, OptionalKeys } from './Polyfill';
-export declare type TriggerDataAttribute = '$$triggerData$$';
-export declare type TriggerTimestampAttribute = '$$triggerTimestamp$$';
-declare type PrimaryKeyAttribute = 'id';
-export declare type InstinctiveAttributes = PrimaryKeyAttribute | '$$createAt$$' | '$$updateAt$$' | '$$deleteAt$$' | TriggerDataAttribute | TriggerTimestampAttribute;
+import { ExprOp, MakeFilter, NodeId } from './Demand';
+import { OneOf } from './Polyfill';
+import { PrimaryKey, Sequence } from './DataType';
+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;
@@ -23,6 +35,7 @@ export declare type OperateOption = {
     blockTrigger?: true;
     dontCollect?: boolean;
     dontCreateOper?: boolean;
+    dontCreateModi?: boolean;
     allowExists?: boolean;
     modiParentId?: string;
     modiParentEntity?: string;
@@ -35,14 +48,15 @@ export declare type FormCreateData<SH extends GeneralEntityShape> = Omit<SH, Ins
     id: string;
 };
 export declare type Operation<A extends GenericAction | string, DATA extends Object, FILTER extends Object | undefined = undefined, SORTER extends Object | undefined = undefined> = {
-    id: string;
+    id?: string;
     action: A;
     data: DATA;
     sorter?: SORTER;
 } & Filter<A, FILTER>;
-export declare type Selection<DATA extends Object, FILTER extends Object | undefined = undefined, SORT extends Object | undefined = undefined> = Omit<Operation<'select', DATA, FILTER, SORT>, 'id'>;
+export declare type Selection<DATA extends Object, FILTER extends Object | undefined = undefined, SORT extends Object | undefined = undefined> = Operation<'select', DATA, FILTER, SORT>;
 export interface EntityShape {
-    id: string;
+    id: PrimaryKey;
+    $$seq$$: Sequence;
     $$createAt$$: number | Date;
     $$updateAt$$: number | Date;
     $$deleteAt$$?: number | Date | null;
@@ -75,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>;
@@ -106,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;
@@ -137,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$$'];
+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.d.ts

@@ -38,7 +38,9 @@ export declare class OakRowInconsistencyException<ED extends EntityDict> extends
  */
 export declare class OakInputIllegalException extends OakUserException {
     private attributes;
-    constructor(attributes: string[], message?: string);
+    private entity;
+    constructor(entity: string, attributes: string[], message?: string);
+    getEntity(): string;
     getAttributes(): string[];
     addAttributesPrefix(prefix: string): void;
     toString(): string;
@@ -71,6 +73,9 @@ export declare class OakCongruentRowExists<ED extends EntityDict, T extends keyo
     getEntity(): T;
     toString(): string;
 }
+export declare class OakDeadlock extends OakUserException {
+    constructor(message?: string | undefined);
+}
 export declare function makeException(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.OakCongruentRowExists = exports.OakRowLockedException = exports.OakUnloggedInException = exports.OakUserUnpermittedException = exports.OakInputIllegalException = exports.OakRowInconsistencyException = exports.OakUserException = exports.OakExternalException = exports.OakRowUnexistedException = exports.OakOperExistedException = exports.OakDataException = exports.OakException = void 0;
+exports.makeException = exports.OakDeadlock = exports.OakCongruentRowExists = exports.OakRowLockedException = exports.OakUnloggedInException = exports.OakUserUnpermittedException = exports.OakInputIllegalException = exports.OakRowInconsistencyException = exports.OakUserException = exports.OakExternalException = exports.OakRowUnexistedException = exports.OakOperExistedException = exports.OakDataException = exports.OakException = void 0;
 var tslib_1 = require("tslib");
 var OakException = /** @class */ (function (_super) {
     tslib_1.__extends(OakException, _super);
@@ -109,11 +109,15 @@ exports.OakRowInconsistencyException = OakRowInconsistencyException;
  */
 var OakInputIllegalException = /** @class */ (function (_super) {
     tslib_1.__extends(OakInputIllegalException, _super);
-    function OakInputIllegalException(attributes, message) {
+    function OakInputIllegalException(entity, attributes, message) {
         var _this = _super.call(this, message) || this;
+        _this.entity = entity;
         _this.attributes = attributes;
         return _this;
     }
+    OakInputIllegalException.prototype.getEntity = function () {
+        return this.entity;
+    };
     OakInputIllegalException.prototype.getAttributes = function () {
         return this.attributes;
     };
@@ -122,6 +126,7 @@ var OakInputIllegalException = /** @class */ (function (_super) {
     };
     OakInputIllegalException.prototype.toString = function () {
         return JSON.stringify({
+            entity: this.entity,
             name: this.constructor.name,
             message: this.message,
             attributes: this.attributes,
@@ -195,39 +200,51 @@ var OakCongruentRowExists = /** @class */ (function (_super) {
     return OakCongruentRowExists;
 }(OakUserException));
 exports.OakCongruentRowExists = OakCongruentRowExists;
+var OakDeadlock = /** @class */ (function (_super) {
+    tslib_1.__extends(OakDeadlock, _super);
+    function OakDeadlock(message) {
+        return _super.call(this, message || '发现死锁') || this;
+    }
+    return OakDeadlock;
+}(OakUserException));
+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: {
-            return new OakInputIllegalException(data.attributes, data.message);
+        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': {
+            return new OakDeadlock(data.message);
+        }
         default:
             return;
     }

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/Storage.d.ts

@@ -25,6 +25,7 @@ export interface Attribute {
     default?: string | number | boolean;
     notNull?: boolean;
     unique?: boolean;
+    sequenceStart?: number;
 }
 export declare type Attributes<SH extends EntityShape> = Omit<{
     [attrName in keyof SH]: Attribute;

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