cabloy 5.1.249 → 5.1.251

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'] } },
+  },
+});

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

@@ -1,11 +1,18 @@
 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 { BeanBase } from 'vona';
 import { Service } from 'vona-module-a-bean';
 import { Core } from 'vona-module-a-core';
+import { $executeAnalysisAggregate, $executeAnalysisGroup } from 'vona-module-a-orm';
 
+import type { DtoStudentAggregateRes } from '../dto/studentAggregateRes.tsx';
 import type { DtoStudentCreate } from '../dto/studentCreate.tsx';
+import type { DtoStudentGroupResItem } from '../dto/studentGroupResItem.tsx';
 import type { DtoStudentSelectRes } from '../dto/studentSelectRes.tsx';
 import type { DtoStudentSummary } from '../dto/studentSummary.tsx';
 import type { DtoStudentUpdate } from '../dto/studentUpdate.tsx';
@@ -13,6 +20,8 @@ import type { DtoStudentView } from '../dto/studentView.tsx';
 import type { EntityStudent } from '../entity/student.tsx';
 import type { ModelStudent } from '../model/student.ts';
 
+import { studentAnalysis } from '../lib/studentAnalysis.ts';
+
 type StudentContentInput = {
   descriptionMarkdown?: string;
 };
@@ -43,6 +52,18 @@ export class ServiceStudent extends BeanBase {
     return await this.scope.model.student.selectAndCount(params);
   }
 
