oak-domain 4.2.2 → 4.2.4

package/lib/entities/Oper.d.ts

@@ -1,12 +1,12 @@
-import { String, Datetime } from '../types/DataType';
-import { EntityShape } from '../types/Entity';
-import { Schema as User } from './User';
-export interface Schema extends EntityShape {
-    action: String<16>;
-    data: Object;
-    filter?: Object;
-    extra?: Object;
-    operator?: User;
-    targetEntity: String<32>;
-    bornAt: Datetime;
-}
+import { String, Datetime } from '../types/DataType';
+import { EntityShape } from '../types/Entity';
+import { Schema as User } from './User';
+export interface Schema extends EntityShape {
+    action: String<16>;
+    data: Object;
+    filter?: Object;
+    extra?: Object;
+    operator?: User;
+    targetEntity: String<32>;
+    bornAt: Datetime;
+}

package/lib/entities/Oper.js

@@ -1,36 +1,36 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-;
-const entityDesc = {
-    locales: {
-        zh_CN: {
-            name: '操作',
-            attr: {
-                action: '动作',
-                data: '数据',
-                filter: '选择条件',
-                extra: '其它',
-                operator: '操作者',
-                targetEntity: '关联对象',
-                bornAt: '诞生时间'
-            },
-        },
-    },
-    configuration: {
-        actionType: 'appendOnly',
-    },
-    indexes: [
-        {
-            name: 'index_bornAt_operatorId',
-            attributes: [
-                {
-                    name: 'bornAt',
-                    direction: 'DESC',
-                },
-                {
-                    name: 'operator',
-                },
-            ]
-        }
-    ]
-};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+;
+const entityDesc = {
+    locales: {
+        zh_CN: {
+            name: '操作',
+            attr: {
+                action: '动作',
+                data: '数据',
+                filter: '选择条件',
+                extra: '其它',
+                operator: '操作者',
+                targetEntity: '关联对象',
+                bornAt: '诞生时间'
+            },
+        },
+    },
+    configuration: {
+        actionType: 'appendOnly',
+    },
+    indexes: [
+        {
+            name: 'index_bornAt_operatorId',
+            attributes: [
+                {
+                    name: 'bornAt',
+                    direction: 'DESC',
+                },
+                {
+                    name: 'operator',
+                },
+            ]
+        }
+    ]
+};

package/lib/entities/User.d.ts

@@ -1,18 +1,18 @@
-import { String, Text } from '../types/DataType';
-import { EntityShape } from '../types/Entity';
-import { ActionDef } from '../types/Action';
-import { EntityDesc } from '../types/EntityDesc';
-export interface Schema extends EntityShape {
-    name?: String<16>;
-    nickname?: String<64>;
-    password?: Text;
-    ref?: Schema;
-}
-type UserAction = 'mergeTo';
-type UserState = 'normal' | 'merged';
-export type Action = UserAction;
-export declare const UserActionDef: ActionDef<UserAction, UserState>;
-export declare const entityDesc: EntityDesc<Schema, Action, '', {
-    userState: UserState;
-}>;
-export {};
+import { String, Text } from '../types/DataType';
+import { EntityShape } from '../types/Entity';
+import { ActionDef } from '../types/Action';
+import { EntityDesc } from '../types/EntityDesc';
+export interface Schema extends EntityShape {
+    name?: String<16>;
+    nickname?: String<64>;
+    password?: Text;
+    ref?: Schema;
+}
+type UserAction = 'mergeTo';
+type UserState = 'normal' | 'merged';
+export type Action = UserAction;
+export declare const UserActionDef: ActionDef<UserAction, UserState>;
+export declare const entityDesc: EntityDesc<Schema, Action, '', {
+    userState: UserState;
+}>;
+export {};

package/lib/entities/User.js

@@ -1,32 +1,32 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.entityDesc = exports.UserActionDef = void 0;
-;
-exports.UserActionDef = {
-    stm: {
-        mergeTo: ['normal', 'merged'],
-    },
-};
-exports.entityDesc = {
-    locales: {
-        zh_CN: {
-            name: '用户',
-            attr: {
-                name: '姓名',
-                nickname: '昵称',
-                password: '密码',
-                ref: '指向用户',
-                userState: '状态',
-            },
-            action: {
-                mergeTo: '合并',
-            },
-            v: {
-                userState: {
-                    normal: '正常',
-                    merged: '已被合并',
-                },
-            }
-        },
-    },
-};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.entityDesc = exports.UserActionDef = void 0;
+;
+exports.UserActionDef = {
+    stm: {
+        mergeTo: ['normal', 'merged'],
+    },
+};
+exports.entityDesc = {
+    locales: {
+        zh_CN: {
+            name: '用户',
+            attr: {
+                name: '姓名',
+                nickname: '昵称',
+                password: '密码',
+                ref: '指向用户',
+                userState: '状态',
+            },
+            action: {
+                mergeTo: '合并',
+            },
+            v: {
+                userState: {
+                    normal: '正常',
+                    merged: '已被合并',
+                },
+            }
+        },
+    },
+};

