cabloy 5.1.131 → 5.1.133

package/vona/src/suite/a-commerce/modules/commerce-trade/test/stockPresentation.test.ts

@@ -0,0 +1,324 @@
+import type { DtoStockAdjust } from 'vona-module-commerce-trade';
+
+import assert from 'node:assert';
+import { randomUUID } from 'node:crypto';
+import { after, before, describe, it } from 'node:test';
+import { acquireTestLock, app } from 'vona-mock';
+import {
+  DtoStockAuditSelectResItem,
+  DtoStockAuditView,
+  DtoStockBalanceSelectResItem,
+  DtoStockBalanceView,
+} from 'vona-module-commerce-trade';
+
+function findComponent(apiJson: any, predicate: (properties: any) => boolean) {
+  return Object.values(apiJson.components!.schemas as any).find(item => {
+    return predicate((item as any).properties);
+  }) as any;
+}
+
+function getListFilter(component: any) {
+  const page = component?.rest?.blocks?.[0];
+  const [filter, table, pager] = page?.options?.blocks ?? [];
+  assert.equal(page?.render, 'basic-page:blockPage');
+  assert.equal(filter?.render, 'basic-page:blockFilter');
+  assert.equal(table?.render, 'basic-page:blockTable');
+  assert.equal(pager?.render, 'basic-page:blockPager');
+  return filter;
+}
+
+function getEntryToolbar(component: any) {
+  const pageEntry = component?.rest?.blocks?.[0];
+  const formBlock = pageEntry?.options?.blocks?.[0];
+  const toolbarBlock = pageEntry?.options?.blocks?.[1];
+  assert.equal(pageEntry?.render, 'basic-pageentry:blockPageEntry');
+  assert.equal(formBlock?.render, 'basic-pageentry:blockForm');
+  assert.equal(toolbarBlock?.render, 'basic-pageentry:blockToolbarRow');
+  return toolbarBlock;
+}
+
+function assertFilter(component: any) {
+  const filter = getListFilter(component);
+  const section = filter.options.blocks[0].options.formLayout.children[0];
+  assert.equal(section.type, 'section');
+  assert.equal(section.layout, 'flow');
+  assert.deepEqual(
+    section.children.slice(0, 2).map((field: any) => field.name),
+    ['skuId', 'createdAt'],
+  );
+  assert.equal(section.children[2].block.render, 'basic-page:blockFilterActions');
+}
+
+interface IStockFixture {
+  categoryId: number;
+  productId: number;
+  skuId: number;
+}
+
+type IStockFixturePartial = Partial<IStockFixture>;
+
+async function dropStockFixture(fixture: IStockFixturePartial | undefined) {
+  if (!fixture) return;
+  const trade = app.scope('commerce-trade');
+  const catalog = app.scope('commerce-catalog');
+  if (fixture.skuId !== undefined) {
+    await trade.model.stockAudit.delete({ skuId: fixture.skuId });
+    await trade.model.stockReservation.delete({ skuId: fixture.skuId });
+    await trade.model.stockBalance.delete({ skuId: fixture.skuId });
+    await catalog.model.sku.delete({ id: fixture.skuId });
+  }
+  if (fixture.productId !== undefined) {
+    await catalog.model.product.delete({ id: fixture.productId });
+  }
+  if (fixture.categoryId !== undefined) {
+    await catalog.model.category.delete({ id: fixture.categoryId });
+  }
+}
+
+async function createSku(suffix: string): Promise<IStockFixture> {
+  const fixture: IStockFixturePartial = {};
+  try {
+    fixture.categoryId = await app.bean.executor.performAction(
+      'post',
+      '/commerce/catalog/category',
+      {
+        body: { name: `presentation-stock-category-${suffix}`, published: true },
+      },
+    );
+    fixture.productId = await app.bean.executor.performAction('post', '/commerce/catalog/product', {
+      body: {
+        categoryId: fixture.categoryId,
+        title: `presentation-stock-product-${suffix}`,
+        published: true,
+      },
+    });
+    fixture.skuId = await app.bean.executor.performAction('post', '/commerce/catalog/sku', {
+      body: {
+        productId: fixture.productId,
+        code: `presentation-stock-sku-${suffix}`,
+        priceCents: 100,
+        lifecycle: 'active',
+      },
+    });
+    return fixture as IStockFixture;
+  } catch (error) {
+    await dropStockFixture(fixture);
+    throw error;
+  }
+}
+
+function stockAdjust(skuId: number, suffix: string): DtoStockAdjust {
+  return {
+    skuId,
+    delta: 7,
+    reason: `presentation stock ${suffix}`,
+    correlationId: `presentation-stock-${suffix}`,
+  };
+}
+
+describe('stockPresentation.test.ts', { concurrency: false }, () => {
+  let releaseTestLock: (() => void) | undefined;
+
+  before(async () => {
+    releaseTestLock = await acquireTestLock('a-commerce');
+  });
+
+  after(() => {
+    releaseTestLock?.();
+  });
+
+  it('action:stock:presentationMetadata', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const balanceListJson = await app.bean.openapi.generateJsonOfClass(
+        DtoStockBalanceSelectResItem,
+      );
+      const balanceList = findComponent(
+        balanceListJson,
+        properties => properties?._operationsRow && properties?.skuId && properties?.onHand,
+      );
+      assert.deepEqual(Object.keys(balanceList.properties).sort(), [
+        '_operationsRow',
+        'available',
+        'id',
+        'onHand',
+        'reserved',
+        'skuId',
+      ]);
+      assert.deepEqual(
+        balanceList.properties._operationsRow.rest.table.columnProps.actions.map(
+          (action: any) => action.render,
+        ),
+        ['basic-table:actionView'],
+      );
+      assertFilter(balanceList);
+
+      const balanceViewJson = await app.bean.openapi.generateJsonOfClass(DtoStockBalanceView);
+      const balanceView = findComponent(balanceViewJson, properties => {
+        return properties?.available && properties?.createdAt && properties?.updatedAt;
+      });
+      assert.deepEqual(Object.keys(balanceView.properties).sort(), [
+        'available',
+        'createdAt',
+        'id',
+        'onHand',
+        'reserved',
+        'skuId',
+        'updatedAt',
+      ]);
+      assert.equal(balanceView.properties.createdAt.rest.table.render, 'basic-date:date');
+      assert.equal(balanceView.properties.updatedAt.rest.table.render, 'basic-date:date');
+      assert.equal(updatedAtVisible(balanceView), true);
+      assert.deepEqual(
+        getEntryToolbar(balanceView).options.actions.map((action: any) => action.render),
+        ['basic-form:actionBack'],
+      );
+
+      const auditListJson = await app.bean.openapi.generateJsonOfClass(DtoStockAuditSelectResItem);
+      const auditList = findComponent(
+        auditListJson,
+        properties => properties?._operationsRow && properties?.skuId && properties?.operation,
+      );
+      assert.deepEqual(Object.keys(auditList.properties).sort(), [
+        '_operationsRow',
+        'createdAt',
+        'delta',
+        'id',
+        'operation',
+        'skuId',
+      ]);
+      assert.equal(auditList.properties.id.rest.table.render, 'basic-table:actionView');
+      assert.deepEqual(
+        auditList.properties._operationsRow.rest.table.columnProps.actions.map(
+          (action: any) => action.render,
+        ),
+        ['basic-table:actionView'],
+      );
+      assertFilter(auditList);
+
+      const auditViewJson = await app.bean.openapi.generateJsonOfClass(DtoStockAuditView);
+      const auditView = findComponent(auditViewJson, properties => {
+        return properties?.stockBalanceId && properties?.priorAvailable && properties?.actorId;
+      });
+      assert.deepEqual(Object.keys(auditView.properties).sort(), [
+        'actorId',
+        'available',
+        'correlationId',
+        'createdAt',
+        'delta',
+        'id',
+        'onHand',
+        'operation',
+        'priorAvailable',
+        'priorOnHand',
+        'priorReserved',
+        'reason',
+        'reserved',
+        'skuId',
+        'stockBalanceId',
+        'stockReservationId',
+        'updatedAt',
+      ]);
+      assert.equal(auditView.properties.createdAt.rest.form.render, 'basic-date:formFieldDate');
+      assert.equal(auditView.properties.updatedAt.rest.form.render, 'basic-date:formFieldDate');
+      assert.deepEqual(
+        getEntryToolbar(auditView).options.actions.map((action: any) => action.render),
+        ['basic-form:actionBack'],
+      );
+
+      for (const component of [balanceList, balanceView, auditList, auditView]) {
+        assert.equal(component.properties.iid, undefined);
+        assert.equal(component.properties.deleted, undefined);
+      }
+    });
+  });
+
+  it('action:stock:runtimeBoundary', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      let fixture: IStockFixture | undefined;
+      const suffix = randomUUID().slice(0, 12);
+      await app.bean.passport.signinMock();
+      try {
+        fixture = await createSku(suffix);
+        const balance: any = await app.bean.executor.performAction(
+          'post',
+          '/commerce/trade/stockBalance/adjustStock',
+          { body: stockAdjust(fixture.skuId, suffix) },
+        );
+        assert.equal(balance.onHand, 7);
+        assert.equal(balance.reserved, 0);
+        assert.equal(balance.available, 7);
+
+        const balanceView: any = await app.bean.executor.performAction(
+          'get',
+          '/commerce/trade/stockBalance/:id',
+          { params: { id: balance.id } },
+        );
+        assert.deepEqual(Object.keys(balanceView).sort(), [
+          'available',
+          'createdAt',
+          'id',
+          'onHand',
+          'reserved',
+          'skuId',
+          'updatedAt',
+        ]);
+        assert.equal(balanceView.available, balanceView.onHand - balanceView.reserved);
+
+        const auditList: any = await app.bean.executor.performAction(
+          'get',
+          '/commerce/trade/stockAudit',
+          {
+            query: { skuId: fixture.skuId },
+          },
+        );
+        assert.equal(auditList.list.length, 1);
+        assert.deepEqual(Object.keys(auditList.list[0]).sort(), [
+          'createdAt',
+          'delta',
+          'id',
+          'operation',
+          'skuId',
+        ]);
+
+        const auditView: any = await app.bean.executor.performAction(
+          'get',
+          '/commerce/trade/stockAudit/:id',
+          { params: { id: auditList.list[0].id } },
+        );
+        assert.deepEqual(Object.keys(auditView).sort(), [
+          'actorId',
+          'available',
+          'correlationId',
+          'createdAt',
+          'delta',
+          'id',
+          'onHand',
+          'operation',
+          'priorAvailable',
+          'priorOnHand',
+          'priorReserved',
+          'reason',
+          'reserved',
+          'skuId',
+          'stockBalanceId',
+          'stockReservationId',
+          'updatedAt',
+        ]);
+        assert.equal(auditView.delta, 7);
+        assert.equal(auditView.priorAvailable, 0);
+        assert.equal(auditView.available, 7);
+        assert.equal(auditView.correlationId, `presentation-stock-${suffix}`);
+        assert.equal(auditView.reason, `presentation stock ${suffix}`);
+        assert.equal(String(auditView.actorId), String(app.bean.passport.currentUser!.id));
+        for (const field of ['iid', 'deleted']) assert.equal(auditView[field], undefined);
+      } finally {
+        await dropStockFixture(fixture);
+        await app.bean.passport.signout();
+      }
+    });
+  });
+});
+
+function updatedAtVisible(component: any) {
+  return component.properties.updatedAt.rest.visible !== false;
+}

