oak-domain 2.0.2 → 2.1.0

package/lib/store/AsyncRowStore.js

@@ -1,180 +1,180 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AsyncContext = void 0;
-var tslib_1 = require("tslib");
-var assert_1 = tslib_1.__importDefault(require("assert"));
-var AsyncContext = /** @class */ (function () {
-    function AsyncContext(store, headers) {
-        this.rowStore = store;
-        this.opRecords = [];
-        this.events = {
-            commit: [],
-            rollback: [],
-        };
-        if (headers) {
-            this.headers = headers;
-        }
-    }
-    AsyncContext.prototype.setHeaders = function (headers) {
-        this.headers = headers;
-    };
-    AsyncContext.prototype.getHeader = function (key) {
-        if (this.headers) {
-            return this.headers[key];
-        }
-    };
-    AsyncContext.prototype.getScene = function () {
-        return this.scene;
-    };
-    AsyncContext.prototype.setScene = function (scene) {
-        this.scene = scene;
-    };
-    AsyncContext.prototype.resetEvents = function () {
-        this.events = {
-            commit: [],
-            rollback: [],
-        };
-    };
-    AsyncContext.prototype.on = function (event, callback) {
-        this.uuid && this.events[event].push(callback);
-    };
-    /**
-     * 一个context中不应该有并发的事务，这里将事务串行化，使用的时候千万要注意不要自己等自己
-     * @param 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:
-                        if (!!this.uuid) return [3 /*break*/, 2];
-                        _a = this;
-                        return [4 /*yield*/, this.rowStore.begin(options)];
-                    case 1:
-                        _a.uuid = _b.sent();
-                        return [3 /*break*/, 3];
-                    case 2:
-                        (0, assert_1.default)(false);
-                        _b.label = 3;
-                    case 3: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    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;
-            return tslib_1.__generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        if (!this.uuid) return [3 /*break*/, 10];
-                        return [4 /*yield*/, this.rowStore.commit(this.uuid)];
-                    case 1:
-                        _d.sent();
-                        this.uuid = undefined;
-                        _d.label = 2;
-                    case 2:
-                        _d.trys.push([2, 7, 8, 9]);
-                        _a = tslib_1.__values(this.events.commit), _b = _a.next();
-                        _d.label = 3;
-                    case 3:
-                        if (!!_b.done) return [3 /*break*/, 6];
-                        e = _b.value;
-                        return [4 /*yield*/, e()];
-                    case 4:
-                        _d.sent();
-                        _d.label = 5;
-                    case 5:
-                        _b = _a.next();
-                        return [3 /*break*/, 3];
-                    case 6: return [3 /*break*/, 9];
-                    case 7:
-                        e_1_1 = _d.sent();
-                        e_1 = { error: e_1_1 };
-                        return [3 /*break*/, 9];
-                    case 8:
-                        try {
-                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
-                        }
-                        finally { if (e_1) throw e_1.error; }
-                        return [7 /*endfinally*/];
-                    case 9:
-                        this.resetEvents();
-                        _d.label = 10;
-                    case 10: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    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;
-            return tslib_1.__generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        if (!this.uuid) return [3 /*break*/, 10];
-                        return [4 /*yield*/, this.rowStore.rollback(this.uuid)];
-                    case 1:
-                        _d.sent();
-                        // console.log('rollback', this.uuid);
-                        this.uuid = undefined;
-                        _d.label = 2;
-                    case 2:
-                        _d.trys.push([2, 7, 8, 9]);
-                        _a = tslib_1.__values(this.events.rollback), _b = _a.next();
-                        _d.label = 3;
-                    case 3:
-                        if (!!_b.done) return [3 /*break*/, 6];
-                        e = _b.value;
-                        return [4 /*yield*/, e()];
-                    case 4:
-                        _d.sent();
-                        _d.label = 5;
-                    case 5:
-                        _b = _a.next();
-                        return [3 /*break*/, 3];
-                    case 6: return [3 /*break*/, 9];
-                    case 7:
-                        e_2_1 = _d.sent();
-                        e_2 = { error: e_2_1 };
-                        return [3 /*break*/, 9];
-                    case 8:
-                        try {
-                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
-                        }
-                        finally { if (e_2) throw e_2.error; }
-                        return [7 /*endfinally*/];
-                    case 9:
-                        this.resetEvents();
-                        _d.label = 10;
-                    case 10: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    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;
-    };
-    AsyncContext.prototype.getSchema = function () {
-        return this.rowStore.getSchema();
-    };
-    return AsyncContext;
-}());
-exports.AsyncContext = AsyncContext;
-;
-;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncContext = void 0;
+var tslib_1 = require("tslib");
+var assert_1 = tslib_1.__importDefault(require("assert"));
+var AsyncContext = /** @class */ (function () {
+    function AsyncContext(store, headers) {
+        this.rowStore = store;
+        this.opRecords = [];
+        this.events = {
+            commit: [],
+            rollback: [],
+        };
+        if (headers) {
+            this.headers = headers;
+        }
+    }
+    AsyncContext.prototype.setHeaders = function (headers) {
+        this.headers = headers;
+    };
+    AsyncContext.prototype.getHeader = function (key) {
+        if (this.headers) {
+            return this.headers[key];
+        }
+    };
+    AsyncContext.prototype.getScene = function () {
+        return this.scene;
+    };
+    AsyncContext.prototype.setScene = function (scene) {
+        this.scene = scene;
+    };
+    AsyncContext.prototype.resetEvents = function () {
+        this.events = {
+            commit: [],
+            rollback: [],
+        };
+    };
+    AsyncContext.prototype.on = function (event, callback) {
+        this.uuid && this.events[event].push(callback);
+    };
+    /**
+     * 一个context中不应该有并发的事务，这里将事务串行化，使用的时候千万要注意不要自己等自己
+     * @param 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:
+                        if (!!this.uuid) return [3 /*break*/, 2];
+                        _a = this;
+                        return [4 /*yield*/, this.rowStore.begin(options)];
+                    case 1:
+                        _a.uuid = _b.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        (0, assert_1.default)(false);
+                        _b.label = 3;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    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;
+            return tslib_1.__generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        if (!this.uuid) return [3 /*break*/, 10];
+                        return [4 /*yield*/, this.rowStore.commit(this.uuid)];
+                    case 1:
+                        _d.sent();
+                        this.uuid = undefined;
+                        _d.label = 2;
+                    case 2:
+                        _d.trys.push([2, 7, 8, 9]);
+                        _a = tslib_1.__values(this.events.commit), _b = _a.next();
+                        _d.label = 3;
+                    case 3:
+                        if (!!_b.done) return [3 /*break*/, 6];
+                        e = _b.value;
+                        return [4 /*yield*/, e()];
+                    case 4:
+                        _d.sent();
+                        _d.label = 5;
+                    case 5:
+                        _b = _a.next();
+                        return [3 /*break*/, 3];
+                    case 6: return [3 /*break*/, 9];
+                    case 7:
+                        e_1_1 = _d.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 9];
+                    case 8:
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                        return [7 /*endfinally*/];
+                    case 9:
+                        this.resetEvents();
+                        _d.label = 10;
+                    case 10: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    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;
+            return tslib_1.__generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        if (!this.uuid) return [3 /*break*/, 10];
+                        return [4 /*yield*/, this.rowStore.rollback(this.uuid)];
+                    case 1:
+                        _d.sent();
+                        // console.log('rollback', this.uuid);
+                        this.uuid = undefined;
+                        _d.label = 2;
+                    case 2:
+                        _d.trys.push([2, 7, 8, 9]);
+                        _a = tslib_1.__values(this.events.rollback), _b = _a.next();
+                        _d.label = 3;
+                    case 3:
+                        if (!!_b.done) return [3 /*break*/, 6];
+                        e = _b.value;
+                        return [4 /*yield*/, e()];
+                    case 4:
+                        _d.sent();
+                        _d.label = 5;
+                    case 5:
+                        _b = _a.next();
+                        return [3 /*break*/, 3];
+                    case 6: return [3 /*break*/, 9];
+                    case 7:
+                        e_2_1 = _d.sent();
+                        e_2 = { error: e_2_1 };
+                        return [3 /*break*/, 9];
+                    case 8:
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                        return [7 /*endfinally*/];
+                    case 9:
+                        this.resetEvents();
+                        _d.label = 10;
+                    case 10: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    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;
+    };
+    AsyncContext.prototype.getSchema = function () {
+        return this.rowStore.getSchema();
+    };
+    return AsyncContext;
+}());
+exports.AsyncContext = AsyncContext;
+;
+;

package/lib/store/CascadeStore.d.ts

@@ -1,89 +1,89 @@
-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> extends RowStore<ED> {
-    constructor(storageSchema: StorageSchema<ED>);
-    protected abstract supportManyToOneJoin(): boolean;
-    protected abstract supportMultipleCreate(): boolean;
-    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
-        多对一：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?: 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
-     * @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']>[]>;
-}
+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> extends RowStore<ED> {
+    constructor(storageSchema: StorageSchema<ED>);
+    protected abstract supportManyToOneJoin(): boolean;
+    protected abstract supportMultipleCreate(): boolean;
+    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
+        多对一：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?: 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
+     * @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']>[]>;
+}