cabloy 5.1.249 → 5.1.250

package/vona/packages-cli/cli-set-api/test/crudAnalysis.test.ts

@@ -0,0 +1,385 @@
+import assert from 'node:assert/strict';
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { describe, it } from 'node:test';
+import { fileURLToPath } from 'node:url';
+import ts from 'typescript';
+
+import { LocalTemplate } from '../../cabloy-cli/src/lib/local.template.ts';
+import { CliToolsCrud } from '../src/lib/bean/cli.tools.crud.ts';
+import { CliToolsCrudBasic } from '../src/lib/bean/cli.tools.crudBasic.ts';
+import { CliToolsCrudStart } from '../src/lib/bean/cli.tools.crudStart.ts';
+import { CliToolsMasterDetail } from '../src/lib/bean/cli.tools.masterDetail.ts';
+import crud from '../src/lib/command/tools.crud.ts';
+import basic from '../src/lib/command/tools.crudBasic.ts';
+import start from '../src/lib/command/tools.crudStart.ts';
+
+const packageRoot = fileURLToPath(new URL('../', import.meta.url));
+const templateRoot = path.join(packageRoot, 'cli/templates');
+const editions = { basic: CliToolsCrudBasic, start: CliToolsCrudStart };
+
+// Exercise the authored templates with the production renderer; packaged templates
+// are checked separately because existing dist-cli output can intentionally be stale.
+class SourceTemplate extends LocalTemplate {
+  resolveTemplatePath(_set: string, target: string) {
+    return path.isAbsolute(target) ? target : path.join(templateRoot, target);
+  }
+}
+
+async function fixture<T>(fn: (root: string) => Promise<T>) {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'crud-analysis-'));
+  try {
+    return await fn(root);
+  } finally {
+    await fs.rm(root, { recursive: true, force: true });
+  }
+}
+
+async function makeCli(
+  root: string,
+  Class: typeof CliToolsCrudBasic | typeof CliToolsCrudStart | typeof CliToolsCrud,
+  Template: typeof LocalTemplate = SourceTemplate,
+) {
+  const moduleRoot = path.join(root, 'module');
+  await fs.mkdir(path.join(moduleRoot, 'src/bean'), { recursive: true });
+  await fs.mkdir(path.join(moduleRoot, 'src/config/locale'), { recursive: true });
+  await fs.writeFile(
+    path.join(moduleRoot, 'package.json'),
+    JSON.stringify({ type: 'module', vonaModule: { fileVersion: 0 } }),
+  );
+  await fs.writeFile(
+    path.join(moduleRoot, 'src/bean/meta.index.ts'),
+    "import { Meta } from 'vona-module-a-meta';\n@Meta({ indexes: {} }) class MetaIndex {}\n",
+  );
+  await fs.writeFile(
+    path.join(moduleRoot, 'src/bean/meta.version.ts'),
+    'class MetaVersion { async update(_options: IMetaVersionUpdateOptions) {} }\n',
+  );
+  for (const locale of ['en-us', 'zh-cn']) {
+    await fs.writeFile(
+      path.join(moduleRoot, `src/config/locale/${locale}.ts`),
+      'export default {};\n',
+    );
+  }
+  const argv = {
+    _: [],
+    module: 'test-record',
+    resourceName: 'record',
+    projectPath: root,
+  };
+  const cli = new Class({ context: { argv } } as never);
+  cli.modulesMeta = { modules: { 'test-record': { root: moduleRoot } } } as never;
+  cli.__template = new Template(cli);
+  cli.console.log = async () => {};
+  cli.helper.formatFile = async () => {};
+  const invocations: string[][] = [];
+  cli.helper.invokeCli = async args => {
+    invocations.push(args);
+  };
+  return { cli, moduleRoot, invocations };
+}
+
+async function filesUnder(root: string): Promise<string[]> {
+  const files: string[] = [];
+  for (const entry of await fs.readdir(root, { withFileTypes: true })) {
+    if (entry.isDirectory()) {
+      files.push(
+        ...(await filesUnder(path.join(root, entry.name))).map(file => `${entry.name}/${file}`),
+      );
+    } else {
+      files.push(entry.name);
+    }
+  }
+  return files.sort();
+}
+
+async function read(root: string, file: string) {
+  return await fs.readFile(path.join(root, file), 'utf8');
+}
+
+describe('default CRUD analysis generation', { concurrency: false }, () => {
+  it('removes analysis flags from command options and usage without adding questions', () => {
+    for (const definition of [crud, basic, start]) {
+      assert.deepEqual(Object.keys(definition.options), ['module']);
+      assert.doesNotMatch(definition.info.usage, /--aggregate|--groupBy/);
+      assert.deepEqual(Object.keys(definition.groups.default.questions), [
+        'resourceName',
+        'module',
+      ]);
+    }
+  });
+
+  for (const [edition, Class] of Object.entries(editions)) {
+    it(`${edition}: generates both actions with one finite name/count policy by default`, async () =>
+      fixture(async root => {
+        const { cli, moduleRoot, invocations } = await makeCli(root, Class);
+        await cli.execute();
+        const files = await filesUnder(moduleRoot);
+        for (const file of [
+          'src/lib/recordAnalysis.ts',
+          'test/recordAnalysis.test.ts',
+          'src/dto/recordGroupResItem.tsx',
+          'src/dto/recordAggregateRes.tsx',
+        ]) {
+          assert.ok(files.includes(file), file);
+        }
+        assert.equal(
+          files.some(file => file.includes('AnalysisReq')),
+          false,
+        );
+        assert.deepEqual(invocations, [[':tools:metadata', 'test-record']]);
+        const controller = await read(moduleRoot, 'src/controller/record.ts');
+        const service = await read(moduleRoot, 'src/service/record.ts');
+        const req = await read(moduleRoot, 'src/dto/recordSelectReq.tsx');
+        const policy = await read(moduleRoot, 'src/lib/recordAnalysis.ts');
+        assert.doesNotMatch(controller, /AnalysisReq|\$schema|dataScope/);
+        assert.ok(
+          controller.includes(
+            'async select(@Arg.filter(DtoRecordSelectReq) params: IQueryParams<ModelRecord>)',
+          ),
+        );
+        assert.match(req, /\$Dto.queryPage\(EntityRecord, \['name', 'createdAt'\]\)/);
+        assert.match(req, /analysis: recordAnalysis/);
+        assert.match(req, /import \{ recordAnalysis \} from '\.\.\/lib\/recordAnalysis\.ts'/);
+        assert.match(
+          policy,
+          /export const recordAnalysis = \$defineAnalysis\(\(\) => ModelRecord, \{/,
+        );
+        assert.match(policy, /groups: \['name'\]/);
+        assert.match(policy, /aggrs: \{ count: \['\*'\] \}/);
+        assert.match(policy, /group: \{ groups: \['name'\], aggrs: \{ count: \['\*'\] \} \}/);
+        assert.match(policy, /aggregate: \{ aggrs: \{ count: \['\*'\] \} \}/);
+        assert.match(policy, /limits: \{ maxGroups: 3, maxMetrics: 10, maxGroupRows: 1000 \}/);
+        assert.doesNotMatch(policy, /description|AnalysisAggrs|AnalysisGroup/);
+        assert.doesNotMatch(
+          service,
+          /\.\.\.params|\.group\(|\.aggregate\(|items\.map|Object\.hasOwn|normalizeRecordCount|count_all:/,
+        );
+        assert.equal(controller.match(/actionInherit: 'select'/g)?.length, 2);
+        for (const action of ['group', 'aggregate']) {
+          const mode = action === 'group' ? 'Group' : 'Aggregate';
+          assert.ok(
+            controller.includes(
+              `async ${action}(@Arg.filter(DtoRecordSelectReq, { mode: '${action}' }) params: TypeAnalysis${mode}Params<typeof recordAnalysis>)`,
+            ),
+            `${action} must derive action controls from the same SelectReq policy`,
+          );
+          assert.ok(
+            controller.indexOf(`@Web.get('${action}'`) < controller.indexOf("@Web.get(':id'"),
+          );
+          assert.ok(
+            service.includes(
+              `async ${action}(params?: TypeAnalysis${mode}Params<typeof recordAnalysis>)`,
+            ),
+          );
+          assert.ok(
+            service.includes(
+              `return await $executeAnalysis${mode}(this.scope.model.record, recordAnalysis, params)`,
+            ),
+          );
+        }
+        const groupDto = await read(moduleRoot, 'src/dto/recordGroupResItem.tsx');
+        assert.match(groupDto, /\$Dto\.analysisGroup\(recordAnalysis\)/);
+        assert.doesNotMatch(groupDto, /description|\$Class|\$makeSchema|zod/);
+        assert.match(
+          await read(moduleRoot, 'src/dto/recordAggregateRes.tsx'),
+          /\$Dto\.analysisAggregate\(recordAnalysis\)/,
+        );
+        for (const locale of ['en-us', 'zh-cn']) {
+          const source = await read(moduleRoot, `src/config/locale/${locale}.ts`);
+          assert.match(source, /RecordGroup/);
+          assert.match(source, /RecordAggregate/);
+        }
+        const analysisTest = await read(moduleRoot, 'test/recordAnalysis.test.ts');
+        assert.doesNotMatch(analysisTest, /normalizeRecordCount|normalizes only/);
+        assert.match(
+          analysisTest,
+          /returns default and requested-only string counts with validated controls/,
+        );
+        assert.match(analysisTest, /JSON\.stringify\(\{ count: \['\*'\] \}\)/);
+        assert.match(
+          analysisTest,
+          /The shared policy does not enable analysis controls on ordinary select/,
+        );
+        assert.match(analysisTest, /\{ name \}/);
+        assert.match(analysisTest, /where: \{ id: fixture.id \}/);
+        assert.match(
+          analysisTest,
+          /columns: \['id'\], orders: 'name,desc', pageNo: 2, pageSize: 1/,
+        );
+        assert.match(analysisTest, /assert.rejects\(/);
+        assert.match(analysisTest, /for \(const action of \['group', 'aggregate'\] as const\)/);
+        assert.match(analysisTest, /\['description'\]/);
+        assert.match(analysisTest, /pageNo: 2, pageSize: 0/);
+        const actionTest = await read(moduleRoot, 'test/record.test.ts');
+        if (edition === 'basic') {
+          assert.match(
+            actionTest,
+            /group: \['get', `\$\{moduleApiPath\}\/group`, 'Group Record'\]/,
+          );
+          assert.match(
+            actionTest,
+            /aggregate: \['get', `\$\{moduleApiPath\}\/aggregate`, 'Aggregate Record'\]/,
+          );
+          assert.match(actionTest, /group: `\$\{controllerBeanFullName\}#select`/);
+          assert.match(actionTest, /aggregate: `\$\{controllerBeanFullName\}#select`/);
+        } else {
+          assert.match(
+            actionTest,
+            /const actions = \['create', 'select', 'view', 'update', 'delete', 'group', 'aggregate'\]/,
+          );
+        }
+        for (const file of files.filter(file => /\.tsx?$/.test(file))) {
+          const source = await read(moduleRoot, file);
+          assert.ok(source.trim(), file);
+          assert.doesNotMatch(source, /<%/);
+          const result = ts.transpileModule(source, {
+            fileName: file,
+            reportDiagnostics: true,
+            compilerOptions: {
+              target: ts.ScriptTarget.ESNext,
+              module: ts.ModuleKind.ESNext,
+              experimentalDecorators: true,
+            },
+          });
+          assert.deepEqual(
+            result.diagnostics?.filter(
+              diagnostic => diagnostic.category === ts.DiagnosticCategory.Error,
+            ),
+            [],
+            file,
+          );
+        }
+      }));
+
+    it(`${edition}: aggregate master-detail cleanup removes generated standalone analysis artifacts`, async () =>
+      fixture(async root => {
+        const { cli, moduleRoot } = await makeCli(root, Class);
+        await cli.execute();
+        const masterDetail = new CliToolsMasterDetail({
+          context: {
+            argv: {
+              _detailModule: { root: moduleRoot },
+              detailResourceName: 'record',
+              createdDetailResource: true,
+              detailMode: 'aggregate',
+            },
+          },
+        } as never);
+        (masterDetail as any)._handleAggregateDetailMode(false);
+        const files = await filesUnder(moduleRoot);
+        for (const file of [
+          'src/controller/record.ts',
+          'src/service/record.ts',
+          'src/lib/recordAnalysis.ts',
+          'test/record.test.ts',
+          'test/recordAnalysis.test.ts',
+        ]) {
+          assert.ok(!files.includes(file), file);
+        }
+        assert.ok(!files.some(file => file.startsWith('src/dto/')));
+        assert.ok(files.includes('src/entity/record.tsx'));
+        assert.ok(files.includes('src/model/record.ts'));
+      }));
+  }
+
+  it(
+    'freshly packaged beans and production templates match default source generation',
+    { skip: process.env.CABLOY_TEST_PACKAGED_CLI !== '1' },
+    async () => {
+      // Run after tsc:publish. Published packages ship raw EJS in cli/ and compiled
+      // snippets in dist-cli/; verify both are packaged, not just present locally.
+      const [pack] = JSON.parse(
+        execFileSync('npm', ['pack', '--dry-run', '--ignore-scripts', '--json'], {
+          cwd: packageRoot,
+          encoding: 'utf8',
+        }),
+      ) as { files: { path: string }[] }[];
+      const packedFiles = new Set(pack.files.map(file => file.path));
+      assert.ok(packedFiles.has('dist/index.js'));
+      const { beans, commands } = await import('../dist/index.js');
+      for (const command of ['crud', 'crudBasic', 'crudStart']) {
+        assert.deepEqual(Object.keys(commands.tools[command].options), ['module']);
+        assert.doesNotMatch(commands.tools[command].info.usage, /--aggregate|--groupBy/);
+      }
+      const previousBrand = process.env.CabloyCliBrandName;
+      process.env.CabloyCliBrandName = 'vona';
+      try {
+        for (const [edition, Class] of Object.entries(editions)) {
+          await fixture(async root => {
+            const source = await makeCli(path.join(root, 'source'), Class);
+            const packaged = await makeCli(
+              path.join(root, 'packaged'),
+              beans[edition === 'basic' ? 'tools.crudBasic' : 'tools.crudStart'],
+              LocalTemplate,
+            );
+            for (const target of [
+              `tools/crud${edition === 'basic' ? 'Basic' : 'Start'}/boilerplate`,
+              `tools/crud${edition === 'basic' ? 'Basic' : 'Start'}/snippets`,
+              'tools/crudAnalysis/common',
+              'tools/crudAnalysis/group',
+              'tools/crudAnalysis/aggregate',
+            ]) {
+              const resolved = packaged.cli.template.resolveTemplatePath('api', target);
+              const prefix = target.endsWith('/snippets') ? 'dist-cli/templates' : 'cli/templates';
+              assert.equal(resolved, path.join(packageRoot, prefix, target));
+              const templateFiles = await filesUnder(resolved);
+              assert.ok(templateFiles.length, target);
+              for (const file of templateFiles) {
+                assert.ok(
+                  packedFiles.has(`${prefix}/${target}/${file}`),
+                  `missing packaged template: ${target}/${file}`,
+                );
+              }
+            }
+            await source.cli.execute();
+            await packaged.cli.execute();
+            const files = await filesUnder(source.moduleRoot);
+            assert.deepEqual(await filesUnder(packaged.moduleRoot), files);
+            for (const file of files) {
+              assert.equal(
+                await read(packaged.moduleRoot, file),
+                await read(source.moduleRoot, file),
+                `${edition} ${file}`,
+              );
+            }
+            assert.deepEqual(packaged.invocations, source.invocations);
+          });
+        }
+      } finally {
+        if (previousBrand === undefined) delete process.env.CabloyCliBrandName;
+        else process.env.CabloyCliBrandName = previousBrand;
+      }
+    },
+  );
+
+  it('wrapper invokes default edition generation and refreshes metadata after all rendering', async () => {
+    for (const edition of ['basic', 'start']) {
+      await fixture(async root => {
+        const { cli, moduleRoot, invocations } = await makeCli(root, CliToolsCrud);
+        await fs.writeFile(
+          path.join(root, edition === 'start' ? '__CABLOY_START__' : '__CABLOY_BASIC__'),
+          '',
+        );
+        cli.helper.invokeCli = async args => {
+          invocations.push(args);
+          if (args[0] === ':tools:metadata') {
+            assert.match(await read(moduleRoot, 'src/bean/ssrMenu.record.ts'), /record/);
+          }
+        };
+        await cli.execute();
+        assert.deepEqual(invocations, [
+          [
+            edition === 'start' ? ':tools:crudStart' : ':tools:crudBasic',
+            'record',
+            '--module=test-record',
+            '--nometadata',
+          ],
+          [':tools:metadata', 'test-record'],
+        ]);
+      });
+    }
+  });
+});

package/vona/packages-utils/babel-plugin-vona-bean-module/package.json

@@ -1,6 +1,6 @@
 {
   "name": "babel-plugin-vona-bean-module",
-  "version": "1.1.10",
+  "version": "1.1.11",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "babel-plugin-vona-bean-module",
   "keywords": [

package/vona/packages-vona/vona/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona",
-  "version": "5.1.124",
+  "version": "5.1.125",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "Vona is an intuitive, elegant and powerful Node.js framework for rapidly developing enterprise applications of any size",
   "keywords": [

package/vona/packages-vona/vona-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-core",
-  "version": "5.1.54",
+  "version": "5.1.55",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "vona",
   "keywords": [

package/vona/packages-vona/vona-mock/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-mock",
-  "version": "6.1.54",
+  "version": "6.1.55",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "vona mock",
   "keywords": [

package/vona/pnpm-lock.yaml

@@ -851,8 +851,8 @@ importers:
         specifier: npm:@cabloy/zod@4.3.8
         version: '@cabloy/zod@4.3.8'
       zova:
-        specifier: ^5.1.178
-        version: 5.1.178(debug@4.4.3(supports-color@7.2.0))(supports-color@7.2.0)(typescript@5.9.3)(vue@3.5.43(typescript@5.9.3))
+        specifier: ^5.1.179
+        version: 5.1.179(debug@4.4.3(supports-color@7.2.0))(supports-color@7.2.0)(typescript@5.9.3)(vue@3.5.43(typescript@5.9.3))
       zova-jsx:
         specifier: ^1.1.95
         version: 1.1.95(typescript@5.9.3)
@@ -917,14 +917,14 @@ importers:
         specifier: ^5.1.36
         version: 5.1.36
       zova-module-a-ssr:
-        specifier: ^5.1.42
-        version: 5.1.42
+        specifier: ^5.1.43
+        version: 5.1.43
       zova-module-a-ssrhmr:
         specifier: ^5.1.24
         version: 5.1.24
       zova-module-a-ssrserver:
-        specifier: ^5.1.27
-        version: 5.1.27
+        specifier: ^5.1.28
+        version: 5.1.28
       zova-module-a-style:
         specifier: ^5.1.36
         version: 5.1.36
@@ -1975,7 +1975,7 @@ importers:
         specifier: ^5.0.3
         version: link:modules/a-markdown
       vona-module-a-rbac:
-        specifier: ^5.0.19
+        specifier: ^5.0.20
         version: link:modules/a-rbac
       vona-module-a-socket:
         specifier: workspace:^

package/vona/src/suite/a-training/modules/training-student/src/.metadata/index.ts

@@ -216,8 +216,10 @@ export * from '../dto/detailRecordBase.tsx';
 export * from '../dto/detailRecordMutate.tsx';
 export * from '../dto/detailRecordResItem.tsx';
 export * from '../dto/detailRecordView.tsx';
+export * from '../dto/studentAggregateRes.tsx';
 export * from '../dto/studentCreate.tsx';
 export * from '../dto/studentDeleteBulk.tsx';
+export * from '../dto/studentGroupResItem.tsx';
 export * from '../dto/studentSelectReq.tsx';
 export * from '../dto/studentSelectRes.tsx';
 export * from '../dto/studentSelectResItem.tsx';
@@ -228,8 +230,10 @@ import type { IDtoOptionsDetailRecordBase } from '../dto/detailRecordBase.tsx';
 import type { IDtoOptionsDetailRecordMutate } from '../dto/detailRecordMutate.tsx';
 import type { IDtoOptionsDetailRecordResItem } from '../dto/detailRecordResItem.tsx';
 import type { IDtoOptionsDetailRecordView } from '../dto/detailRecordView.tsx';
+import type { IDtoOptionsStudentAggregateRes } from '../dto/studentAggregateRes.tsx';
 import type { IDtoOptionsStudentCreate } from '../dto/studentCreate.tsx';
 import type { IDtoOptionsStudentDeleteBulk } from '../dto/studentDeleteBulk.tsx';
+import type { IDtoOptionsStudentGroupResItem } from '../dto/studentGroupResItem.tsx';
 import type { IDtoOptionsStudentSelectReq } from '../dto/studentSelectReq.tsx';
 import type { IDtoOptionsStudentSelectRes } from '../dto/studentSelectRes.tsx';
 import type { IDtoOptionsStudentSelectResItem } from '../dto/studentSelectResItem.tsx';
@@ -244,8 +248,10 @@ declare module 'vona-module-a-web' {
 'training-student:detailRecordMutate': IDtoOptionsDetailRecordMutate;
 'training-student:detailRecordResItem': IDtoOptionsDetailRecordResItem;
 'training-student:detailRecordView': IDtoOptionsDetailRecordView;
+'training-student:studentAggregateRes': IDtoOptionsStudentAggregateRes;
 'training-student:studentCreate': IDtoOptionsStudentCreate;
 'training-student:studentDeleteBulk': IDtoOptionsStudentDeleteBulk;
+'training-student:studentGroupResItem': IDtoOptionsStudentGroupResItem;
 'training-student:studentSelectReq': IDtoOptionsStudentSelectReq;
 'training-student:studentSelectRes': IDtoOptionsStudentSelectRes;
 'training-student:studentSelectResItem': IDtoOptionsStudentSelectResItem;
@@ -265,8 +271,10 @@ import type { DtoDetailRecordBase } from '../dto/detailRecordBase.tsx';
 import type { DtoDetailRecordMutate } from '../dto/detailRecordMutate.tsx';
 import type { DtoDetailRecordResItem } from '../dto/detailRecordResItem.tsx';
 import type { DtoDetailRecordView } from '../dto/detailRecordView.tsx';
+import type { DtoStudentAggregateRes } from '../dto/studentAggregateRes.tsx';
 import type { DtoStudentCreate } from '../dto/studentCreate.tsx';
 import type { DtoStudentDeleteBulk } from '../dto/studentDeleteBulk.tsx';
+import type { DtoStudentGroupResItem } from '../dto/studentGroupResItem.tsx';
 import type { DtoStudentSelectReq } from '../dto/studentSelectReq.tsx';
 import type { DtoStudentSelectRes } from '../dto/studentSelectRes.tsx';
 import type { DtoStudentSelectResItem } from '../dto/studentSelectResItem.tsx';
@@ -291,6 +299,10 @@ declare module 'vona-module-training-student' {
       fields?: TypeEntityOptionsFields<DtoDetailRecordView, IDtoOptionsDetailRecordView[TypeSymbolKeyFieldsMore]>;
     }
 
+    export interface IDtoOptionsStudentAggregateRes {
+      fields?: TypeEntityOptionsFields<DtoStudentAggregateRes, IDtoOptionsStudentAggregateRes[TypeSymbolKeyFieldsMore]>;
+    }
+
     export interface IDtoOptionsStudentCreate {
       fields?: TypeEntityOptionsFields<DtoStudentCreate, IDtoOptionsStudentCreate[TypeSymbolKeyFieldsMore]>;
     }
@@ -299,6 +311,10 @@ declare module 'vona-module-training-student' {
       fields?: TypeEntityOptionsFields<DtoStudentDeleteBulk, IDtoOptionsStudentDeleteBulk[TypeSymbolKeyFieldsMore]>;
     }
 
+    export interface IDtoOptionsStudentGroupResItem {
+      fields?: TypeEntityOptionsFields<DtoStudentGroupResItem, IDtoOptionsStudentGroupResItem[TypeSymbolKeyFieldsMore]>;
+    }
+
     export interface IDtoOptionsStudentSelectReq {
       fields?: TypeEntityOptionsFields<DtoStudentSelectReq, IDtoOptionsStudentSelectReq[TypeSymbolKeyFieldsMore]>;
     }
@@ -366,6 +382,8 @@ declare module 'vona-module-a-web' {
     }
 export interface IApiPathGetRecord{
         '/training/student': undefined;
+'/training/student/group': undefined;
+'/training/student/aggregate': undefined;
 '/training/student/:id': undefined;
 '/training/student/summary/:id': undefined;
     }

package/vona/src/suite/a-training/modules/training-student/src/config/locale/en-us.ts

@@ -22,6 +22,8 @@ export default {
   StudentController: 'Student Management',
   StudentCreate: 'Create Student',
   StudentSelect: 'List Students',
+  StudentGroup: 'Group Students',
+  StudentAggregate: 'Aggregate Students',
   StudentView: 'View Student',
   StudentUpdate: 'Update Student',
   StudentSummary: 'View Student Summary',

package/vona/src/suite/a-training/modules/training-student/src/config/locale/zh-cn.ts

@@ -22,6 +22,8 @@ export default {
   StudentController: '学生管理',
   StudentCreate: '创建学生',
   StudentSelect: '查询学生列表',
+  StudentGroup: '学生分组统计',
+  StudentAggregate: '学生统计',
   StudentView: '查看学生',
   StudentUpdate: '更新学生',
   StudentSummary: '查看学生摘要',

package/vona/src/suite/a-training/modules/training-student/src/controller/student.ts

@@ -1,5 +1,9 @@
 import type { TableIdentity } from 'table-identity';
-import type { IQueryParams } from 'vona-module-a-orm';
+import type {
+  IQueryParams,
+  TypeAnalysisAggregateParams,
+  TypeAnalysisGroupParams,
+} from 'vona-module-a-orm';
 import type { IDecoratorControllerOptions } from 'vona-module-a-web';
 
 import { BeanBase } from 'vona';
@@ -9,11 +13,14 @@ import { Passport } from 'vona-module-a-user';
 import { Arg, Controller, Web } from 'vona-module-a-web';
 import { z } from 'zod';
 
+import type { studentAnalysis } from '../lib/studentAnalysis.ts';
 import type { ModelStudent } from '../model/student.ts';
 
 import { $locale } from '../.metadata/locales.ts';
+import { DtoStudentAggregateRes } from '../dto/studentAggregateRes.tsx';
 import { DtoStudentCreate } from '../dto/studentCreate.tsx';
 import { DtoStudentDeleteBulk } from '../dto/studentDeleteBulk.tsx';
+import { DtoStudentGroupResItem } from '../dto/studentGroupResItem.tsx';
 import { DtoStudentSelectReq } from '../dto/studentSelectReq.tsx';
 import { DtoStudentSelectRes } from '../dto/studentSelectRes.tsx';
 import { DtoStudentSummary } from '../dto/studentSummary.tsx';
@@ -44,6 +51,26 @@ export class ControllerStudent extends BeanBase {
     return await this.scope.service.student.select(params);
   }
 
+  @Web.get('group', { summary: $locale('StudentGroup') })
+  @Api.body(v.array(DtoStudentGroupResItem))
+  @Passport.rbac({ actionInherit: 'select' })
+  async group(
+    @Arg.filter(DtoStudentSelectReq, { mode: 'group' })
+    params: TypeAnalysisGroupParams<typeof studentAnalysis>,
+  ): Promise<DtoStudentGroupResItem[]> {
+    return await this.scope.service.student.group(params);
+  }
+
+  @Web.get('aggregate', { summary: $locale('StudentAggregate') })
+  @Api.body(DtoStudentAggregateRes)
+  @Passport.rbac({ actionInherit: 'select' })
+  async aggregate(
+    @Arg.filter(DtoStudentSelectReq, { mode: 'aggregate' })
+    params: TypeAnalysisAggregateParams<typeof studentAnalysis>,
+  ): Promise<DtoStudentAggregateRes> {
+    return await this.scope.service.student.aggregate(params);
+  }
+
   @Web.get(':id', { summary: $locale('StudentView') })
   @Api.body(v.optional(), v.object(DtoStudentView))
   @Core.serializer()

package/vona/src/suite/a-training/modules/training-student/src/dto/studentAggregateRes.tsx

@@ -0,0 +1,11 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+
+import { $Dto } from 'vona-module-a-orm';
+import { Dto } from 'vona-module-a-web';
+
+import { studentAnalysis } from '../lib/studentAnalysis.ts';
+
+export interface IDtoOptionsStudentAggregateRes extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsStudentAggregateRes>()
+export class DtoStudentAggregateRes extends $Dto.analysisAggregate(studentAnalysis) {}

package/vona/src/suite/a-training/modules/training-student/src/dto/studentGroupResItem.tsx

@@ -0,0 +1,11 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+
+import { $Dto } from 'vona-module-a-orm';
+import { Dto } from 'vona-module-a-web';
+
+import { studentAnalysis } from '../lib/studentAnalysis.ts';
+
+export interface IDtoOptionsStudentGroupResItem extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsStudentGroupResItem>()
+export class DtoStudentGroupResItem extends $Dto.analysisGroup(studentAnalysis) {}

package/vona/src/suite/a-training/modules/training-student/src/dto/studentSelectReq.tsx

@@ -8,10 +8,12 @@ import { ZovaRender } from 'zova-rest-cabloy-basic-admin';
 
 import { $locale } from '../.metadata/locales.ts';
 import { EntityStudent, studentLevelItems } from '../entity/student.tsx';
+import { studentAnalysis } from '../lib/studentAnalysis.ts';
 
 export interface IDtoOptionsStudentSelectReq extends IDecoratorDtoOptions {}
 
 @Dto<IDtoOptionsStudentSelectReq>({
+  analysis: studentAnalysis,
   openapi: { filter: { table: 'trainingStudent' } },
   fields: {
     name: $makeSchema(v.optional(), z.string()),

package/vona/src/suite/a-training/modules/training-student/src/lib/studentAnalysis.ts

@@ -0,0 +1,12 @@
+import { $defineAnalysis } from 'vona-module-a-orm';
+
+import { ModelStudent } from '../model/student.ts';
+
+export const studentAnalysis = $defineAnalysis(() => ModelStudent, {
+  groups: ['level'],
+  aggrs: { count: ['*', 'imageId'] },
+  defaults: {
+    group: { groups: ['level'], aggrs: { count: ['*'] } },
+    aggregate: { aggrs: { count: ['*', 'imageId'] } },
+  },
+});