package/lib/index.d.ts

@@ -1 +1 @@
-export type { EntityDict as BaseEntityDict } from './base-app-domain';
+export type { EntityDict as BaseEntityDict } from './base-app-domain';

package/lib/index.js

@@ -1,3 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-// export * from './types';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// export * from './types';

package/lib/store/AsyncRowStore.d.ts

@@ -1,66 +1,66 @@
-/// <reference types="node" />
-import { EntityDict, RowStore, OperateOption, OperationResult, SelectOption, Context, TxnOption, OpRecord, AggregationResult, ClusterInfo } from "../types";
-import { IncomingHttpHeaders } from "http";
-/**
- * 服务器端执行的异步环境的底层抽象
- */
-export declare abstract class AsyncContext<ED extends EntityDict> implements Context {
-    rowStore: AsyncRowStore<ED, this>;
-    private uuid?;
-    opRecords: OpRecord<ED>[];
-    private scene?;
-    headers?: IncomingHttpHeaders;
-    clusterInfo?: ClusterInfo;
-    opResult: OperationResult<ED>;
-    private message?;
-    events: {
-        commit: Array<() => Promise<void>>;
-        rollback: Array<() => Promise<void>>;
-    };
-    /**
-     * 在返回结果前调用，对数据行进行一些预处理，比如将一些敏感的列隐藏
-     */
-    abstract refineOpRecords(): Promise<void>;
-    constructor(store: AsyncRowStore<ED, AsyncContext<ED>>);
-    restartToExecute(routine: (context: this) => Promise<any>): Promise<void>;
-    getHeader(key: string): string | string[] | undefined;
-    getScene(): string | undefined;
-    setScene(scene?: string): void;
-    private resetEvents;
-    on(event: 'commit' | 'rollback', callback: () => Promise<void>): void;
-    saveOpRecord<T extends keyof ED>(entity: T, operation: ED[T]['Operation']): void;
-    /**
-     * 一个context中不应该有并发的事务，这里将事务串行化，使用的时候千万要注意不要自己等自己
-     * @param options
-     */
-    begin(options?: TxnOption): Promise<void>;
-    commit(): Promise<void>;
-    rollback(): Promise<void>;
-    operate<T extends keyof ED, OP extends OperateOption>(entity: T, operation: ED[T]['Operation'], option: OP): Promise<OperationResult<ED>>;
-    select<T extends keyof ED, OP extends SelectOption>(entity: T, selection: ED[T]['Selection'], option: OP): Promise<Partial<ED[T]["Schema"]>[]>;
-    aggregate<T extends keyof ED, OP extends SelectOption>(entity: T, aggregation: ED[T]['Aggregation'], option: OP): Promise<AggregationResult<ED[T]["Schema"]>>;
-    count<T extends keyof ED, OP extends SelectOption>(entity: T, selection: Pick<ED[T]['Selection'], 'filter' | 'count'>, option: OP): Promise<number>;
-    exec(script: string, txnId?: string): Promise<void>;
-    mergeMultipleResults(toBeMerged: OperationResult<ED>[]): OperationResult<ED>;
-    getCurrentTxnId(): string | undefined;
-    getSchema(): import("../types").StorageSchema<ED>;
-    setMessage(message: string): void;
-    getMessage(): string | undefined;
-    abstract isRoot(): boolean;
-    abstract getCurrentUserId(allowUnloggedIn?: boolean): string | undefined;
-    abstract setCurrentUserId(userId: string | undefined): void;
-    abstract toString(): Promise<string>;
-    abstract initialize(data: any): Promise<void>;
-    abstract allowUserUpdate(): boolean;
-    abstract openRootMode(): () => void;
-}
-export interface AsyncRowStore<ED extends EntityDict, Cxt extends AsyncContext<ED>> extends RowStore<ED> {
-    operate<T extends keyof ED, OP extends OperateOption>(entity: T, operation: ED[T]['Operation'], context: Cxt, option: OP): Promise<OperationResult<ED>>;
-    select<T extends keyof ED, OP extends SelectOption>(entity: T, selection: ED[T]['Selection'], context: Cxt, option: OP): Promise<Partial<ED[T]['Schema']>[]>;
-    aggregate<T extends keyof ED, OP extends SelectOption>(entity: T, aggregation: ED[T]['Aggregation'], context: Cxt, option: OP): Promise<AggregationResult<ED[T]['Schema']>>;
-    count<T extends keyof ED, OP extends SelectOption>(entity: T, selection: Pick<ED[T]['Selection'], 'filter' | 'count'>, context: Cxt, option: OP): Promise<number>;
-    begin(option?: TxnOption): Promise<string>;
-    commit(txnId: string): Promise<void>;
-    rollback(txnId: string): Promise<void>;
-    exec(script: string, txnId?: string): Promise<void>;
-}
+/// <reference types="node" />
+import { EntityDict, RowStore, OperateOption, OperationResult, SelectOption, Context, TxnOption, OpRecord, AggregationResult, ClusterInfo } from "../types";
+import { IncomingHttpHeaders } from "http";
+/**
+ * 服务器端执行的异步环境的底层抽象
+ */
+export declare abstract class AsyncContext<ED extends EntityDict> implements Context {
+    rowStore: AsyncRowStore<ED, this>;
+    private uuid?;
+    opRecords: OpRecord<ED>[];
+    private scene?;
+    headers?: IncomingHttpHeaders;
+    clusterInfo?: ClusterInfo;
+    opResult: OperationResult<ED>;
+    private message?;
+    events: {
+        commit: Array<() => Promise<void>>;
+        rollback: Array<() => Promise<void>>;
+    };
+    /**
+     * 在返回结果前调用，对数据行进行一些预处理，比如将一些敏感的列隐藏
+     */
+    abstract refineOpRecords(): Promise<void>;
+    constructor(store: AsyncRowStore<ED, AsyncContext<ED>>);
+    restartToExecute(routine: (context: this) => Promise<any>): Promise<void>;
+    getHeader(key: string): string | string[] | undefined;
+    getScene(): string | undefined;
+    setScene(scene?: string): void;
+    private resetEvents;
+    on(event: 'commit' | 'rollback', callback: () => Promise<void>): void;
+    saveOpRecord<T extends keyof ED>(entity: T, operation: ED[T]['Operation']): void;
+    /**
+     * 一个context中不应该有并发的事务，这里将事务串行化，使用的时候千万要注意不要自己等自己
+     * @param options
+     */
+    begin(options?: TxnOption): Promise<void>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    operate<T extends keyof ED, OP extends OperateOption>(entity: T, operation: ED[T]['Operation'], option: OP): Promise<OperationResult<ED>>;
+    select<T extends keyof ED, OP extends SelectOption>(entity: T, selection: ED[T]['Selection'], option: OP): Promise<Partial<ED[T]["Schema"]>[]>;
+    aggregate<T extends keyof ED, OP extends SelectOption>(entity: T, aggregation: ED[T]['Aggregation'], option: OP): Promise<AggregationResult<ED[T]["Schema"]>>;
+    count<T extends keyof ED, OP extends SelectOption>(entity: T, selection: Pick<ED[T]['Selection'], 'filter' | 'count'>, option: OP): Promise<number>;
+    exec(script: string, txnId?: string): Promise<void>;
+    mergeMultipleResults(toBeMerged: OperationResult<ED>[]): OperationResult<ED>;
+    getCurrentTxnId(): string | undefined;
+    getSchema(): import("../types").StorageSchema<ED>;
+    setMessage(message: string): void;
+    getMessage(): string | undefined;
+    abstract isRoot(): boolean;
+    abstract getCurrentUserId(allowUnloggedIn?: boolean): string | undefined;
+    abstract setCurrentUserId(userId: string | undefined): void;
+    abstract toString(): Promise<string>;
+    abstract initialize(data: any, later?: boolean): Promise<void>;
+    abstract allowUserUpdate(): boolean;
+    abstract openRootMode(): () => void;
+}
+export interface AsyncRowStore<ED extends EntityDict, Cxt extends AsyncContext<ED>> extends RowStore<ED> {
+    operate<T extends keyof ED, OP extends OperateOption>(entity: T, operation: ED[T]['Operation'], context: Cxt, option: OP): Promise<OperationResult<ED>>;
+    select<T extends keyof ED, OP extends SelectOption>(entity: T, selection: ED[T]['Selection'], context: Cxt, option: OP): Promise<Partial<ED[T]['Schema']>[]>;
+    aggregate<T extends keyof ED, OP extends SelectOption>(entity: T, aggregation: ED[T]['Aggregation'], context: Cxt, option: OP): Promise<AggregationResult<ED[T]['Schema']>>;
+    count<T extends keyof ED, OP extends SelectOption>(entity: T, selection: Pick<ED[T]['Selection'], 'filter' | 'count'>, context: Cxt, option: OP): Promise<number>;
+    begin(option?: TxnOption): Promise<string>;
+    commit(txnId: string): Promise<void>;
+    rollback(txnId: string): Promise<void>;
+    exec(script: string, txnId?: string): Promise<void>;
+}

