oak-domain 1.1.13 → 2.0.1

package/lib/compiler/schemalBuilder.js

@@ -850,19 +850,7 @@ function analyzeEntity(filename, path, program, relativePath) {
 function constructSchema(statements, entity) {
     var e_1, _a, e_2, _b;
     var schemaAttrs = Schema[entity].schemaAttrs;
-    var members = [
-        // id: String<64>
-        factory.createPropertySignature(undefined, factory.createIdentifier('id'), undefined, factory.createTypeReferenceNode(factory.createIdentifier('PrimaryKey'))),
-        // $$createAt$$: Datetime
-        factory.createPropertySignature(undefined, factory.createIdentifier('$$createAt$$'), undefined, factory.createTypeReferenceNode(factory.createIdentifier('Datetime'))),
-        // $$updateAt$$: Datetime
-        factory.createPropertySignature(undefined, factory.createIdentifier('$$updateAt$$'), undefined, factory.createTypeReferenceNode(factory.createIdentifier('Datetime'))),
-        // $$updateAt$$: Datetime
-        factory.createPropertySignature(undefined, factory.createIdentifier('$$deleteAt$$'), factory.createToken(ts.SyntaxKind.QuestionToken), factory.createUnionTypeNode([
-            factory.createTypeReferenceNode(factory.createIdentifier('Datetime')),
-            factory.createLiteralTypeNode(factory.createNull())
-        ]))
-    ];
+    var members = [];
     var members2 = [];
     var _c = ManyToOne, _d = entity, manyToOneSet = _c[_d];
     var _e = OneToMany, _f = entity, oneToManySet = _e[_f];
@@ -997,10 +985,14 @@ function constructSchema(statements, entity) {
     }
     statements.push(factory.createTypeAliasDeclaration(undefined, [
         factory.createModifier(ts.SyntaxKind.ExportKeyword)
-    ], factory.createIdentifier('OpSchema'), undefined, factory.createTypeLiteralNode(members)), factory.createTypeAliasDeclaration(undefined, [factory.createModifier(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier("OpAttr"), undefined, factory.createTypeOperatorNode(ts.SyntaxKind.KeyOfKeyword, factory.createTypeReferenceNode(factory.createIdentifier("OpSchema"), undefined))));
+    ], factory.createIdentifier('OpSchema'), undefined, factory.createIntersectionTypeNode([
+        factory.createTypeReferenceNode('EntityShape'),
+        factory.createTypeLiteralNode(members)
+    ])), factory.createTypeAliasDeclaration(undefined, [factory.createModifier(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier("OpAttr"), undefined, factory.createTypeOperatorNode(ts.SyntaxKind.KeyOfKeyword, factory.createTypeReferenceNode(factory.createIdentifier("OpSchema"), undefined))));
     statements.push(factory.createTypeAliasDeclaration(undefined, [
         factory.createModifier(ts.SyntaxKind.ExportKeyword)
     ], factory.createIdentifier('Schema'), undefined, factory.createIntersectionTypeNode([
+        factory.createTypeReferenceNode('EntityShape'),
         factory.createTypeLiteralNode(members.concat(members2)),
         factory.createMappedTypeNode(undefined, factory.createTypeParameterDeclaration(undefined, factory.createIdentifier("A"), factory.createTypeReferenceNode(factory.createIdentifier("ExpressionKey"), undefined), undefined), undefined, factory.createToken(ts.SyntaxKind.QuestionToken), factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword), undefined)
     ])));
@@ -1022,6 +1014,8 @@ function constructFilter(statements, entity) {
         ])),
         // $$createAt$$: Q_DateValue
         factory.createPropertySignature(undefined, factory.createIdentifier('$$createAt$$'), undefined, factory.createTypeReferenceNode(factory.createIdentifier('Q_DateValue'))),
+        // $$seq$$: Q_StringValue
+        factory.createPropertySignature(undefined, factory.createIdentifier('$$seq$$'), undefined, factory.createTypeReferenceNode(factory.createIdentifier('Q_StringValue'))),
         // $$updateAt$$: Q_DateValue
         factory.createPropertySignature(undefined, factory.createIdentifier('$$updateAt$$'), undefined, factory.createTypeReferenceNode(factory.createIdentifier('Q_DateValue')))
     ];