+  async group(
+    params?: TypeAnalysisGroupParams<typeof studentAnalysis>,
+  ): Promise<DtoStudentGroupResItem[]> {
+    return await $executeAnalysisGroup(this.scope.model.student, studentAnalysis, params);
+  }
+
+  async aggregate(
+    params?: TypeAnalysisAggregateParams<typeof studentAnalysis>,
+  ): Promise<DtoStudentAggregateRes> {
+    return await $executeAnalysisAggregate(this.scope.model.student, studentAnalysis, params);
+  }
+
   async view(id: TableIdentity): Promise<DtoStudentView | undefined> {
     return await this.scope.model.student.getById(id, {
       include: getStudentRelationsInclude(),

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

@@ -78,6 +78,8 @@ describe('student.test.ts', { concurrency: false }, () => {
       const expectedSummaries = {
         create: ['post', '/api/training/student', 'Create Student'],
         select: ['get', '/api/training/student', 'List Students'],
+        group: ['get', '/api/training/student/group', 'Group Students'],
+        aggregate: ['get', '/api/training/student/aggregate', 'Aggregate Students'],
         view: ['get', '/api/training/student/{id}', 'View Student'],
         update: ['patch', '/api/training/student/{id}', 'Update Student'],
         summary: ['get', '/api/training/student/summary/{id}', 'View Student Summary'],
@@ -685,6 +687,8 @@ describe('student.test.ts', { concurrency: false }, () => {
       const expectedInherits = {
         create: undefined,
         select: undefined,
+        group: `${controllerBeanFullName}#select`,
+        aggregate: `${controllerBeanFullName}#select`,
         view: undefined,
         update: undefined,
         summary: `${controllerBeanFullName}#view`,

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

@@ -0,0 +1,422 @@
+import type { TableIdentity } from 'table-identity';
+import type { ISchemaObjectExtensionField } from 'vona-module-a-openapi';
+
+import { ZodMetadata } from '@cabloy/zod-openapi';
+import assert from 'node:assert';
+import { randomUUID } from 'node:crypto';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { describe, it } from 'node:test';
+import { app } from 'vona-mock';
+import { $schema } from 'vona-module-a-openapiutils';
+
+import { DtoStudentAggregateRes } from '../src/dto/studentAggregateRes.tsx';
+import { DtoStudentGroupResItem } from '../src/dto/studentGroupResItem.tsx';
+import { DtoStudentSelectReq } from '../src/dto/studentSelectReq.tsx';
+
+type StudentGroup = { level: number; count_all: string };
+type StudentAggregate = { count_all: string; count_imageId: string };
+
+async function dropStudents(ids: TableIdentity[]) {
+  const student = app.scope('training-student');
+  for (const id of ids.toReversed()) {
+    await student.model.studentContent.delete({ studentId: id }, { disableDeleted: true });
+    await student.model.student.deleteById(id, { disableDeleted: true });
+  }
+}
+
+async function readAnalysis(query: Record<string, unknown>) {
+  const groups: StudentGroup[] = await app.bean.executor.performAction(
+    'get',
+    '/training/student/group',
+    { query },
+  );
+  const aggregate: StudentAggregate = await app.bean.executor.performAction(
+    'get',
+    '/training/student/aggregate',
+    { query },
+  );
+  return {
+    groups: groups.sort((a, b) => a.level - b.level),
+    aggregate,
+  };
+}
+
+describe('studentAnalysis.test.ts', { concurrency: false }, () => {
+  it('keeps select unchanged and emits optional analysis response field supersets', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const request = $schema(DtoStudentSelectReq);
+      const requestMetadata = ZodMetadata.getOpenapiMetadata(request) as
+        | ISchemaObjectExtensionField
+        | undefined;
+      assert.equal(requestMetadata?.filter?.table, 'trainingStudent');
+      assert.equal(request.safeParse({}).success, true);
+      assert.equal(
+        request.safeParse({ name: 'Student', level: 2, createdAt: '2026-03-10~2026-03-10' })
+          .success,
+        true,
+      );
+      assert.equal(
+        request.safeParse({
+          where: { level: { _gte_: 2 } },
+          columns: ['name'],
+          orders: 'level,desc',
+          pageNo: 2,
+          pageSize: 1,
+        }).success,
+        true,
+      );
+      assert.equal(request.safeParse({ pageSize: 0 }).success, false);
+      // Filter transforms belong to runtime schema metadata; public OpenAPI strips them.
+      const createdAtSchema = ZodMetadata.getFieldSchema(request, 'createdAt');
+      assert.ok(createdAtSchema);
+      const createdAtMetadata = ZodMetadata.getOpenapiMetadata(createdAtSchema) as
+        | ISchemaObjectExtensionField
+        | undefined;
+      assert.equal(createdAtMetadata?.filter?.transform?.[0], 'a-web:dateRange');
+      for (const [DtoClass, expectedFields] of [
+        [
+          DtoStudentSelectReq,
+          ['columns', 'createdAt', 'level', 'name', 'orders', 'pageNo', 'pageSize', 'where'],
+        ],
+        [DtoStudentGroupResItem, ['count_all', 'count_imageId', 'level']],
+        [DtoStudentAggregateRes, ['count_all', 'count_imageId']],
+      ] as const) {
+        const document = await app.bean.openapi.generateJsonOfClass(DtoClass, 'V31');
+        const component = Object.values(document.components!.schemas!).find(
+          item => !('$ref' in item) && Object.hasOwn(item.properties ?? {}, expectedFields[0]),
+        );
+        assert.ok(component && !('$ref' in component));
+        assert.deepEqual(Object.keys(component.properties ?? {}).sort(), [...expectedFields]);
+        for (const field of expectedFields.filter(field => field.startsWith('count_'))) {
+          const schema = component.properties![field];
+          assert.ok(schema && !('$ref' in schema));
+          // v.optional() emits a nullable string in the V31 schema dialect.
+          assert.deepEqual(schema.type, ['string', 'null']);
+        }
+      }
+      assert.deepEqual($schema(DtoStudentGroupResItem).parse({ count_imageId: '1' }), {
+        count_imageId: '1',
+      });
+      assert.deepEqual($schema(DtoStudentGroupResItem).parse({ level: 2, count_all: '3' }), {
+        level: 2,
+        count_all: '3',
+      });
+      assert.deepEqual(
+        $schema(DtoStudentAggregateRes).parse({ count_all: '3', count_imageId: '1' }),
+        { count_all: '3', count_imageId: '1' },
+      );
+    });
+  });
+
+  it('filters real API results and refreshes warmed counts after create, update and soft delete', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const jwt = await app.bean.passport.signinMock();
+      const ids: TableIdentity[] = [];
+      const name = `Analysis-${randomUUID()}`;
+      let imageId: TableIdentity | undefined;
+      let directory: string | undefined;
+      const student = app.scope('training-student');
+      try {
+        const empty = {
+          groups: [],
+          aggregate: { count_all: '0', count_imageId: '0' },
+        };
+        assert.deepEqual(await readAnalysis({ name }), empty);
+        directory = await mkdtemp(path.join(os.tmpdir(), 'student-analysis-'));
+        const file = path.join(directory, 'student.png');
+        await writeFile(
+          file,
+          Buffer.from(
+            'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIHWP4z8DwHwAFAAH/e+m+7wAAAABJRU5ErkJggg==',
+            'base64',
+          ),
+        );
+        const image = await app.bean.image.upload(
+          'image-native:native',
+          { file, filename: 'student.png', contentType: 'image/png' },
+          { imageScene: 'training-student:studentImage' },
+        );
+        imageId = image.id;
+        for (const [index, level] of [1, 1, 2].entries()) {
+          const id = await app.bean.executor.performAction('post', '/training/student', {
+            body: {
+              name: `${name}-${index}`,
+              mobile: '13812345678',
+              level,
+              ...(index === 0 ? { imageId } : {}),
+            },
+          });
+          ids.push(id);
+          await student.model.student.updateById(id, {
+            createdAt: new Date(index === 2 ? '2026-03-11T12:00:00Z' : '2026-03-10T12:00:00Z'),
+          });
+        }
+        const initial = {
+          groups: [
+            { level: 1, count_all: '2' },
+            { level: 2, count_all: '1' },
+          ],
+          aggregate: { count_all: '3', count_imageId: '1' },
+        };
+        assert.deepEqual(await readAnalysis({ name }), initial);
+        assert.deepEqual(await readAnalysis({ name }), initial);
+        assert.deepEqual(
+          await app.bean.executor.performAction('get', '/training/student/group', {
+            query: { name, aggrs: { count: ['imageId'] } },
+          }),
+          [
+            { level: 1, count_imageId: '1' },
+            { level: 2, count_imageId: '0' },
+          ],
+        );
+        assert.deepEqual(
+          await student.service.student.group({
+            where: { name: { _startsWith_: name } },
+            groups: ['level'],
+          }),
+          initial.groups,
+        );
+        assert.deepEqual(
+          await student.service.student.aggregate({
+            where: { name: { _startsWith_: name } },
+            aggrs: { count: ['imageId'] },
+          }),
+          { count_imageId: '1' },
+        );
+        const selected = await app.bean.executor.performAction('get', '/training/student', {
+          query: { name, pageSize: 1 },
+        });
+        assert.equal(selected.total, '3');
+        assert.equal(selected.list.length, 1);
+        assert.equal(Object.hasOwn(selected.list[0], 'count_all'), false);
+        assert.deepEqual(await readAnalysis({ name, level: 2 }), {
+          groups: [{ level: 2, count_all: '1' }],
+          aggregate: { count_all: '1', count_imageId: '0' },
+        });
+        assert.deepEqual(await readAnalysis({ name, createdAt: '2026-03-10~2026-03-10' }), {
+          groups: [{ level: 1, count_all: '2' }],
+          aggregate: { count_all: '2', count_imageId: '1' },
+        });
+        assert.deepEqual(await readAnalysis({ name: `${name}-absent` }), empty);
+
+        // Dispatch concrete URLs through the HTTP router, where /:id could otherwise win.
+        for (const [action, expected] of [
+          ['group', initial.groups],
+          ['aggregate', initial.aggregate],
+        ] as const) {
+          const url = new URL(app.util.getAbsoluteUrlByApiPath(`/training/student/${action}`));
+          url.searchParams.set('name', name);
+          const response = await fetch(url, {
+            headers: {
+              Accept: 'application/json',
+              Authorization: `Bearer ${jwt.accessToken}`,
+            },
+          });
+          assert.equal(response.status, 200);
+          const body = await response.json();
+          assert.equal(body.code, 0, JSON.stringify(body));
+          const actual =
+            action === 'group'
+              ? body.data.sort((a: StudentGroup, b: StudentGroup) => a.level - b.level)
+              : body.data;
+          assert.deepEqual(actual, expected);
+        }
+        for (const [action, controls, expected] of [
+          [
+            'group',
+            { groups: ['level'], aggrs: { count: ['imageId'] } },
+            [
+              { level: 1, count_imageId: '1' },
+              { level: 2, count_imageId: '0' },
+            ],
+          ],
+          ['aggregate', { aggrs: { count: ['*'] } }, { count_all: '3' }],
+        ] as const) {
+          const url = new URL(app.util.getAbsoluteUrlByApiPath(`/training/student/${action}`));
+          url.searchParams.set('name', name);
+          for (const [key, value] of Object.entries(controls)) {
+            url.searchParams.set(key, JSON.stringify(value));
+          }
+          const response = await fetch(url, {
+            headers: {
+              Accept: 'application/json',
+              Authorization: `Bearer ${jwt.accessToken}`,
+            },
+          });
+          assert.equal(response.status, 200);
+          const body = await response.json();
+          assert.equal(body.code, 0, JSON.stringify(body));
+          assert.deepEqual(body.data, expected);
+        }
+        for (const [action, field, value] of [
+          ['group', 'groups', 'level'],
+          ['group', 'groups', '["level"'],
+          ['group', 'aggrs', '{"count":'],
+          ['aggregate', 'aggrs', '{"count":'],
+        ]) {
+          const url = new URL(app.util.getAbsoluteUrlByApiPath(`/training/student/${action}`));
+          url.searchParams.set('name', name);
+          url.searchParams.set(field, value);
+          const response = await fetch(url, {
+            headers: {
+              Accept: 'application/json',
+              Authorization: `Bearer ${jwt.accessToken}`,
+            },
+          });
+          assert.equal(response.status, 422);
+          assert.equal((await response.json()).code, 422);
+        }
+        for (const [action, controls] of [
+          ['', { groups: ['level'] }],
+          ['', { aggrs: { count: ['*'] } }],
+          ['group', { groups: [] }],
+          ['group', { groups: ['level', 'level'] }],
+          ['group', { groups: ['name'] }],
+          ['group', { aggrs: {} }],
+          ['group', { aggrs: { count: [] } }],
+          ['group', { aggrs: { count: ['*', '*'] } }],
+          ['group', { aggrs: { count: ['mobile'] } }],
+          ['group', { aggrs: { sum: ['level'] } }],
+          ['aggregate', { groups: ['level'] }],
+          ['aggregate', { groups: [] }],
+        ] as const) {
+          await assert.rejects(
+            () =>
+              app.bean.executor.performAction(
+                'get',
+                action === '' ? '/training/student' : `/training/student/${action}`,
+                {
+                  query: { name, ...controls },
+                },
+              ),
+            (error: { code?: number }) => error.code === 422,
+          );
+        }
+        await assert.rejects(
+          () => student.service.student.group({ groups: ['name'] } as never),
+          (error: { code?: number }) => error.code === 422,
+        );
+        await assert.rejects(
+          () => student.service.student.aggregate({ groups: ['level'] } as never),
+          (error: { code?: number }) => error.code === 422,
+        );
+        assert.deepEqual(
+          await readAnalysis({
+            name,
+            columns: ['name'],
+            orders: 'level,desc',
+            pageNo: 2,
+            pageSize: 1,
+          }),
+          initial,
+        );
+        // Raw predicates are shared with select and take precedence over named filters.
+        assert.deepEqual(
+          await readAnalysis({
+            name,
+            level: 1,
+            where: { level: 2 },
+          }),
+          {
+            groups: [{ level: 2, count_all: '1' }],
+            aggregate: { count_all: '1', count_imageId: '0' },
+          },
+        );
+        for (const action of ['group', 'aggregate'] as const) {
+          for (const query of [
+            { name, pageSize: 0 },
+            { name, pageNo: 0 },
+          ]) {
+            await assert.rejects(
+              () =>
+                app.bean.executor.performAction('get', `/training/student/${action}`, { query }),
+              (error: { code?: number }) => error.code === 422,
+            );
+          }
+        }
+        await app.bean.executor.performAction('patch', '/training/student/:id', {
+          params: { id: ids[1] },
+          body: { name: `${name}-1`, mobile: '13812345678', level: 2 },
+        });
+        assert.deepEqual(await readAnalysis({ name }), {
+          groups: [
+            { level: 1, count_all: '1' },
+            { level: 2, count_all: '2' },
+          ],
+          aggregate: { count_all: '3', count_imageId: '1' },
+        });
+        await app.bean.executor.performAction('delete', '/training/student/:id', {
+          params: { id: ids[0] },
+        });
+        assert.equal(
+          (await student.model.student.getById(ids[0], { disableDeleted: true }))?.deleted,
+          true,
+        );
+        assert.deepEqual(await readAnalysis({ name }), {
+          groups: [{ level: 2, count_all: '2' }],
+          aggregate: { count_all: '2', count_imageId: '0' },
+        });
+      } finally {
+        try {
+          await dropStudents(ids);
+          if (imageId !== undefined) await app.bean.image.delete(imageId);
+        } finally {
+          if (directory) await rm(directory, { recursive: true, force: true });
+          await app.bean.passport.signout();
+        }
+      }
+    });
+  });
+
+  it('excludes students owned by another instance', async () => {
+    // Keep the full UUID within the VARCHAR(50) name column.
+    const name = `Analysis-${randomUUID()}`;
+    const ids: TableIdentity[] = [];
+    try {
+      await app.bean.executor.mockCtx(async () => {
+        await app.bean.passport.signinMock();
+        try {
+          ids.push(
+            await app.bean.executor.performAction('post', '/training/student', {
+              body: { name, mobile: '13812345678', level: 3 },
+            }),
+          );
+          assert.deepEqual(await readAnalysis({ name }), {
+            groups: [{ level: 3, count_all: '1' }],
+            aggregate: { count_all: '1', count_imageId: '0' },
+          });
+        } finally {
+          await app.bean.passport.signout();
+        }
+      });
+      await app.bean.executor.mockCtx(
+        async () => {
+          await app.bean.passport.signinMock();
+          try {
+            assert.deepEqual(await readAnalysis({ name }), {
+              groups: [],
+              aggregate: { count_all: '0', count_imageId: '0' },
+            });
+          } finally {
+            await app.bean.passport.signout();
+          }
+        },
+        { instanceName: 'shareTest' as any },
+      );
+      await app.bean.executor.mockCtx(async () => {
+        assert.deepEqual(
+          await app.scope('training-student').service.student.aggregate({
+            where: { name },
+          }),
+          { count_all: '1', count_imageId: '0' },
+        );
+      });
+    } finally {
+      await app.bean.executor.mockCtx(async () => {
+        await dropStudents(ids);
+      });
+    }
+  });
+});

package/vona/src/suite-vendor/a-cabloy/modules/a-rbac/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-rbac",
-  "version": "5.0.19",
+  "version": "5.0.20",
   "description": "",
   "keywords": [
     "Vona Module"

package/vona/src/suite-vendor/a-cabloy/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-suite-a-cabloy",
-  "version": "5.1.71",
+  "version": "5.1.72",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "author": "",
@@ -10,7 +10,7 @@
     "vona-module-a-cabloy": "workspace:^",
     "vona-module-a-layoutprofile": "^5.0.2",
     "vona-module-a-markdown": "^5.0.3",
-    "vona-module-a-rbac": "^5.0.19",
+    "vona-module-a-rbac": "^5.0.20",
     "vona-module-a-socket": "workspace:^",
     "vona-module-a-ssr": "workspace:^",
     "vona-module-a-ssrhmr": "workspace:^"

package/vona/src/suite-vendor/a-captcha/modules/a-captcha/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-captcha",
-  "version": "5.1.16",
+  "version": "5.1.17",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "keywords": [

package/vona/src/suite-vendor/a-captcha/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-suite-a-captcha",
-  "version": "5.1.20",
+  "version": "5.1.21",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "author": "",

package/vona/src/suite-vendor/a-vona/modules/a-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-core",
-  "version": "5.1.70",
+  "version": "5.1.71",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "keywords": [

package/vona/src/suite-vendor/a-vona/modules/a-hmr/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-hmr",
-  "version": "5.1.16",
+  "version": "5.1.17",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "keywords": [

package/vona/src/suite-vendor/a-vona/modules/a-locale/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-locale",
-  "version": "5.1.13",
+  "version": "5.1.14",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "keywords": [

package/vona/src/suite-vendor/a-vona/modules/a-openapi/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-openapi",
-  "version": "5.1.27",
+  "version": "5.1.28",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "keywords": [

package/vona/src/suite-vendor/a-vona/modules/a-openapiutils/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-openapiutils",
-  "version": "5.1.24",
+  "version": "5.1.25",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "keywords": [

package/vona/src/suite-vendor/a-vona/modules/a-openapiutils/src/lib/utils.ts

@@ -38,7 +38,7 @@ export function getTargetDecoratorDtoOpenapi(
       replace: true,
     });
   }
-  return appMetadata.getOwnMetadata(SymbolDecoratorDtoOpenapi, target);
+  return appMetadata.getMetadata(SymbolDecoratorDtoOpenapi, target);
 }
 
 export function setTargetDecoratorDtoOpenapi(

package/vona/src/suite-vendor/a-vona/modules/a-orm/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-orm",
-  "version": "5.1.39",
+  "version": "5.1.40",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "db",
   "keywords": [