package/lib/store/CascadeStore.d.ts

@@ -1,109 +1,109 @@
-import { EntityDict, OperateOption, SelectOption, OperationResult, AggregationResult } from "../types/Entity";
-import { EntityDict as BaseEntityDict } from '../base-app-domain';
-import { OperationRewriter, RowStore, SelectionRewriter } from '../types/RowStore';
-import { StorageSchema } from '../types/Storage';
-import { SyncContext } from "./SyncRowStore";
-import { AsyncContext } from "./AsyncRowStore";
-/**这个用来处理级联的select和update，对不同能力的 */
-export declare abstract class CascadeStore<ED extends EntityDict & BaseEntityDict> extends RowStore<ED> {
-    constructor(storageSchema: StorageSchema<ED>);
-    protected abstract supportManyToOneJoin(): boolean;
-    protected abstract supportMultipleCreate(): boolean;
-    private selectionRewriters;
-    private operationRewriters;
-    private reinforceSelectionAsync;
-    private reinforceSelectionSync;
-    private reinforceSelectionInner;
-    private reinforceOperation;
-    registerOperationRewriter(rewriter: OperationRewriter<ED, AsyncContext<ED> | SyncContext<ED>, OperateOption>): void;
-    registerSelectionRewriter(rewriter: SelectionRewriter<ED, AsyncContext<ED> | SyncContext<ED>, SelectOption>): void;
-    protected abstract selectAbjointRow<T extends keyof ED, OP extends SelectOption, Cxt extends SyncContext<ED>>(entity: T, selection: ED[T]['Selection'], context: Cxt, option: OP): Partial<ED[T]['Schema']>[];
-    protected abstract countAbjointRow<T extends keyof ED, OP extends SelectOption, Cxt extends SyncContext<ED>>(entity: T, selection: Pick<ED[T]['Selection'], 'filter' | 'count'>, context: Cxt, option: OP): number;
-    protected abstract countAbjointRowAsync<T extends keyof ED, OP extends SelectOption, Cxt extends AsyncContext<ED>>(entity: T, selection: Pick<ED[T]['Selection'], 'filter' | 'count'>, context: Cxt, option: OP): Promise<number>;
-    protected abstract updateAbjointRow<T extends keyof ED, OP extends OperateOption, Cxt extends SyncContext<ED>>(entity: T, operation: ED[T]['Operation'], context: Cxt, option: OP): number;
-    protected abstract selectAbjointRowAsync<T extends keyof ED, OP extends SelectOption, Cxt extends AsyncContext<ED>>(entity: T, selection: ED[T]['Selection'], context: Cxt, option: OP): Promise<Partial<ED[T]['Schema']>[]>;
-    protected abstract updateAbjointRowAsync<T extends keyof ED, OP extends OperateOption, Cxt extends AsyncContext<ED>>(entity: T, operation: ED[T]['Create'] | ED[T]['Update'] | ED[T]['Remove'], context: Cxt, option: OP): Promise<number>;
-    protected abstract aggregateAbjointRowSync<T extends keyof ED, OP extends SelectOption, Cxt extends SyncContext<ED>>(entity: T, aggregation: ED[T]['Aggregation'], context: Cxt, option: OP): AggregationResult<ED[T]['Schema']>;
-    protected abstract aggregateAbjointRowAsync<T extends keyof ED, OP extends SelectOption, Cxt extends AsyncContext<ED>>(entity: T, aggregation: ED[T]['Aggregation'], context: Cxt, option: OP): Promise<AggregationResult<ED[T]['Schema']>>;
-    protected destructCascadeSelect<T extends keyof ED, OP extends SelectOption, Cxt extends SyncContext<ED> | AsyncContext<ED>>(entity: T, projection2: ED[T]['Selection']['data'], context: Cxt, cascadeSelectFn: <T2 extends keyof ED>(entity2: T2, selection: ED[T2]['Selection'], context: Cxt, op: OP) => Partial<ED[T2]['Schema']>[] | Promise<Partial<ED[T2]['Schema']>[]>, aggregateFn: <T2 extends keyof ED>(entity2: T2, aggregation: ED[T2]['Aggregation'], context: Cxt, op: OP) => AggregationResult<ED[T2]['Schema']> | Promise<AggregationResult<ED[T2]['Schema']>>, option: OP): {
-        projection: ED[T]["Selection"]["data"];
-        cascadeSelectionFns: ((result: Partial<ED[T]['Schema']>[]) => Promise<void> | void)[];
-    };
-    /**
-     * 级联更新
-     * A --> B
-        多对一：A CREATE／B CREATE，B data的主键赋到A的data上
-            A CREATE／B UPDATE，B filter的主键来自A的data
-            A UPDATE／B CREATE，B data的主键赋到A的data上
-            A UPDATE／B UPDATE，B filter的主键来自A的row
-            A UPDATE／B REMOVE，B filter的主键来自A的row
-            A REMOVE／B UPDATE，B filter的主键来自A的row
-            A REMOVE／B REMOVE，B filter的主键来自A的row
-
-        一对多：A CREATE／B CREATE，A data上的主键赋到B的data上
-            A CREATE／B UPDATE，A data上的主键赋到B的data上
-            A UPDATE／B CREATE，A filter上的主键赋到B的data上（一定是带主键的filter）
-            A UPDATE／B UPDATE，A filter上的主键赋到B的filter上（一定是带主键的filter）
-            A UPDATE／B REMOVE，A filter上的主键赋到B的filter上（一定是带主键的filter）
-            A REMOVE／B UPDATE，A filter上的主键赋到B的filter上（且B关于A的外键清空）
-            A REMOVE／B REMOVE，A filter上的主键赋到B的filter上
-     *
-     * 延时更新，
-     *  A（业务级别的申请对象） ---> B（业务级别需要更新的对象）
-     * 两者必须通过entity/entityId关联
-     * 此时需要把对B的更新记录成一条新插入的Modi对象，并将A上的entity/entityId指向该对象（新生成的Modi对象的id与此operation的id保持一致）
-     * @param entity
-     * @param action
-     * @param data
-     * @param context
-     * @param option
-     * @param result
-     * @param filter
-     * @returns
-     */
-    protected destructCascadeUpdate<T extends keyof ED, Cxt extends SyncContext<ED> | AsyncContext<ED>, OP extends OperateOption, R>(entity: T, action: ED[T]['Action'], data: ED[T]['CreateSingle']['data'] | ED[T]['Update']['data'] | ED[T]['Remove']['data'], context: Cxt, option: OP, cascadeUpdate: <T2 extends keyof ED>(entity: T2, operation: ED[T2]['Operation'], context: Cxt, option: OP) => R, filter?: ED[T]['Update']['filter'], bornAt?: number): {
-        data: Record<string, any>;
-        beforeFns: (() => R)[];
-        afterFns: (() => R)[];
-    };
-    protected preProcessDataCreated<T extends keyof ED>(entity: T, data: ED[T]['Create']['data']): void;
-    protected preProcessDataUpdated(data: Record<string, any>): void;
-    judgeRelation(entity: keyof ED, attr: string): string | 1 | 2 | string[] | 0 | -1;
-    /**
-     * 和具体的update过程无关的例程放在这里，包括对later动作的处理、对oper的记录以及对record的收集等
-     * @param entity
-     * @param operation
-     * @param context
-     * @param option
-     */
-    private doUpdateSingleRowAsync;
-    private doUpdateSingleRow;
-    protected cascadeUpdate<T extends keyof ED, Cxt extends SyncContext<ED>, OP extends OperateOption>(entity: T, operation: ED[T]['Operation'], context: Cxt, option: OP): OperationResult<ED>;
-    /**
-     *
-     * @param entity
-     * @param operation
-     * @param context
-     * @param option
-     */
-    protected cascadeUpdateAsync<T extends keyof ED, Cxt extends AsyncContext<ED>, OP extends OperateOption>(entity: T, operation: ED[T]['Operation'], context: Cxt, option: OP): Promise<OperationResult<ED>>;
-    protected cascadeSelect<T extends keyof ED, OP extends SelectOption, Cxt extends SyncContext<ED>>(entity: T, selection: ED[T]['Selection'], context: Cxt, option: OP): Partial<ED[T]['Schema']>[];
-    /**
-     * 将一次查询的结果集加入result
-     * todo 如果是supportMtoOJoin，这里还要解构（未充分测试）
-     * @param entity
-     * @param rows
-     * @param context
-     */
-    private addToResultSelections;
-    private addSingleRowToResultSelections;
-    protected cascadeSelectAsync<T extends keyof ED, OP extends SelectOption, Cxt extends AsyncContext<ED>>(entity: T, selection: ED[T]['Selection'], context: Cxt, option: OP): Promise<Partial<ED[T]['Schema']>[]>;
-    protected aggregateAsync<T extends keyof ED, OP extends SelectOption, Cxt extends AsyncContext<ED>>(entity: T, aggregation: ED[T]['Aggregation'], context: Cxt, option: OP): Promise<AggregationResult<ED[T]['Schema']>>;
-    protected aggregateSync<T extends keyof ED, OP extends SelectOption, Cxt extends SyncContext<ED>>(entity: T, aggregation: ED[T]['Aggregation'], context: Cxt, option: OP): AggregationResult<ED[T]['Schema']>;
-    protected selectAsync<T extends keyof ED, OP extends SelectOption, Cxt extends AsyncContext<ED>>(entity: T, selection: ED[T]['Selection'], context: Cxt, option: OP): Promise<Partial<ED[T]['Schema']>[]>;
-    protected selectSync<T extends keyof ED, OP extends SelectOption, Cxt extends SyncContext<ED>>(entity: T, selection: ED[T]['Selection'], context: Cxt, option: OP): Partial<ED[T]['Schema']>[];
-    protected operateSync<T extends keyof ED, Cxt extends SyncContext<ED>, OP extends OperateOption>(entity: T, operation: ED[T]['Operation'], context: Cxt, option: OP): OperationResult<ED>;
-    protected operateAsync<T extends keyof ED, Cxt extends AsyncContext<ED>, OP extends OperateOption>(entity: T, operation: ED[T]['Operation'], context: Cxt, option: OP): Promise<OperationResult<ED>>;
-    protected countSync<T extends keyof ED, OP extends SelectOption, Cxt extends SyncContext<ED>>(entity: T, selection: Pick<ED[T]['Selection'], 'filter' | 'count'>, context: Cxt, option: OP): number;
-    protected countAsync<T extends keyof ED, OP extends SelectOption, Cxt extends AsyncContext<ED>>(entity: T, selection: Pick<ED[T]['Selection'], 'filter' | 'count'>, context: Cxt, option: OP): Promise<number>;
-}
+import { EntityDict, OperateOption, SelectOption, OperationResult, AggregationResult } from "../types/Entity";
+import { EntityDict as BaseEntityDict } from '../base-app-domain';
+import { OperationRewriter, RowStore, SelectionRewriter } from '../types/RowStore';
+import { StorageSchema } from '../types/Storage';
+import { SyncContext } from "./SyncRowStore";
+import { AsyncContext } from "./AsyncRowStore";
+/**这个用来处理级联的select和update，对不同能力的 */
+export declare abstract class CascadeStore<ED extends EntityDict & BaseEntityDict> extends RowStore<ED> {
+    constructor(storageSchema: StorageSchema<ED>);
+    protected abstract supportManyToOneJoin(): boolean;
+    protected abstract supportMultipleCreate(): boolean;
+    private selectionRewriters;
+    private operationRewriters;
+    private reinforceSelectionAsync;
+    private reinforceSelectionSync;
+    private reinforceSelectionInner;
+    private reinforceOperation;
+    registerOperationRewriter(rewriter: OperationRewriter<ED, AsyncContext<ED> | SyncContext<ED>, OperateOption>): void;
+    registerSelectionRewriter(rewriter: SelectionRewriter<ED, AsyncContext<ED> | SyncContext<ED>, SelectOption>): void;
+    protected abstract selectAbjointRow<T extends keyof ED, OP extends SelectOption, Cxt extends SyncContext<ED>>(entity: T, selection: ED[T]['Selection'], context: Cxt, option: OP): Partial<ED[T]['Schema']>[];
+    protected abstract countAbjointRow<T extends keyof ED, OP extends SelectOption, Cxt extends SyncContext<ED>>(entity: T, selection: Pick<ED[T]['Selection'], 'filter' | 'count'>, context: Cxt, option: OP): number;
+    protected abstract countAbjointRowAsync<T extends keyof ED, OP extends SelectOption, Cxt extends AsyncContext<ED>>(entity: T, selection: Pick<ED[T]['Selection'], 'filter' | 'count'>, context: Cxt, option: OP): Promise<number>;
+    protected abstract updateAbjointRow<T extends keyof ED, OP extends OperateOption, Cxt extends SyncContext<ED>>(entity: T, operation: ED[T]['Operation'], context: Cxt, option: OP): number;
+    protected abstract selectAbjointRowAsync<T extends keyof ED, OP extends SelectOption, Cxt extends AsyncContext<ED>>(entity: T, selection: ED[T]['Selection'], context: Cxt, option: OP): Promise<Partial<ED[T]['Schema']>[]>;
+    protected abstract updateAbjointRowAsync<T extends keyof ED, OP extends OperateOption, Cxt extends AsyncContext<ED>>(entity: T, operation: ED[T]['Create'] | ED[T]['Update'] | ED[T]['Remove'], context: Cxt, option: OP): Promise<number>;
+    protected abstract aggregateAbjointRowSync<T extends keyof ED, OP extends SelectOption, Cxt extends SyncContext<ED>>(entity: T, aggregation: ED[T]['Aggregation'], context: Cxt, option: OP): AggregationResult<ED[T]['Schema']>;
+    protected abstract aggregateAbjointRowAsync<T extends keyof ED, OP extends SelectOption, Cxt extends AsyncContext<ED>>(entity: T, aggregation: ED[T]['Aggregation'], context: Cxt, option: OP): Promise<AggregationResult<ED[T]['Schema']>>;
+    protected destructCascadeSelect<T extends keyof ED, OP extends SelectOption, Cxt extends SyncContext<ED> | AsyncContext<ED>>(entity: T, projection2: ED[T]['Selection']['data'], context: Cxt, cascadeSelectFn: <T2 extends keyof ED>(entity2: T2, selection: ED[T2]['Selection'], context: Cxt, op: OP) => Partial<ED[T2]['Schema']>[] | Promise<Partial<ED[T2]['Schema']>[]>, aggregateFn: <T2 extends keyof ED>(entity2: T2, aggregation: ED[T2]['Aggregation'], context: Cxt, op: OP) => AggregationResult<ED[T2]['Schema']> | Promise<AggregationResult<ED[T2]['Schema']>>, option: OP): {
+        projection: ED[T]["Selection"]["data"];
+        cascadeSelectionFns: ((result: Partial<ED[T]['Schema']>[]) => Promise<void> | void)[];
+    };
+    /**
+     * 级联更新
+     * A --> B
+        多对一：A CREATE／B CREATE，B data的主键赋到A的data上
+            A CREATE／B UPDATE，B filter的主键来自A的data
+            A UPDATE／B CREATE，B data的主键赋到A的data上
+            A UPDATE／B UPDATE，B filter的主键来自A的row
+            A UPDATE／B REMOVE，B filter的主键来自A的row
+            A REMOVE／B UPDATE，B filter的主键来自A的row
+            A REMOVE／B REMOVE，B filter的主键来自A的row
+
+        一对多：A CREATE／B CREATE，A data上的主键赋到B的data上
+            A CREATE／B UPDATE，A data上的主键赋到B的data上
+            A UPDATE／B CREATE，A filter上的主键赋到B的data上（一定是带主键的filter）
+            A UPDATE／B UPDATE，A filter上的主键赋到B的filter上（一定是带主键的filter）
+            A UPDATE／B REMOVE，A filter上的主键赋到B的filter上（一定是带主键的filter）
+            A REMOVE／B UPDATE，A filter上的主键赋到B的filter上（且B关于A的外键清空）
+            A REMOVE／B REMOVE，A filter上的主键赋到B的filter上
+     *
+     * 延时更新，
+     *  A（业务级别的申请对象） ---> B（业务级别需要更新的对象）
+     * 两者必须通过entity/entityId关联
+     * 此时需要把对B的更新记录成一条新插入的Modi对象，并将A上的entity/entityId指向该对象（新生成的Modi对象的id与此operation的id保持一致）
+     * @param entity
+     * @param action
+     * @param data
+     * @param context
+     * @param option
+     * @param result
+     * @param filter
+     * @returns
+     */
+    protected destructCascadeUpdate<T extends keyof ED, Cxt extends SyncContext<ED> | AsyncContext<ED>, OP extends OperateOption, R>(entity: T, action: ED[T]['Action'], data: ED[T]['CreateSingle']['data'] | ED[T]['Update']['data'] | ED[T]['Remove']['data'], context: Cxt, option: OP, cascadeUpdate: <T2 extends keyof ED>(entity: T2, operation: ED[T2]['Operation'], context: Cxt, option: OP) => R, filter?: ED[T]['Update']['filter'], bornAt?: number): {
+        data: Record<string, any>;
+        beforeFns: (() => R)[];
+        afterFns: (() => R)[];
+    };
+    protected preProcessDataCreated<T extends keyof ED>(entity: T, data: ED[T]['Create']['data']): void;
+    protected preProcessDataUpdated(data: Record<string, any>): void;
+    judgeRelation(entity: keyof ED, attr: string): string | 1 | 2 | string[] | 0 | -1;
+    /**
+     * 和具体的update过程无关的例程放在这里，包括对later动作的处理、对oper的记录以及对record的收集等
+     * @param entity
+     * @param operation
+     * @param context
+     * @param option
+     */
+    private doUpdateSingleRowAsync;
+    private doUpdateSingleRow;
+    protected cascadeUpdate<T extends keyof ED, Cxt extends SyncContext<ED>, OP extends OperateOption>(entity: T, operation: ED[T]['Operation'], context: Cxt, option: OP): OperationResult<ED>;
+    /**
+     *
+     * @param entity
+     * @param operation
+     * @param context
+     * @param option
+     */
+    protected cascadeUpdateAsync<T extends keyof ED, Cxt extends AsyncContext<ED>, OP extends OperateOption>(entity: T, operation: ED[T]['Operation'], context: Cxt, option: OP): Promise<OperationResult<ED>>;
+    protected cascadeSelect<T extends keyof ED, OP extends SelectOption, Cxt extends SyncContext<ED>>(entity: T, selection: ED[T]['Selection'], context: Cxt, option: OP): Partial<ED[T]['Schema']>[];
+    /**
+     * 将一次查询的结果集加入result
+     * todo 如果是supportMtoOJoin，这里还要解构（未充分测试）
+     * @param entity
+     * @param rows
+     * @param context
+     */
+    private addToResultSelections;
+    private addSingleRowToResultSelections;
+    protected cascadeSelectAsync<T extends keyof ED, OP extends SelectOption, Cxt extends AsyncContext<ED>>(entity: T, selection: ED[T]['Selection'], context: Cxt, option: OP): Promise<Partial<ED[T]['Schema']>[]>;
+    protected aggregateAsync<T extends keyof ED, OP extends SelectOption, Cxt extends AsyncContext<ED>>(entity: T, aggregation: ED[T]['Aggregation'], context: Cxt, option: OP): Promise<AggregationResult<ED[T]['Schema']>>;
+    protected aggregateSync<T extends keyof ED, OP extends SelectOption, Cxt extends SyncContext<ED>>(entity: T, aggregation: ED[T]['Aggregation'], context: Cxt, option: OP): AggregationResult<ED[T]['Schema']>;
+    protected selectAsync<T extends keyof ED, OP extends SelectOption, Cxt extends AsyncContext<ED>>(entity: T, selection: ED[T]['Selection'], context: Cxt, option: OP): Promise<Partial<ED[T]['Schema']>[]>;
+    protected selectSync<T extends keyof ED, OP extends SelectOption, Cxt extends SyncContext<ED>>(entity: T, selection: ED[T]['Selection'], context: Cxt, option: OP): Partial<ED[T]['Schema']>[];
+    protected operateSync<T extends keyof ED, Cxt extends SyncContext<ED>, OP extends OperateOption>(entity: T, operation: ED[T]['Operation'], context: Cxt, option: OP): OperationResult<ED>;
+    protected operateAsync<T extends keyof ED, Cxt extends AsyncContext<ED>, OP extends OperateOption>(entity: T, operation: ED[T]['Operation'], context: Cxt, option: OP): Promise<OperationResult<ED>>;
+    protected countSync<T extends keyof ED, OP extends SelectOption, Cxt extends SyncContext<ED>>(entity: T, selection: Pick<ED[T]['Selection'], 'filter' | 'count'>, context: Cxt, option: OP): number;
+    protected countAsync<T extends keyof ED, OP extends SelectOption, Cxt extends AsyncContext<ED>>(entity: T, selection: Pick<ED[T]['Selection'], 'filter' | 'count'>, context: Cxt, option: OP): Promise<number>;
+}