@@ -1176,6 +1170,7 @@ function constructProjection(statements, entity) {
         ['id', true],
         ['$$createAt$$', false],
         ['$$updateAt$$', false],
+        ['$$seq$$', false],
     ];
     var foreignKeyProperties = (_a = {},
         _a[entity] = [''],
@@ -1341,7 +1336,7 @@ function constructProjection(statements, entity) {
     statements.push(factory.createTypeAliasDeclaration(undefined, [factory.createModifier(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier("Projection"), undefined, factory.createIntersectionTypeNode([
         factory.createTypeLiteralNode(MetaPropertySignaturs.concat(properties.map(function (_a) {
             var _b = tslib_1.__read(_a, 3), n = _b[0], q = _b[1], v = _b[2];
-            return factory.createPropertySignature(undefined, n, q ? undefined : factory.createToken(ts.SyntaxKind.QuestionToken), v || factory.createLiteralTypeNode(factory.createNumericLiteral("1")));
+            return factory.createPropertySignature(undefined, n, q ? undefined : factory.createToken(ts.SyntaxKind.QuestionToken), v || factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword));
         }))),
         exprNode,
     ])));
@@ -1357,7 +1352,7 @@ function constructProjection(statements, entity) {
     for (var foreignKey in foreignKeyProperties) {
         var identifier = "".concat(foreignKey, "IdProjection");
         statements.push(factory.createTypeAliasDeclaration(undefined, undefined, factory.createIdentifier(identifier), undefined, factory.createTypeReferenceNode(factory.createIdentifier("OneOf"), [
-            factory.createTypeLiteralNode(foreignKeyProperties[foreignKey].map(function (attr) { return factory.createPropertySignature(undefined, attr ? factory.createIdentifier("".concat(attr, "Id")) : 'id', undefined, factory.createLiteralTypeNode(factory.createNumericLiteral("1"))); }))
+            factory.createTypeLiteralNode(foreignKeyProperties[foreignKey].map(function (attr) { return factory.createPropertySignature(undefined, attr ? factory.createIdentifier("".concat(attr, "Id")) : 'id', undefined, factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword)); }))
         ])));
     }
 }
@@ -1498,11 +1493,13 @@ function constructSorter(statements, entity) {
     var schemaAttrs = Schema[entity].schemaAttrs;
     var members = [
         // id: 1
-        factory.createTypeLiteralNode([factory.createPropertySignature(undefined, factory.createIdentifier("id"), undefined, factory.createLiteralTypeNode(factory.createNumericLiteral("1")))]),
+        factory.createTypeLiteralNode([factory.createPropertySignature(undefined, factory.createIdentifier("id"), undefined, factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword))]),
         // $$createAt$$: 1
-        factory.createTypeLiteralNode([factory.createPropertySignature(undefined, factory.createIdentifier("$$createAt$$"), undefined, factory.createLiteralTypeNode(factory.createNumericLiteral("1")))]),
+        factory.createTypeLiteralNode([factory.createPropertySignature(undefined, factory.createIdentifier("$$createAt$$"), undefined, factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword))]),
+        // $$seq$$: 1
+        factory.createTypeLiteralNode([factory.createPropertySignature(undefined, factory.createIdentifier("$$seq$$"), undefined, factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword))]),
         // $$updateAt$$: 1
-        factory.createTypeLiteralNode([factory.createPropertySignature(undefined, factory.createIdentifier("$$updateAt$$"), undefined, factory.createLiteralTypeNode(factory.createNumericLiteral("1")))]),
+        factory.createTypeLiteralNode([factory.createPropertySignature(undefined, factory.createIdentifier("$$updateAt$$"), undefined, factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword))]),
     ];
     var _b = ManyToOne, _c = entity, manyToOneSet = _b[_c];
     var _loop_6 = function (attr) {
@@ -1522,7 +1519,7 @@ function constructSorter(statements, entity) {
                     case 'Datetime':
                     case 'Image':
                     case 'File': {
-                        type2 = factory.createLiteralTypeNode(factory.createNumericLiteral("1"));
+                        type2 = factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword);
                         break;
                     }
                     default: {
@@ -1533,11 +1530,11 @@ function constructSorter(statements, entity) {
                         });
                         if (manyToOneItem) {
                             type2 = factory.createTypeReferenceNode(createForeignRef(entity, text2_5, 'SortAttr'));
-                            members.push(factory.createTypeLiteralNode([factory.createPropertySignature(undefined, factory.createIdentifier("".concat(name_5.text, "Id")), undefined, factory.createLiteralTypeNode(factory.createNumericLiteral("1")))]));
+                            members.push(factory.createTypeLiteralNode([factory.createPropertySignature(undefined, factory.createIdentifier("".concat(name_5.text, "Id")), undefined, factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword))]));
                         }
                         else if (!['Object'].includes(text)) {
                             // todo 对State的专门处理
-                            type2 = factory.createLiteralTypeNode(factory.createNumericLiteral("1"));
+                            type2 = factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword);
                         }
                     }
                 }
