oak-domain 2.2.0 → 2.3.1

package/lib/compiler/schemalBuilder.js

@@ -337,6 +337,7 @@ function analyzeEntity(filename, path, program, relativePath) {
     var localEnumStringTypes = [];
     var additionalImports = [];
     var localeDef = undefined;
+    var relationHierarchy = undefined;
     ts.forEachChild(sourceFile, function (node) {
         var _a, _b, _c, _d;
         if (ts.isImportDeclaration(node)) {
@@ -519,7 +520,7 @@ function analyzeEntity(filename, path, program, relativePath) {
                     actionDefNodes.push(factory.createTypeReferenceNode('RelationAction', undefined));
                 }
                 pushStatementIntoActionAst(moduleName, factory.createTypeAliasDeclaration(undefined, [factory.createModifier(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier("Action"), undefined, factory.createUnionTypeNode(actionDefNodes)), sourceFile);
-                dealWithActions(moduleName, filename, node.type, program, sourceFile, hasRelationDef || moduleName === 'User');
+                dealWithActions(moduleName, filename, node.type, program, sourceFile, !!hasRelationDef || moduleName === 'User');
             }
             else if (node.name.text === 'Relation') {
                 (0, assert_1.default)(!hasActionDef, "\u3010".concat(filename, "\u3011action\u5B9A\u4E49\u987B\u5728Relation\u4E4B\u540E"));
@@ -541,18 +542,22 @@ function analyzeEntity(filename, path, program, relativePath) {
                 var relationSchemaAttrs = [
                     factory.createPropertySignature(undefined, factory.createIdentifier("user"), undefined, factory.createTypeReferenceNode(factory.createIdentifier("User"), undefined)),
                     factory.createPropertySignature(undefined, factory.createIdentifier(entityLc), undefined, factory.createTypeReferenceNode(factory.createIdentifier(moduleName), undefined)),
-                    factory.createPropertySignature(undefined, factory.createIdentifier('relation'), undefined, node.type),
+                    factory.createPropertySignature(undefined, factory.createIdentifier('relation'), undefined, factory.createTypeReferenceNode(factory.createIdentifier("Relation"), undefined)),
                 ];
                 (0, lodash_1.assign)(Schema, (_d = {},
                     _d[relationEntityName] = {
                         schemaAttrs: relationSchemaAttrs,
                         sourceFile: sourceFile,
+                        enumStringAttrs: ['relation'],
                         actionType: 'excludeUpdate',
+                        additionalImports: [
+                            factory.createImportDeclaration(undefined, undefined, factory.createImportClause(false, undefined, factory.createNamedImports([factory.createImportSpecifier(false, undefined, factory.createIdentifier("Relation"))])), factory.createStringLiteral("../".concat(moduleName, "/Schema")), undefined)
+                        ],
                     },
                     _d));
                 addRelationship(relationEntityName, 'User', 'user', true);
                 addRelationship(relationEntityName, moduleName, entityLc, true);
-                hasRelationDef = true;
+                hasRelationDef = node;
             }
             else if (node.name.text.endsWith('Action') || node.name.text.endsWith('State')) {
                 (0, assert_1.default)(!localeDef, "\u3010".concat(filename, "\u3011locale\u5B9A\u4E49\u987B\u5728Action/State\u4E4B\u540E"));
@@ -790,6 +795,13 @@ function analyzeEntity(filename, path, program, relativePath) {
                         _static = true; // static如果有值只能为true
                     }
                 }
+                else if (ts.isTypeReferenceNode(declaration.type) && ts.isIdentifier(declaration.type.typeName) && declaration.type.typeName.text === 'RelationHierarchy') {
+                    // RelationHierary
+                    (0, assert_1.default)(hasRelationDef, "".concat(moduleName, "\u4E2D\u7684Relation\u5B9A\u4E49\u5728RelationHierarchy\u4E4B\u540E"));
+                    var initializer = declaration.initializer;
+                    (0, assert_1.default)(ts.isObjectLiteralExpression(initializer), "".concat(moduleName, "\u4E2D\u7684RelationHierarchy\u7684\u5B9A\u4E49\u5FC5\u987B\u662F\u521D\u59CB\u5316\u4E3AObjectLiteralExpress"));
+                    relationHierarchy = initializer;
+                }
                 else {
                     throw new Error("".concat(moduleName, "\uFF1A\u4E0D\u80FD\u7406\u89E3\u7684\u5B9A\u4E49\u5185\u5BB9").concat(declaration.name.getText()));
                 }
@@ -831,6 +843,15 @@ function analyzeEntity(filename, path, program, relativePath) {
             locale: localeDef,
         });
     }
+    if (hasRelationDef) {
+        (0, assert_1.default)(relationHierarchy, "".concat(filename, "\u4E2D\u7F3A\u5C11\u4E86relationHierarchy\u5B9A\u4E49"));
+        (0, lodash_1.assign)(schema, {
+            relationHierarchy: relationHierarchy,
+        });
+    }
+    else {
+        (0, assert_1.default)(!relationHierarchy, "".concat(filename, "\u4E2D\u5177\u6709relationHierarchy\u5B9A\u4E49\u4F46\u6CA1\u6709Relation\u5B9A\u4E49"));
+    }
     (0, lodash_1.assign)(Schema, (_a = {},
         _a[moduleName] = schema,
         _a));
@@ -962,6 +983,8 @@ function constructSchema(statements, entity) {
             foreignKeySet[entityName].forEach(function (foreignKey) {
                 var identifier = "".concat(entityNameLc, "$").concat(foreignKey);
                 members2.push(factory.createPropertySignature(undefined, identifier, factory.createToken(ts.SyntaxKind.QuestionToken), factory.createTypeReferenceNode(factory.createIdentifier("Array"), [factory.createTypeReferenceNode(createForeignRef(entity, entityName, 'Schema'), undefined)])));
+                var aggrIdentifier = "".concat(entityNameLc, "$").concat(foreignKey, "$$aggr");
+                members2.push(factory.createPropertySignature(undefined, aggrIdentifier, factory.createToken(ts.SyntaxKind.QuestionToken), factory.createTypeReferenceNode(factory.createIdentifier("AggregationResult"), [factory.createTypeReferenceNode(createForeignRef(entity, entityName, 'Schema'), undefined)])));
             });
         };
         for (var entityName in foreignKeySet) {
@@ -1161,7 +1184,7 @@ function constructProjection(statements, entity) {
     var _a, e_4, _b, e_5, _c;
     var schemaAttrs = Schema[entity].schemaAttrs;
     var properties = [
-        ['id', true],
+        ['id', false],
         ['$$createAt$$', false],
         ['$$updateAt$$', false],
         ['$$seq$$', false],
@@ -1202,7 +1225,10 @@ function constructProjection(statements, entity) {
                         });
                         if (manyToOneItem) {
                             // 外键投影
-                            properties.push(["".concat(attrName, "Id"), false, undefined], [name_4, false, factory.createTypeReferenceNode(createForeignRef(entity, text2_4, 'Projection')), factory.createTypeReferenceNode(createForeignRef(entity, text2_4, 'ExportProjection'))]);
+                            properties.push(["".concat(attrName, "Id"), false, undefined], [name_4, false, factory.createTypeReferenceNode(createForeignRef(entity, text2_4, 'Projection')) /* , factory.createTypeReferenceNode(
+                                    createForeignRef(entity, text2, 'ExportProjection')
+                                ) */
+                            ]);
                             if (foreignKeyProperties.hasOwnProperty(text2_4)) {
                                 foreignKeyProperties[text2_4].push(attrName);
                             }
@@ -1252,7 +1278,10 @@ function constructProjection(statements, entity) {
         ReversePointerRelations[entity].forEach(function (one) {
             var _a;
             var text2 = one === 'Schema' ? entity : one;
-            properties.push([(0, string_1.firstLetterLowerCase)(one), false, factory.createTypeReferenceNode(createForeignRef(entity, one, 'Projection')), factory.createTypeReferenceNode(createForeignRef(entity, one, 'ExportProjection'))]);
+            properties.push([(0, string_1.firstLetterLowerCase)(one), false, factory.createTypeReferenceNode(createForeignRef(entity, one, 'Projection')) /* , factory.createTypeReferenceNode(
+                    createForeignRef(entity, one, 'ExportProjection')
+                ) */
+            ]);
             if (foreignKeyProperties.hasOwnProperty(one)) {
                 foreignKeyProperties[text2].push('entity');
             }
@@ -1290,15 +1319,31 @@ function constructProjection(statements, entity) {
             var entityNameLc = (0, string_1.firstLetterLowerCase)(entityName);
             foreignKeySet[entityName].forEach(function (foreignKey) {
                 var identifier = "".concat(entityNameLc, "$").concat(foreignKey);
+                var aggrIdentifier = "".concat(entityNameLc, "$").concat(foreignKey, "$$aggr");
                 properties.push([identifier, false,
                     factory.createIntersectionTypeNode([
                         factory.createTypeReferenceNode(createForeignRef(entity, entityName, 'Selection'), undefined),
                         factory.createTypeLiteralNode([
                             factory.createPropertySignature(undefined, factory.createIdentifier("$entity"), undefined, factory.createLiteralTypeNode(factory.createStringLiteral((0, string_1.firstLetterLowerCase)(entityName))))
                         ])
-                    ]),
+                    ]) /* ,
+                    factory.createIntersectionTypeNode([
+                        factory.createTypeReferenceNode(
+                            createForeignRef(entity, entityName, 'Exportation'),
+                            undefined
+                        ),
+                        factory.createTypeLiteralNode([
+                            factory.createPropertySignature(
+                                undefined,
+                                factory.createIdentifier("$entity"),
+                                undefined,
+                                factory.createLiteralTypeNode(factory.createStringLiteral(firstLetterLowerCase(entityName)))
+                            )
+                        ])
+                    ]) */
+                ], [aggrIdentifier, false,
                     factory.createIntersectionTypeNode([
-                        factory.createTypeReferenceNode(createForeignRef(entity, entityName, 'Exportation'), undefined),
+                        factory.createTypeReferenceNode(createForeignRef(entity, entityName, 'Aggregation'), undefined),
                         factory.createTypeLiteralNode([
                             factory.createPropertySignature(undefined, factory.createIdentifier("$entity"), undefined, factory.createLiteralTypeNode(factory.createStringLiteral((0, string_1.firstLetterLowerCase)(entityName))))
                         ])
@@ -1320,28 +1365,47 @@ function constructProjection(statements, entity) {
                 factory.createTypeReferenceNode(factory.createIdentifier('OpAttr'))
         ])
     ]);
-    var MetaPropertySignaturs = [
+    var MetaPropertySignatures = [
         factory.createPropertySignature(undefined, factory.createStringLiteral("#id"), factory.createToken(ts.SyntaxKind.QuestionToken), factory.createTypeReferenceNode('NodeId'))
     ];
     if (process.env.COMPLING_AS_LIB) {
-        MetaPropertySignaturs.push(factory.createIndexSignature(undefined, undefined, [factory.createParameterDeclaration(undefined, undefined, undefined, factory.createIdentifier("k"), undefined, factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword), undefined)], factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)));
+        MetaPropertySignatures.push(factory.createIndexSignature(undefined, undefined, [factory.createParameterDeclaration(undefined, undefined, undefined, factory.createIdentifier("k"), undefined, factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword), undefined)], factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)));
     }
     // Projection，正常查询的投影
     statements.push(factory.createTypeAliasDeclaration(undefined, [factory.createModifier(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier("Projection"), undefined, factory.createIntersectionTypeNode([
-        factory.createTypeLiteralNode(MetaPropertySignaturs.concat(properties.map(function (_a) {
+        factory.createTypeLiteralNode(MetaPropertySignatures.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.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword));
         }))),
         exprNode,
     ])));
-    // ExportProjection，下载查询的投影
-    statements.push(factory.createTypeAliasDeclaration(undefined, [factory.createModifier(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier("ExportProjection"), undefined, factory.createIntersectionTypeNode([
-        factory.createTypeLiteralNode(MetaPropertySignaturs.concat(properties.map(function (_a) {
-            var _b = tslib_1.__read(_a, 4), n = _b[0], q = _b[1], v = _b[2], v2 = _b[3];
-            return factory.createPropertySignature(undefined, n, factory.createToken(ts.SyntaxKind.QuestionToken), v2 || factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword));
-        }))),
-        exprNode,
-    ])));
+    // ExportProjection，下载查询的投影 
+    // 已经废弃。By Xc 2023.01.08
+    /* statements.push(
+        factory.createTypeAliasDeclaration(
+            undefined,
+            [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+            factory.createIdentifier("ExportProjection"),
+            undefined,
+            factory.createIntersectionTypeNode([
+                factory.createTypeLiteralNode(
+                    MetaPropertySignaturs.concat(
+                        properties.map(
+                            ([n, q, v, v2]) => {
+                                return factory.createPropertySignature(
+                                    undefined,
+                                    n,
+                                    factory.createToken(ts.SyntaxKind.QuestionToken),
+                                    v2 || factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword)
+                                )
+                            }
+                        )
+                    )
+                ),
+                exprNode,
+            ])
+        )
+    ); */
     // ${Entity}Projection，外键查询的专用投影
     for (var foreignKey in foreignKeyProperties) {
         var identifier = "".concat(foreignKey, "IdProjection");
@@ -1717,14 +1781,43 @@ function constructActions(statements, entity) {
             factory.createTypeReferenceNode(factory.createIdentifier("P"), undefined)
         ]),
         factory.createLiteralTypeNode(factory.createStringLiteral("action"))
+    ])), factory.createTypeAliasDeclaration(undefined, [factory.createToken(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier("Aggregation"), undefined, factory.createTypeReferenceNode(factory.createIdentifier("Omit"), [
+        factory.createTypeReferenceNode(factory.createIdentifier("DeduceAggregation"), [
+            factory.createTypeReferenceNode(factory.createIdentifier("Schema"), undefined),
+            factory.createTypeReferenceNode(factory.createIdentifier("Projection"), undefined),
+            factory.createTypeReferenceNode(factory.createIdentifier("Filter"), undefined),
+            factory.createTypeReferenceNode(factory.createIdentifier("Sorter"), undefined)
+        ]),
+        factory.createLiteralTypeNode(factory.createStringLiteral("id"))
     ])));
     // Exportation
-    statements.push(factory.createTypeAliasDeclaration(undefined, [factory.createModifier(ts.SyntaxKind.ExportKeyword)], factory.createIdentifier("Exportation"), undefined, factory.createTypeReferenceNode(factory.createIdentifier("OakOperation"), [
-        factory.createLiteralTypeNode(factory.createStringLiteral("export")),
-        factory.createTypeReferenceNode(factory.createIdentifier("ExportProjection"), undefined),
-        factory.createTypeReferenceNode(factory.createIdentifier("Filter"), undefined),
-        factory.createTypeReferenceNode(factory.createIdentifier("Sorter"), undefined)
-    ])));
+    // 已经废弃，by Xc 2023.01.08
+    /*  statements.push(
+         factory.createTypeAliasDeclaration(
+             undefined,
+             [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+             factory.createIdentifier("Exportation"),
+             undefined,
+             factory.createTypeReferenceNode(
+                 factory.createIdentifier("OakOperation"),
+                 [
+                     factory.createLiteralTypeNode(factory.createStringLiteral("export")),
+                     factory.createTypeReferenceNode(
+                         factory.createIdentifier("ExportProjection"),
+                         undefined
+                     ),
+                     factory.createTypeReferenceNode(
+                         factory.createIdentifier("Filter"),
+                         undefined
+                     ),
+                     factory.createTypeReferenceNode(
+                         factory.createIdentifier("Sorter"),
+                         undefined
+                     )
+                 ]
+             )
+         )
+     ); */
     var _k = ManyToOne, _l = entity, manyToOneSet = _k[_l];
     var _m = OneToMany, _o = entity, oneToManySet = _m[_o];
     var foreignKeySet = {};
@@ -2539,9 +2632,11 @@ var initialStatements = function () { return [
     factory.createImportDeclaration(undefined, undefined, factory.createImportClause(false, undefined, factory.createNamedImports([
         factory.createImportSpecifier(false, undefined, factory.createIdentifier("FormCreateData")),
         factory.createImportSpecifier(false, undefined, factory.createIdentifier("FormUpdateData")),
+        factory.createImportSpecifier(false, undefined, factory.createIdentifier("DeduceAggregation")),
         factory.createImportSpecifier(false, factory.createIdentifier("Operation"), factory.createIdentifier("OakOperation")),
         factory.createImportSpecifier(false, factory.createIdentifier("MakeAction"), factory.createIdentifier("OakMakeAction")),
         factory.createImportSpecifier(false, undefined, factory.createIdentifier("EntityShape")),
+        factory.createImportSpecifier(false, undefined, factory.createIdentifier("AggregationResult")),
     ])), factory.createStringLiteral("".concat((0, env_1.TYPE_PATH_IN_OAK_DOMAIN)(), "Entity")), undefined)
 ]; };
 function outputSubQuery(outputDir, printer) {
@@ -2649,6 +2744,11 @@ function outputSchema(outputDir, printer) {
         if ((additionalImports === null || additionalImports === void 0 ? void 0 : additionalImports.length) > 0) {
             statements.push.apply(statements, tslib_1.__spreadArray([], tslib_1.__read(additionalImports), false));
         }
+        // Relation定义加入
+        if (typeof Schema[entity].hasRelationDef === 'object' && ts.isTypeAliasDeclaration(Schema[entity].hasRelationDef)) {
+            var node = Schema[entity].hasRelationDef;
+            statements.push(factory.updateTypeAliasDeclaration(node, undefined, [factory.createModifier(ts.SyntaxKind.ExportKeyword)], node.name, node.typeParameters, node.type));
+        }
         constructSchema(statements, entity);
         constructFilter(statements, entity);
         constructProjection(statements, entity);
@@ -2676,6 +2776,7 @@ function outputSchema(outputDir, printer) {
                     factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword)
                 ]) : actionTypeNode),
             factory.createPropertySignature(undefined, factory.createIdentifier("Selection"), undefined, factory.createTypeReferenceNode(factory.createIdentifier("Selection"), undefined)),
+            factory.createPropertySignature(undefined, factory.createIdentifier("Aggregation"), undefined, factory.createTypeReferenceNode(factory.createIdentifier("Aggregation"), undefined)),
             factory.createPropertySignature(undefined, factory.createIdentifier("Operation"), undefined, factory.createTypeReferenceNode(factory.createIdentifier("Operation"), undefined)),
             factory.createPropertySignature(undefined, factory.createIdentifier("Create"), undefined, factory.createTypeReferenceNode(factory.createIdentifier("CreateOperation"), undefined)),
             factory.createPropertySignature(undefined, factory.createIdentifier("Update"), undefined, factory.createTypeReferenceNode(factory.createIdentifier("UpdateOperation"), undefined)),
@@ -2807,7 +2908,7 @@ function constructAttributes(entity) {
                             attrAssignments.push(factory.createPropertyAssignment(factory.createIdentifier("type"), factory.createStringLiteral("ref")), factory.createPropertyAssignment(factory.createIdentifier("ref"), factory.createStringLiteral((0, string_1.firstLetterLowerCase)(text2_6))));
                         }
                         else {
-                            if (enumStringAttrs.includes(name.text)) {
+                            if (enumStringAttrs && enumStringAttrs.includes(name.text)) {
                                 attrAssignments.push(factory.createPropertyAssignment(factory.createIdentifier("type"), factory.createStringLiteral("varchar")), factory.createPropertyAssignment(factory.createIdentifier("params"), factory.createObjectLiteralExpression([factory.createPropertyAssignment(factory.createIdentifier("length"), factory.createNumericLiteral(env_1.STRING_LITERAL_MAX_LENGTH))], true)));
                             }
                             else {
@@ -2944,10 +3045,16 @@ function outputStorage(outputDir, printer) {
     var entityAssignments = [];
     for (var entity in Schema) {
         var indexExpressions = [];
-        var _a = Schema[entity], sourceFile = _a.sourceFile, inModi = _a.inModi, indexes = _a.indexes, toModi = _a.toModi, actionType = _a.actionType, _static = _a.static;
+        var _a = Schema[entity], sourceFile = _a.sourceFile, inModi = _a.inModi, indexes = _a.indexes, toModi = _a.toModi, actionType = _a.actionType, _static = _a.static, relationHierarchy = _a.relationHierarchy;
+        var fromSchemaSpecifiers = [
+            factory.createImportSpecifier(false, undefined, factory.createIdentifier("OpSchema"))
+        ];
+        if (relationHierarchy) {
+            fromSchemaSpecifiers.push(factory.createImportSpecifier(false, undefined, factory.createIdentifier("Relation")));
+        }
         var statements = [
             factory.createImportDeclaration(undefined, undefined, factory.createImportClause(false, undefined, factory.createNamedImports([factory.createImportSpecifier(false, undefined, factory.createIdentifier("StorageDesc"))])), factory.createStringLiteral("".concat((0, env_1.TYPE_PATH_IN_OAK_DOMAIN)(), "Storage")), undefined),
-            factory.createImportDeclaration(undefined, undefined, factory.createImportClause(false, undefined, factory.createNamedImports([factory.createImportSpecifier(false, undefined, factory.createIdentifier("OpSchema"))])), factory.createStringLiteral("./Schema"), undefined)
+            factory.createImportDeclaration(undefined, undefined, factory.createImportClause(false, undefined, factory.createNamedImports(fromSchemaSpecifiers)), factory.createStringLiteral("./Schema"), undefined)
         ];
         var needImportActions = [];
         switch (actionType) {
@@ -3003,9 +3110,16 @@ function outputStorage(outputDir, printer) {
         if (indexExpressions.length > 0) {
             propertyAssignments.push(factory.createPropertyAssignment(factory.createIdentifier("indexes"), factory.createArrayLiteralExpression(indexExpressions, true)));
         }
-        statements.push(factory.createVariableStatement([factory.createModifier(ts.SyntaxKind.ExportKeyword)], factory.createVariableDeclarationList([factory.createVariableDeclaration(factory.createIdentifier("desc"), undefined, factory.createTypeReferenceNode(factory.createIdentifier("StorageDesc"), [
-                factory.createTypeReferenceNode(factory.createIdentifier("OpSchema"), undefined)
-            ]), factory.createObjectLiteralExpression(propertyAssignments, true))], ts.NodeFlags.Const)));
+        if (relationHierarchy) {
+            propertyAssignments.push(factory.createPropertyAssignment(factory.createIdentifier("relationHierarchy"), relationHierarchy));
+        }
+        var sdTypeArguments = [
+            factory.createTypeReferenceNode(factory.createIdentifier("OpSchema"), undefined)
+        ];
+        if (relationHierarchy) {
+            sdTypeArguments.push(factory.createTypeReferenceNode(factory.createIdentifier("Relation"), undefined));
+        }
+        statements.push(factory.createVariableStatement([factory.createModifier(ts.SyntaxKind.ExportKeyword)], factory.createVariableDeclarationList([factory.createVariableDeclaration(factory.createIdentifier("desc"), undefined, factory.createTypeReferenceNode(factory.createIdentifier("StorageDesc"), sdTypeArguments), factory.createObjectLiteralExpression(propertyAssignments, true))], ts.NodeFlags.Const)));
         var result_2 = printer.printList(ts.ListFormat.SourceFileStatements, factory.createNodeArray(statements), sourceFile);
         var filename_1 = path_1.default.join(outputDir, entity, 'Storage.ts');
         (0, fs_1.writeFileSync)(filename_1, result_2, { flag: 'w' });

package/lib/store/AsyncRowStore.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { EntityDict, RowStore, OperateOption, OperationResult, SelectOption, Context, TxnOption, OpRecord } from "../types";
+import { EntityDict, RowStore, OperateOption, OperationResult, SelectOption, Context, TxnOption, OpRecord, AggregationResult } from "../types";
 import { IncomingHttpHeaders } from "http";
 export declare abstract class AsyncContext<ED extends EntityDict> implements Context {
     private rowStore;
@@ -27,6 +27,7 @@ export declare abstract class AsyncContext<ED extends EntityDict> implements Con
     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>;
     mergeMultipleResults(toBeMerged: OperationResult<ED>[]): OperationResult<ED>;
     getCurrentTxnId(): string | undefined;
@@ -39,6 +40,7 @@ export declare abstract class AsyncContext<ED extends EntityDict> implements Con
 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']>[]>;
+    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>;

package/lib/store/AsyncRowStore.js

@@ -161,6 +161,9 @@ var AsyncContext = /** @class */ (function () {
     AsyncContext.prototype.select = function (entity, selection, option) {
         return this.rowStore.select(entity, selection, this, option);
     };
+    AsyncContext.prototype.aggregate = function (entity, aggregation, option) {
+        return this.rowStore.aggregate(entity, aggregation, this, option);
+    };
     AsyncContext.prototype.count = function (entity, selection, option) {
         return this.rowStore.count(entity, selection, this, option);
     };

package/lib/store/CascadeStore.d.ts

@@ -1,4 +1,4 @@
-import { EntityDict, OperateOption, SelectOption, OperationResult, DeduceFilter } from "../types/Entity";
+import { EntityDict, OperateOption, SelectOption, OperationResult, DeduceFilter, AggregationResult } from "../types/Entity";
 import { EntityDict as BaseEntityDict } from '../base-app-domain';
 import { RowStore } from '../types/RowStore';
 import { StorageSchema } from '../types/Storage';
@@ -13,7 +13,9 @@ export declare abstract class CascadeStore<ED extends EntityDict & BaseEntityDic
     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): {
+    protected abstract 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 abstract 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 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)[];
     };