package/vona/src/suite/a-home/modules/home-base/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-home-base",
-  "version": "5.1.6",
+  "version": "5.1.5",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "keywords": [
@@ -26,7 +26,7 @@
   },
   "scripts": {
     "clean": "rimraf dist tsconfig.build.tsbuildinfo",
-    "tsc:publish": "npm run clean && node ../../../../../packages-cli/cli/src/bin/vona.ts :bin:buildModule --sourcemap && tsc -p tsconfig.build.json",
+    "tsc:publish": "npm run clean && vona :bin:buildModule --sourcemap && tsc -p tsconfig.build.json",
     "prepublishOnly": "npm run tsc:publish",
     "prepack": "clean-package",
     "postpack": "clean-package restore"
@@ -45,6 +45,7 @@
   "title": "home-base",
   "vonaModule": {
     "dependencies": {
+      "a-ssr": "5.0.0",
       "a-vona": "5.0.0"
     }
   }

package/vona/src/suite/a-home/modules/home-base/src/.metadata/index.ts

@@ -1,21 +1,24 @@
 // eslint-disable
-import type { TypeControllerOptionsActions } from 'vona-module-a-openapi';
+import type { TypeSymbolKeyFieldsMore } from 'vona-module-a-orm';
+import type { TypeEntityOptionsFields,TypeControllerOptionsActions } from 'vona-module-a-openapi';
 /** service: begin */
 export * from '../service/menu.ts';
 export * from '../service/permission.ts';
+export * from '../service/siteCatalog.ts';
 
 import 'vona-module-a-bean';
 declare module 'vona-module-a-bean' {
-  
+
     export interface IServiceRecord {
       'home-base:menu': never;
 'home-base:permission': never;
+'home-base:siteCatalog': never;
     }
 
-  
+
 }
 declare module 'vona-module-home-base' {
-  
+
         export interface ServiceMenu {
           /** @internal */
           get scope(): ScopeModuleHomeBase;
@@ -24,7 +27,7 @@ declare module 'vona-module-home-base' {
           export interface ServiceMenu {
             get $beanFullName(): 'home-base.service.menu';
             get $onionName(): 'home-base:menu';
-            
+
           }
 
         export interface ServicePermission {
@@ -35,16 +38,29 @@ declare module 'vona-module-home-base' {
           export interface ServicePermission {
             get $beanFullName(): 'home-base.service.permission';
             get $onionName(): 'home-base:permission';
-            
-          } 
+
+          }
+
+        export interface ServiceSiteCatalog {
+          /** @internal */
+          get scope(): ScopeModuleHomeBase;
+        }
+
+          export interface ServiceSiteCatalog {
+            get $beanFullName(): 'home-base.service.siteCatalog';
+            get $onionName(): 'home-base:siteCatalog';
+
+          }
 }
 /** service: end */
 /** service: begin */
 import type { ServiceMenu } from '../service/menu.ts';
 import type { ServicePermission } from '../service/permission.ts';
+import type { ServiceSiteCatalog } from '../service/siteCatalog.ts';
 export interface IModuleService {
   'menu': ServiceMenu;
 'permission': ServicePermission;
+'siteCatalog': ServiceSiteCatalog;
 }
 /** service: end */
 /** service: begin */
@@ -54,26 +70,63 @@ declare module 'vona' {
   export interface IBeanRecordGeneral {
     'home-base.service.menu': ServiceMenu;
 'home-base.service.permission': ServicePermission;
+'home-base.service.siteCatalog': ServiceSiteCatalog;
   }
 }
 /** service: end */
+/** dto: begin */
+export * from '../dto/siteCatalogSelectRes.ts';
+export * from '../dto/siteCatalogSelectResItem.ts';
+import type { IDtoOptionsSiteCatalogSelectRes } from '../dto/siteCatalogSelectRes.ts';
+import type { IDtoOptionsSiteCatalogSelectResItem } from '../dto/siteCatalogSelectResItem.ts';
+import 'vona-module-a-web';
+declare module 'vona-module-a-web' {
+
+    export interface IDtoRecord {
+      'home-base:siteCatalogSelectRes': IDtoOptionsSiteCatalogSelectRes;
+'home-base:siteCatalogSelectResItem': IDtoOptionsSiteCatalogSelectResItem;
+    }
+
+
+}
+declare module 'vona-module-home-base' {
+
+}
+/** dto: end */
+/** dto: begin */
+import type { DtoSiteCatalogSelectRes } from '../dto/siteCatalogSelectRes.ts';
+import type { DtoSiteCatalogSelectResItem } from '../dto/siteCatalogSelectResItem.ts';
+declare module 'vona-module-home-base' {
+
+    export interface IDtoOptionsSiteCatalogSelectRes {
+      fields?: TypeEntityOptionsFields<DtoSiteCatalogSelectRes, IDtoOptionsSiteCatalogSelectRes[TypeSymbolKeyFieldsMore]>;
+    }
+
+    export interface IDtoOptionsSiteCatalogSelectResItem {
+      fields?: TypeEntityOptionsFields<DtoSiteCatalogSelectResItem, IDtoOptionsSiteCatalogSelectResItem[TypeSymbolKeyFieldsMore]>;
+    }
+}
+/** dto: end */
 /** controller: begin */
 export * from '../controller/menu.ts';
 export * from '../controller/permission.ts';
+export * from '../controller/siteCatalog.ts';
 import type { IControllerOptionsMenu } from '../controller/menu.ts';
 import type { IControllerOptionsPermission } from '../controller/permission.ts';
+import type { IControllerOptionsSiteCatalog } from '../controller/siteCatalog.ts';
 import 'vona-module-a-web';
 declare module 'vona-module-a-web' {
-  
+
     export interface IControllerRecord {
       'home-base:menu': IControllerOptionsMenu;
 'home-base:permission': IControllerOptionsPermission;
+'home-base:siteCatalog': IControllerOptionsSiteCatalog;
     }
 
-  
+
 }
 declare module 'vona-module-home-base' {
-  
+
         export interface ControllerMenu {
           /** @internal */
           get scope(): ScopeModuleHomeBase;
@@ -94,7 +147,18 @@ declare module 'vona-module-home-base' {
             get $beanFullName(): 'home-base.controller.permission';
             get $onionName(): 'home-base:permission';
             get $onionOptions(): IControllerOptionsPermission;
-          } 
+          }
+
+        export interface ControllerSiteCatalog {
+          /** @internal */
+          get scope(): ScopeModuleHomeBase;
+        }
+
+          export interface ControllerSiteCatalog {
+            get $beanFullName(): 'home-base.controller.siteCatalog';
+            get $onionName(): 'home-base:siteCatalog';
+            get $onionOptions(): IControllerOptionsSiteCatalog;
+          }
 }
 /** controller: end */
 /** controller: begin */
@@ -102,8 +166,10 @@ declare module 'vona-module-home-base' {
 import type { ControllerMenu } from '../controller/menu.ts';
 // @ts-ignore ignore
 import type { ControllerPermission } from '../controller/permission.ts';
+// @ts-ignore ignore
+import type { ControllerSiteCatalog } from '../controller/siteCatalog.ts';
 declare module 'vona-module-home-base' {
-  
+
     export interface IControllerOptionsMenu {
       actions?: TypeControllerOptionsActions<ControllerMenu>;
     }
@@ -111,14 +177,25 @@ declare module 'vona-module-home-base' {
     export interface IControllerOptionsPermission {
       actions?: TypeControllerOptionsActions<ControllerPermission>;
     }
+
+    export interface IControllerOptionsSiteCatalog {
+      actions?: TypeControllerOptionsActions<ControllerSiteCatalog>;
+    }
 }
 declare module 'vona-module-a-web' {
   export interface IApiPathGetRecord{
         '/home/base/menu/:publicPath?': undefined;
 '/home/base/permission/:resource': undefined;
+'/home/base/siteCatalog': undefined;
     }
 
 }
+import 'vona-module-a-openapi';
+  declare module 'vona-module-a-openapi' {
+    export interface IResourceRecord {
+      'home-base:siteCatalog': never;
+    }
+  }
 
 /** controller: end */
 /** main: begin */
@@ -145,11 +222,11 @@ declare module 'vona' {
   export interface IBeanScopeContainer {
     homeBase: ScopeModuleHomeBase;
   }
-  
-  
 
-  
 
-  
+
+
+
+
 }
 /** scope: end */

package/vona/src/suite/a-home/modules/home-base/src/controller/siteCatalog.ts

@@ -0,0 +1,21 @@
+import type { IDecoratorControllerOptions } from 'vona-module-a-web';
+
+import { BeanBase } from 'vona';
+import { Api, Resource } from 'vona-module-a-openapiutils';
+import { Passport } from 'vona-module-a-user';
+import { Controller, Web } from 'vona-module-a-web';
+
+import { DtoSiteCatalogSelectRes } from '../dto/siteCatalogSelectRes.ts';
+
+export interface IControllerOptionsSiteCatalog extends IDecoratorControllerOptions {}
+
+@Controller<IControllerOptionsSiteCatalog>('siteCatalog')
+@Resource()
+export class ControllerSiteCatalog extends BeanBase {
+  @Web.get()
+  @Api.body(DtoSiteCatalogSelectRes)
+  @Passport.systemAdmin()
+  async select(): Promise<DtoSiteCatalogSelectRes> {
+    return await this.scope.service.siteCatalog.select();
+  }
+}

package/vona/src/suite/a-home/modules/home-base/src/dto/siteCatalogSelectRes.ts

@@ -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 { DtoSiteCatalogSelectResItem } from './siteCatalogSelectResItem.ts';
+
+export interface IDtoOptionsSiteCatalogSelectRes extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsSiteCatalogSelectRes>()
+export class DtoSiteCatalogSelectRes extends $Dto.listAndCount(DtoSiteCatalogSelectResItem) {}

package/vona/src/suite/a-home/modules/home-base/src/dto/siteCatalogSelectResItem.ts

@@ -0,0 +1,15 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+
+import { Api, v } from 'vona-module-a-openapiutils';
+import { Dto } from 'vona-module-a-web';
+
+export interface IDtoOptionsSiteCatalogSelectResItem extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsSiteCatalogSelectResItem>()
+export class DtoSiteCatalogSelectResItem {
+  @Api.field(v.required())
+  siteId: string;
+
+  @Api.field(v.required())
+  title: string;
+}

package/vona/src/suite/a-home/modules/home-base/src/service/siteCatalog.ts

@@ -0,0 +1,29 @@
+import type { IDecoratorSsrSiteOptions } from 'vona-module-a-ssr';
+
+import { BeanBase } from 'vona';
+import { Service } from 'vona-module-a-bean';
+
+import type { DtoSiteCatalogSelectRes } from '../dto/siteCatalogSelectRes.ts';
+
+@Service()
+export class ServiceSiteCatalog extends BeanBase {
+  async select(): Promise<DtoSiteCatalogSelectRes> {
+    const list = this.app
+      .scope('a-ssr')
+      .service.ssr.getSitesEnabled()
+      .map(site => {
+        const options = site.beanOptions.options as IDecoratorSsrSiteOptions;
+        return {
+          siteId: String(options.siteId),
+          title: this.app.meta.text.locale(this.ctx.locale, options.title),
+        };
+      });
+    return {
+      list,
+      total: String(list.length),
+      pageCount: 1,
+      pageSize: list.length,
+      pageNo: 1,
+    } as DtoSiteCatalogSelectRes;
+  }
+}

package/vona/src/suite/cabloy-basic/modules/basic-siteadmin/src/bean/ssrSite.admin.ts

@@ -3,6 +3,8 @@ import type { IIconRecord, IPagePathRecord } from 'zova-rest-cabloy-basic-admin'
 
 import { BeanSsrSiteBase, SsrSite } from 'vona-module-a-ssr';
 
+import { $locale } from '../.metadata/locales.ts';
+
 declare module 'vona-module-a-ssr' {
   export interface ISsrSiteIdRecord {
     admin: never;
@@ -25,6 +27,7 @@ export interface ISsrSiteOptionsAdmin extends IDecoratorSsrSiteOptions<
 
 @SsrSite<ISsrSiteOptionsAdmin>({
   siteId: 'admin',
+  title: $locale('SiteTitle'),
   publicPath: 'admin',
   bundlePath: 'ssr-cabloyBasicAdmin-5.0.0',
   diagnostics: {

package/vona/src/suite/cabloy-basic/modules/basic-siteadmin/src/config/locale/en-us.ts

@@ -1,4 +1,5 @@
 export default {
   Home: 'Home',
+  SiteTitle: 'Admin',
   Management: 'Management',
 };

package/vona/src/suite/cabloy-basic/modules/basic-siteadmin/src/config/locale/zh-cn.ts

@@ -1,4 +1,5 @@
 export default {
   Home: '首页',
+  SiteTitle: '管理',
   Management: '管理',
 };

package/vona/src/suite/cabloy-basic/modules/basic-siteweb/src/bean/ssrSite.web.ts

@@ -3,6 +3,8 @@ import type { IIconRecord, IPagePathRecord } from 'zova-rest-cabloy-basic-web';
 
 import { BeanSsrSiteBase, SsrSite } from 'vona-module-a-ssr';
 
+import { $locale } from '../.metadata/locales.ts';
+
 declare module 'vona-module-a-ssr' {
   export interface ISsrSiteIdRecord {
     web: never;
@@ -25,6 +27,7 @@ export interface ISsrSiteOptionsWeb extends IDecoratorSsrSiteOptions<
 
 @SsrSite<ISsrSiteOptionsWeb>({
   siteId: 'web',
+  title: $locale('SiteTitle'),
   publicPath: '',
   bundlePath: 'ssr-cabloyBasicWeb-5.0.0',
   diagnostics: {