@@ -1547,7 +1544,7 @@ function constructSorter(statements, entity) {
             }
         }
         else if (ts.isUnionTypeNode(type) && ts.isLiteralTypeNode(type.types[0]) || ts.isLiteralTypeNode(type)) {
-            members.push(factory.createTypeLiteralNode([factory.createPropertySignature(undefined, name_5, undefined, factory.createLiteralTypeNode(factory.createNumericLiteral("1")))]));
+            members.push(factory.createTypeLiteralNode([factory.createPropertySignature(undefined, name_5, undefined, factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword))]));
         }
         else {
             // 本地规定的shape，非结构化属性不参与排序
@@ -2549,7 +2546,8 @@ var initialStatements = function () { return [
         factory.createImportSpecifier(false, undefined, factory.createIdentifier("FormCreateData")),
         factory.createImportSpecifier(false, undefined, factory.createIdentifier("FormUpdateData")),
         factory.createImportSpecifier(false, factory.createIdentifier("Operation"), factory.createIdentifier("OakOperation")),
-        factory.createImportSpecifier(false, factory.createIdentifier("MakeAction"), factory.createIdentifier("OakMakeAction"))
+        factory.createImportSpecifier(false, factory.createIdentifier("MakeAction"), factory.createIdentifier("OakMakeAction")),
+        factory.createImportSpecifier(false, undefined, factory.createIdentifier("EntityShape")),
     ])), factory.createStringLiteral("".concat((0, env_1.TYPE_PATH_IN_OAK_DOMAIN)(), "Entity")), undefined)
 ]; };
 function outputSubQuery(outputDir, printer) {

package/lib/store/AsyncRowStore.d.ts

@@ -0,0 +1,45 @@
+/// <reference types="node" />
+import { EntityDict, RowStore, OperateOption, OperationResult, SelectOption, Context, TxnOption, OpRecord } from "../types";
+import { IncomingHttpHeaders } from "http";
+export declare abstract class AsyncContext<ED extends EntityDict> implements Context {
+    private rowStore;
+    private uuid?;
+    opRecords: OpRecord<ED>[];
+    private scene?;
+    private headers?;
+    events: {
+        commit: Array<() => Promise<void>>;
+        rollback: Array<() => Promise<void>>;
+    };
+    constructor(store: AsyncRowStore<ED, AsyncContext<ED>>, headers?: IncomingHttpHeaders);
+    setHeaders(headers: IncomingHttpHeaders): void;
+    getHeader(key: string): string | string[] | undefined;
+    getScene(): string | undefined;
+    setScene(scene?: string): void;
+    private resetEvents;
+    on(event: 'commit' | 'rollback', callback: () => Promise<void>): 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"]>[]>;
+    count<T extends keyof ED, OP extends SelectOption>(entity: T, selection: Pick<ED[T]['Selection'], 'filter' | 'count'>, option: OP): Promise<number>;
+    mergeMultipleResults(toBeMerged: OperationResult<ED>[]): OperationResult<ED>;
+    getCurrentTxnId(): string | undefined;
+    getSchema(): import("../types").StorageSchema<ED>;
+    abstract isRoot(): boolean;
+    abstract getCurrentUserId(allowUnloggedIn?: boolean): string | undefined;
+    abstract toString(): string;
+}
+export interface AsyncRowStore<ED extends EntityDict, Cxt extends Context> 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']>[]>;
+    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>;
+}

package/lib/store/{UniversalContext.js → AsyncRowStore.js}

@@ -1,14 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UniversalContext = void 0;
+exports.AsyncContext = void 0;
 var tslib_1 = require("tslib");
 var assert_1 = tslib_1.__importDefault(require("assert"));
-var concurrent_1 = require("../utils/concurrent");
-var UniversalContext = /** @class */ (function () {
-    function UniversalContext(store, headers) {
+var AsyncContext = /** @class */ (function () {
+    function AsyncContext(store, headers) {
         this.rowStore = store;
         this.opRecords = [];
-        this.rwLock = new concurrent_1.RWLock();
         this.events = {
             commit: [],
             rollback: [],
@@ -17,56 +15,54 @@ var UniversalContext = /** @class */ (function () {
             this.headers = headers;
         }
     }
-    UniversalContext.prototype.setHeaders = function (headers) {
+    AsyncContext.prototype.setHeaders = function (headers) {
         this.headers = headers;
     };
-    UniversalContext.prototype.getHeader = function (key) {
+    AsyncContext.prototype.getHeader = function (key) {
         if (this.headers) {
             return this.headers[key];
         }
     };
-    UniversalContext.prototype.getScene = function () {
+    AsyncContext.prototype.getScene = function () {
         return this.scene;
     };
-    UniversalContext.prototype.setScene = function (scene) {
+    AsyncContext.prototype.setScene = function (scene) {
         this.scene = scene;
     };
-    UniversalContext.prototype.resetEvents = function () {
+    AsyncContext.prototype.resetEvents = function () {
         this.events = {
             commit: [],
             rollback: [],
         };
     };
-    UniversalContext.prototype.on = function (event, callback) {
+    AsyncContext.prototype.on = function (event, callback) {
         this.uuid && this.events[event].push(callback);
     };
     /**
      * 一个context中不应该有并发的事务，这里将事务串行化，使用的时候千万要注意不要自己等自己
      * @param options
      */
-    UniversalContext.prototype.begin = function (options) {
+    AsyncContext.prototype.begin = function (options) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
             var _a;
             return tslib_1.__generator(this, function (_b) {
                 switch (_b.label) {
-                    case 0: return [4 /*yield*/, this.rwLock.acquire('X')];
-                    case 1:
-                        _b.sent();
-                        if (!!this.uuid) return [3 /*break*/, 3];
+                    case 0:
+                        if (!!this.uuid) return [3 /*break*/, 2];
                         _a = this;
                         return [4 /*yield*/, this.rowStore.begin(options)];
-                    case 2:
+                    case 1:
                         _a.uuid = _b.sent();
-                        return [3 /*break*/, 4];
-                    case 3:
+                        return [3 /*break*/, 3];
+                    case 2:
                         (0, assert_1.default)(false);
-                        _b.label = 4;
-                    case 4: return [2 /*return*/];
+                        _b.label = 3;
+                    case 3: return [2 /*return*/];
                 }
             });
         });
     };
-    UniversalContext.prototype.commit = function () {
+    AsyncContext.prototype.commit = function () {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
             var _a, _b, e, e_1_1;
             var e_1, _c;
@@ -77,9 +73,7 @@ var UniversalContext = /** @class */ (function () {
                         return [4 /*yield*/, this.rowStore.commit(this.uuid)];
                     case 1:
                         _d.sent();
-                        // console.log('commit', this.uuid);
                         this.uuid = undefined;
-                        this.rwLock.release();
                         _d.label = 2;
                     case 2:
                         _d.trys.push([2, 7, 8, 9]);
@@ -114,7 +108,7 @@ var UniversalContext = /** @class */ (function () {
             });
         });
     };
-    UniversalContext.prototype.rollback = function () {
+    AsyncContext.prototype.rollback = function () {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
             var _a, _b, e, e_2_1;
             var e_2, _c;
@@ -127,7 +121,6 @@ var UniversalContext = /** @class */ (function () {
                         _d.sent();
                         // console.log('rollback', this.uuid);
                         this.uuid = undefined;
-                        this.rwLock.release();
                         _d.label = 2;
                     case 2:
                         _d.trys.push([2, 7, 8, 9]);
@@ -162,9 +155,26 @@ var UniversalContext = /** @class */ (function () {
             });
         });
     };
-    UniversalContext.prototype.getCurrentTxnId = function () {
+    AsyncContext.prototype.operate = function (entity, operation, option) {
+        return this.rowStore.operate(entity, operation, this, option);
+    };
+    AsyncContext.prototype.select = function (entity, selection, option) {
+        return this.rowStore.select(entity, selection, this, option);
+    };
+    AsyncContext.prototype.count = function (entity, selection, option) {
+        return this.rowStore.count(entity, selection, this, option);
+    };
+    AsyncContext.prototype.mergeMultipleResults = function (toBeMerged) {
+        return this.rowStore.mergeMultipleResults(toBeMerged);
+    };
+    AsyncContext.prototype.getCurrentTxnId = function () {
         return this.uuid;
     };
-    return UniversalContext;
+    AsyncContext.prototype.getSchema = function () {
+        return this.rowStore.getSchema();
+    };
+    return AsyncContext;
 }());
-exports.UniversalContext = UniversalContext;
+exports.AsyncContext = AsyncContext;
+;
+;

package/lib/store/CascadeStore.d.ts

@@ -1,27 +1,22 @@
-import { Context } from '../types/Context';
-import { EntityDict, OperateOption, SelectOption, OperationResult, SelectRowShape } from "../types/Entity";
+import { EntityDict, OperateOption, SelectOption, OperationResult, DeduceFilter } from "../types/Entity";
 import { EntityDict as BaseEntityDict } from '../base-app-domain';
 import { RowStore } 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, Cxt extends Context<ED>> extends RowStore<ED, Cxt> {
+export declare abstract class CascadeStore<ED extends EntityDict & BaseEntityDict> extends RowStore<ED> {
     constructor(storageSchema: StorageSchema<ED>);
     protected abstract supportManyToOneJoin(): boolean;
     protected abstract supportMultipleCreate(): boolean;
-    protected abstract selectAbjointRow<T extends keyof ED, S extends ED[T]['Selection'], OP extends SelectOption>(entity: T, selection: S, context: Cxt, option: OP): Promise<SelectRowShape<ED[T]['Schema'], S['data']>[]>;
-    protected abstract updateAbjointRow<T extends keyof ED, OP extends OperateOption>(entity: T, operation: ED[T]['Create'] | ED[T]['Update'] | ED[T]['Remove'], context: Cxt, option: OP): Promise<number>;
-    /**
-     * 将一次查询的结果集加入result
-     * @param entity
-     * @param rows
-     * @param context
-     */
-    private addToResultSelections;
-    private reduceDescendants;
-    private destructCascadeSelect;
-    protected cascadeSelect<T extends keyof ED, S extends ED[T]['Selection'], OP extends SelectOption>(entity: T, selection: S, context: Cxt, option: OP): Promise<SelectRowShape<ED[T]['Schema'], S['data']>[]>;
-    protected cascadeSelect2<T extends keyof ED, S extends ED[T]['Selection'], OP extends SelectOption>(entity: T, selection: S, context: Cxt, option: OP): Promise<SelectRowShape<ED[T]['Schema'], S['data']>[]>;
-    private destructCascadeUpdate;
+    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 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 destructCascadeSelect<T extends keyof ED, OP extends SelectOption, Cxt extends SyncContext<ED> | AsyncContext<ED>, R>(entity: T, projection2: ED[T]['Selection']['data'], context: Cxt, cascadeSelect: <T2 extends keyof ED>(entity2: T2, selection: ED[T2]['Selection'], context: Cxt, op: OP) => R, option: OP): {
+        projection: ED[T]["Selection"]["data"];
+        cascadeSelectionFns: ((result: Partial<ED[T]['Schema']>[]) => Promise<void> | void)[];
+    };
     /**
      * 级联更新
      * A --> B
@@ -46,11 +41,22 @@ export declare abstract class CascadeStore<ED extends EntityDict & BaseEntityDic
      * 两者必须通过entity/entityId关联
      * 此时需要把对B的更新记录成一条新插入的Modi对象，并将A上的entity/entityId指向该对象（新生成的Modi对象的id与此operation的id保持一致）
      * @param entity
-     * @param operation
+     * @param action
+     * @param data
      * @param context
      * @param option
+     * @param result
+     * @param filter
+     * @returns
      */
-    protected cascadeUpdate<T extends keyof ED, OP extends OperateOption>(entity: T, operation: ED[T]['Create'] | ED[T]['Update'] | ED[T]['Remove'], context: Cxt, option: OP): Promise<OperationResult<ED>>;
+    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?: DeduceFilter<ED[T]['Schema']>): {
+        data: Record<string, any>;
+        beforeFns: (() => R)[];
+        afterFns: (() => R)[];
+    };
+    protected preProcessDataCreated<T extends keyof ED>(entity: T, data: ED[T]['Create']['data']): void;
+    protected preProcessDataUpdated<T extends keyof ED>(data: ED[T]['Update']['data']): void;
+    judgeRelation(entity: keyof ED, attr: string): string | 2 | 1 | string[] | 0;
     /**
      * 和具体的update过程无关的例程放在这里，包括对later动作的处理、对oper的记录以及对record的收集等
      * @param entity
@@ -58,6 +64,26 @@ export declare abstract class CascadeStore<ED extends EntityDict & BaseEntityDic
      * @param context
      * @param option
      */
+    private doUpdateSingleRowAsync;
     private doUpdateSingleRow;
-    judgeRelation(entity: keyof ED, attr: string): string | string[] | 1 | 0 | 2;
+    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']>[]>;
 }