cabloy 5.1.134 → 5.1.136

package/vona/src/suite/a-commerce/modules/commerce-catalog/src/entity/productContent.tsx

@@ -0,0 +1,36 @@
+import type { TableIdentity } from 'table-identity';
+import type { IDecoratorEntityOptions } from 'vona-module-a-orm';
+
+import { $makeMetadata, Api, v } from 'vona-module-a-openapiutils';
+import { Entity, EntityBase } from 'vona-module-a-orm';
+import { ZovaRender } from 'zova-rest-cabloy-basic-admin';
+
+import { $locale } from '../.metadata/locales.ts';
+
+export interface IEntityOptionsProductContent extends IDecoratorEntityOptions {}
+
+@Entity<IEntityOptionsProductContent>('commerceCatalogProductContent', {
+  openapi: { title: $locale('ProductContent') },
+  fields: {
+    id: $makeMetadata(ZovaRender.visible(false)),
+    iid: $makeMetadata(ZovaRender.visible(false)),
+    deleted: $makeMetadata(ZovaRender.visible(false)),
+    createdAt: $makeMetadata(ZovaRender.visible(false)),
+    updatedAt: $makeMetadata(ZovaRender.visible(false)),
+  },
+})
+export class EntityProductContent extends EntityBase {
+  @Api.field(v.tableIdentity(), ZovaRender.visible(false))
+  productId: TableIdentity;
+
+  @Api.field(
+    v.title($locale('DescriptionMarkdown')),
+    v.optional(),
+    ZovaRender.order(1),
+    ZovaRender.field('basic-markdown:formFieldMarkdown'),
+  )
+  descriptionMarkdown?: string;
+
+  @Api.field(v.title($locale('DescriptionHtml')), v.optional(), ZovaRender.visible(false))
+  descriptionHtml?: string;
+}

package/vona/src/suite/a-commerce/modules/commerce-catalog/src/model/product.ts

@@ -15,6 +15,12 @@ export interface IModelOptionsProduct extends IDecoratorModelOptions<EntityProdu
       'categoryId',
       { columns: ['id', 'name', 'published'] },
     ),
+    productContent: $relation.hasOne('commerce-catalog:productContent', 'productId', {
+      columns: ['id', 'productId', 'descriptionMarkdown', 'descriptionHtml'],
+    }),
+    productContentForm: $relation.hasOne('commerce-catalog:productContent', 'productId', {
+      columns: ['id', 'productId', 'descriptionMarkdown'],
+    }),
     skus: $relation.hasMany('commerce-catalog:sku', 'productId'),
     skuAvailables: $relation.hasMany(
       'commerce-catalog:sku',

package/vona/src/suite/a-commerce/modules/commerce-catalog/src/model/productContent.ts

@@ -0,0 +1,22 @@
+import type { IDecoratorModelOptions } from 'vona-module-a-orm';
+
+import { $relation, BeanModelBase, Model } from 'vona-module-a-orm';
+
+import { EntityProductContent } from '../entity/productContent.tsx';
+
+export interface IModelOptionsProductContent extends IDecoratorModelOptions<EntityProductContent> {}
+
+@Model<IModelOptionsProductContent>({
+  entity: EntityProductContent,
+  relations: {
+    product: $relation.belongsTo(
+      'commerce-catalog:productContent',
+      'commerce-catalog:product',
+      'productId',
+    ),
+  },
+  cache: {
+    modelsClear: 'commerce-catalog:product',
+  },
+})
+export class ModelProductContent extends BeanModelBase<EntityProductContent> {}

package/vona/src/suite/a-commerce/modules/commerce-catalog/src/service/product.ts

@@ -4,9 +4,11 @@ import type { IQueryParams } from 'vona-module-a-orm';
 
 import { BeanBase } from 'vona';
 import { Service } from 'vona-module-a-bean';
+import { Core } from 'vona-module-a-core';
 
 import type { DtoProductCreate } from '../dto/productCreate.tsx';
 import type { DtoProductPublic } from '../dto/productPublic.tsx';
+import type { DtoProductPublicDetail } from '../dto/productPublicDetail.tsx';
 import type { DtoProductPublicSelectRes } from '../dto/productPublicSelectRes.tsx';
 import type { DtoProductSelectRes } from '../dto/productSelectRes.tsx';
 import type { DtoProductUpdate } from '../dto/productUpdate.tsx';
@@ -14,11 +16,35 @@ import type { DtoProductView } from '../dto/productView.tsx';
 import type { EntityProduct } from '../entity/product.tsx';
 import type { ModelProduct } from '../model/product.ts';
 
+const serializationRetryOptions = {
+  retries: 3,
+  factor: 1,
+  minTimeout: 10,
+  maxTimeout: 10,
+  randomize: false,
+  errorCodes: [
+    '40001',
+    'ER_LOCK_DEADLOCK',
+    'ER_LOCK_WAIT_TIMEOUT',
+    'SQLITE_BUSY',
+    'SQLITE_BUSY_SNAPSHOT',
+  ],
+  ownerOnly: true,
+};
+
 @Service()
 export class ServiceProduct extends BeanBase {
+  @Core.transaction()
   async create(product: DtoProductCreate): Promise<EntityProduct> {
     await this._ensureCategoryExists(product.categoryId);
-    return await this.scope.model.product.insert(product);
+    const { productContentForm, ...productFields } = product as DtoProductCreate & {
+      productContentForm?: { descriptionMarkdown?: string };
+    };
+    const created = await this.scope.model.product.insert(productFields);
+    if (productContentForm !== undefined) {
+      await this._updateProductContent(created.id, productContentForm.descriptionMarkdown);
+    }
+    return created;
   }
 
   async select(params?: IQueryParams<ModelProduct>): Promise<DtoProductSelectRes> {
@@ -54,15 +80,19 @@ export class ServiceProduct extends BeanBase {
 
   async view(id: TableIdentity): Promise<DtoProductView | undefined> {
     return await this.scope.model.product.getById(id, {
-      include: { category: true },
+      include: {
+        category: true,
+        productContentForm: { columns: ['id', 'productId', 'descriptionMarkdown'] },
+      },
     });
   }
 
-  async viewPublic(id: TableIdentity): Promise<DtoProductPublic | undefined> {
+  async viewPublic(id: TableIdentity): Promise<DtoProductPublicDetail | undefined> {
     const product = await this.scope.model.product.get(this._getPublicProductWhere({ id }), {
       columns: ['id', 'title', 'description', 'categoryId'],
       include: {
         category: { columns: ['id', 'name'] },
+        productContent: { columns: ['descriptionHtml'] },
         skuAvailables: true,
       },
     });
@@ -70,16 +100,37 @@ export class ServiceProduct extends BeanBase {
     const balancesBySkuId = await this._getBalancesBySkuId(
       product.skuAvailables.map(sku => sku.id),
     );
-    return this._toPublicProduct(product, balancesBySkuId);
+    const publicProduct = this._toPublicProduct(product, balancesBySkuId);
+    if (!publicProduct) return undefined;
+    return {
+      ...publicProduct,
+      descriptionHtml: product.productContent?.descriptionHtml,
+    };
   }
 
+  @Core.transaction()
+  @Core.retryable(serializationRetryOptions)
   async update(id: TableIdentity, product: DtoProductUpdate) {
+    const productForUpdate = await this.scope.model.product.getByIdForUpdate(id);
+    if (!productForUpdate) {
+      this.app.throw(404, 'Product not found');
+    }
     if (product.categoryId !== undefined) await this._ensureCategoryExists(product.categoryId);
-    return await this.scope.model.product.updateById(id, product);
+    const { productContentForm, ...productFields } = product as DtoProductUpdate & {
+      productContentForm?: { descriptionMarkdown?: string };
+    };
+    await this.scope.model.product.updateById(id, productFields);
+    if (productContentForm !== undefined) {
+      await this._updateProductContent(id, productContentForm.descriptionMarkdown);
+    }
   }
 
+  @Core.transaction()
   async delete(id: TableIdentity) {
-    return await this.scope.model.product.deleteById(id);
+    const product = await this.scope.model.product.getByIdForUpdate(id);
+    if (!product) return;
+    await this.scope.model.productContent.delete({ productId: id });
+    return await this.scope.model.product.deleteById(product.id);
   }
 
   private _getPublicProductWhere(where?: Record<string, unknown>) {
@@ -159,6 +210,31 @@ export class ServiceProduct extends BeanBase {
     };
   }
 
+  private async _updateProductContent(
+    productId: TableIdentity,
+    descriptionMarkdown?: string,
+  ): Promise<void> {
+    const markdown = descriptionMarkdown?.trim();
+    const productContent = await this.scope.model.productContent.getForUpdate({ productId });
+    if (!markdown) {
+      if (productContent) await this.scope.model.productContent.deleteById(productContent.id);
+      return;
+    }
+    const descriptionHtml = this.bean.markdown.renderHtml(markdown);
+    if (productContent) {
+      await this.scope.model.productContent.updateById(productContent.id, {
+        descriptionMarkdown: markdown,
+        descriptionHtml,
+      });
+    } else {
+      await this.scope.model.productContent.insert({
+        productId,
+        descriptionMarkdown: markdown,
+        descriptionHtml,
+      });
+    }
+  }
+
   private async _ensureCategoryExists(categoryId: TableIdentity) {
     if (!(await this.scope.model.category.getById(categoryId))) {
       this.app.throw(404, 'Product category not found');

package/vona/src/suite/a-commerce/modules/commerce-catalog/test/productContent.test.ts

@@ -0,0 +1,271 @@
+import assert from 'node:assert';
+import { randomUUID } from 'node:crypto';
+import { after, before, describe, it } from 'node:test';
+import { acquireTestLock, app } from 'vona-mock';
+
+interface IFixture {
+  categoryId?: number | string;
+  productIds: Array<number | string>;
+  skuIds: Array<number | string>;
+}
+
+async function cleanupFixture(fixture: IFixture) {
+  const scopeCatalog = app.scope('commerce-catalog');
+  const scopeTrade = app.scope('commerce-trade');
+  for (const skuId of fixture.skuIds) {
+    await scopeTrade.model.stockAudit.delete({ skuId });
+    await scopeTrade.model.stockReservation.delete({ skuId });
+    await scopeTrade.model.stockBalance.delete({ skuId });
+    await scopeCatalog.model.sku.delete({ id: skuId });
+  }
+  for (const productId of fixture.productIds) {
+    await scopeCatalog.model.productContent.delete({ productId });
+    await scopeCatalog.model.product.delete({ id: productId });
+  }
+  if (fixture.categoryId !== undefined) {
+    await scopeCatalog.model.category.delete({ id: fixture.categoryId });
+  }
+}
+
+async function runInMockCtx<TResult>(operation: () => Promise<TResult>): Promise<TResult> {
+  return await app.bean.executor.mockCtx(async () => {
+    await app.bean.passport.signinMock();
+    try {
+      return await operation();
+    } finally {
+      await app.bean.passport.signout();
+    }
+  });
+}
+
+describe('productContent.test.ts', { concurrency: false }, () => {
+  let releaseTestLock: (() => void) | undefined;
+
+  before(async () => {
+    releaseTestLock = await acquireTestLock('a-commerce');
+  });
+
+  after(() => {
+    releaseTestLock?.();
+  });
+
+  it('stores Markdown and server-rendered safe HTML through the Admin contract', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const fixture: IFixture = { productIds: [], skuIds: [] };
+      const suffix = randomUUID().slice(0, 12);
+      const scopeCatalog = app.scope('commerce-catalog');
+      await app.bean.passport.signinMock();
+      try {
+        const category = await scopeCatalog.model.category.insert({
+          name: `__ProductContentCategory-${suffix}__`,
+          published: true,
+        });
+        fixture.categoryId = category.id;
+        const product = await scopeCatalog.model.product.insert({
+          categoryId: category.id,
+          title: `__ProductContent-${suffix}__`,
+          description: 'Short summary',
+          published: true,
+        });
+        fixture.productIds.push(product.id);
+        const sku = await scopeCatalog.model.sku.insert({
+          code: `__ProductContentSku-${suffix}__`,
+          productId: product.id,
+          priceCents: 1999,
+          lifecycle: 'active',
+        });
+        fixture.skuIds.push(sku.id);
+        await app.scope('commerce-trade').service.stockBalance.adjustStock({
+          skuId: sku.id,
+          delta: 1,
+          reason: 'product content fixture',
+          correlationId: `product-content-${suffix}`,
+        });
+
+        const markdown =
+          '# Product details\n\nA **durable** product.\n\n- [ ] Open task\n- [x] Completed task\n\n<a href="javascript:alert(\'unsafe\')">unsafe</a>';
+        const updateResult = await app.bean.executor.performAction(
+          'patch',
+          '/commerce/catalog/product/:id',
+          {
+            params: { id: product.id },
+            body: {
+              title: product.title,
+              categoryId: product.categoryId,
+              published: product.published,
+              productContentForm: { descriptionMarkdown: markdown },
+            },
+          },
+        );
+        assert.equal(updateResult, null);
+
+        const stored = await scopeCatalog.model.productContent.get({ productId: product.id });
+        assert.ok(stored);
+        assert.equal(stored.descriptionMarkdown, markdown);
+        assert.equal(stored.descriptionHtml, app.bean.markdown.renderHtml(markdown));
+        assert.match(stored.descriptionHtml!, /<h1>Product details<\/h1>/);
+        assert.match(stored.descriptionHtml!, /<strong>durable<\/strong>/);
+        assert.match(stored.descriptionHtml!, /<ul data-type="taskList">/);
+        assert.match(stored.descriptionHtml!, /<input type="checkbox" disabled="disabled" \/>/);
+        assert.match(
+          stored.descriptionHtml!,
+          /<input type="checkbox" checked="checked" disabled="disabled" \/>/,
+        );
+        assert.doesNotMatch(stored.descriptionHtml!, /<a[^>]+javascript:/i);
+
+        const adminProduct: any = await app.bean.executor.performAction(
+          'get',
+          '/commerce/catalog/product/:id',
+          { params: { id: product.id } },
+        );
+        assert.equal(adminProduct.productContentForm.descriptionMarkdown, markdown);
+
+        const publicDetailWithTasks: any = await app.bean.executor.performAction(
+          'get',
+          '/commerce/catalog/product/public/:id',
+          { params: { id: product.id }, innerAccess: false },
+        );
+        assert.equal(publicDetailWithTasks.descriptionMarkdown, undefined);
+        assert.equal(publicDetailWithTasks.descriptionHtml, stored.descriptionHtml);
+
+        await scopeCatalog.service.product.update(product.id, {
+          productContentForm: {
+            descriptionMarkdown: '## Server-derived HTML',
+            descriptionHtml: '<script>forged</script>',
+          },
+        } as any);
+        const forgedHtmlIgnored = await scopeCatalog.model.productContent.get({
+          productId: product.id,
+        });
+        assert.equal(forgedHtmlIgnored?.descriptionHtml, '<h2>Server-derived HTML</h2>');
+
+        const publicDetail: any = await app.bean.executor.performAction(
+          'get',
+          '/commerce/catalog/product/public/:id',
+          { params: { id: product.id }, innerAccess: false },
+        );
+        assert.equal(publicDetail.descriptionMarkdown, undefined);
+        assert.equal(publicDetail.descriptionHtml, '<h2>Server-derived HTML</h2>');
+        assert.equal(publicDetail.description, 'Short summary');
+
+        const publicList: any = await app.bean.executor.performAction(
+          'get',
+          '/commerce/catalog/product/public',
+          { innerAccess: false },
+        );
+        const publicListItem = publicList.list.find(
+          (item: any) => String(item.id) === String(product.id),
+        );
+        assert.ok(publicListItem);
+        assert.equal(publicListItem.descriptionHtml, undefined);
+
+        await app.bean.executor.performAction('patch', '/commerce/catalog/product/:id', {
+          params: { id: product.id },
+          body: {
+            title: product.title,
+            categoryId: product.categoryId,
+            published: product.published,
+            productContentForm: { descriptionMarkdown: '  \n\t' },
+          },
+        });
+        assert.equal(
+          await scopeCatalog.model.productContent.get({ productId: product.id }),
+          undefined,
+        );
+        const productWithoutContent: any = await app.bean.executor.performAction(
+          'get',
+          '/commerce/catalog/product/:id',
+          { params: { id: product.id } },
+        );
+        assert.equal(productWithoutContent.productContentForm, undefined);
+      } finally {
+        await cleanupFixture(fixture);
+        await app.bean.passport.signout();
+      }
+    });
+  });
+
+  it('removes ProductContent when its Product is deleted', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const fixture: IFixture = { productIds: [], skuIds: [] };
+      const suffix = randomUUID().slice(0, 12);
+      const scopeCatalog = app.scope('commerce-catalog');
+      await app.bean.passport.signinMock();
+      try {
+        const category = await scopeCatalog.model.category.insert({
+          name: `__ProductContentDeleteCategory-${suffix}__`,
+          published: false,
+        });
+        fixture.categoryId = category.id;
+        const product = await scopeCatalog.model.product.insert({
+          categoryId: category.id,
+          title: `__ProductContentDelete-${suffix}__`,
+          published: false,
+        });
+        fixture.productIds.push(product.id);
+        await scopeCatalog.service.product.update(product.id, {
+          productContentForm: { descriptionMarkdown: 'Content to delete' },
+        } as any);
+
+        await app.bean.executor.performAction('delete', '/commerce/catalog/product/:id', {
+          params: { id: product.id },
+        });
+        fixture.productIds = fixture.productIds.filter(id => String(id) !== String(product.id));
+        assert.equal(
+          await scopeCatalog.model.productContent.get({ productId: product.id }),
+          undefined,
+        );
+      } finally {
+        await cleanupFixture(fixture);
+        await app.bean.passport.signout();
+      }
+    });
+  });
+
+  it('keeps the final Markdown and HTML pair consistent across competing updates', async () => {
+    const fixture: IFixture = { productIds: [], skuIds: [] };
+    const suffix = randomUUID().slice(0, 12);
+    const markdowns = ['# First update', '## Second update'];
+    try {
+      const productId = await runInMockCtx(async () => {
+        const scopeCatalog = app.scope('commerce-catalog');
+        const category = await scopeCatalog.model.category.insert({
+          name: `__ProductContentRaceCategory-${suffix}__`,
+          published: false,
+        });
+        fixture.categoryId = category.id;
+        const product = await scopeCatalog.model.product.insert({
+          categoryId: category.id,
+          title: `__ProductContentRace-${suffix}__`,
+          published: false,
+        });
+        fixture.productIds.push(product.id);
+        return product.id;
+      });
+
+      await Promise.all(
+        markdowns.map(descriptionMarkdown =>
+          runInMockCtx(async () => {
+            await app.scope('commerce-catalog').service.product.update(productId, {
+              productContentForm: { descriptionMarkdown },
+            } as any);
+          }),
+        ),
+      );
+
+      await runInMockCtx(async () => {
+        const stored = await app.scope('commerce-catalog').model.productContent.get({ productId });
+        assert.ok(stored);
+        assert.ok(markdowns.includes(stored.descriptionMarkdown!));
+        assert.equal(
+          stored.descriptionHtml,
+          app.bean.markdown.renderHtml(stored.descriptionMarkdown),
+        );
+      });
+    } finally {
+      await runInMockCtx(async () => {
+        await cleanupFixture(fixture);
+      });
+    }
+  });
+});

package/vona/src/suite/a-commerce/modules/commerce-catalog/test/productPresentation.test.ts

@@ -4,6 +4,8 @@ import { describe, it } from 'node:test';
 import { app } from 'vona-mock';
 import {
   DtoProductCreate,
+  DtoProductPublic,
+  DtoProductPublicDetail,
   DtoProductSelectResItem,
   DtoProductUpdate,
   DtoProductView,
@@ -15,14 +17,38 @@ function findComponent(apiJson: any, predicate: (properties: any) => boolean) {
   }) as any;
 }
 
-function getEntryForm(component: any) {
+function getEntryBlocks(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;
+  return { formBlock, toolbarBlock };
+}
+
+function getEntryForm(component: any) {
+  return getEntryBlocks(component).toolbarBlock;
+}
+
+function assertProductFormGroups(component: any, productFields: string[]) {
+  const { formBlock } = getEntryBlocks(component);
+  const layoutBlock = formBlock?.options?.blocks?.[0];
+  assert.equal(layoutBlock?.render, 'basic-form:blockFormLayout');
+  const groups = layoutBlock?.options?.formLayout?.children;
+  assert.equal(groups?.length, 2);
+  assert.deepEqual(
+    groups.map((group: any) => group.type),
+    ['group', 'group'],
+  );
+  assert.deepEqual(
+    groups[0].children[0].children.map((field: any) => field.name),
+    productFields,
+  );
+  assert.deepEqual(
+    groups[1].children[0].children.map((field: any) => field.name),
+    ['productContentForm'],
+  );
 }
 
 describe('productPresentation.test.ts', () => {
@@ -35,6 +61,7 @@ describe('productPresentation.test.ts', () => {
       assert.deepEqual(Object.keys(createComponent.properties).sort(), [
         'categoryId',
         'description',
+        'productContentForm',
         'published',
         'title',
       ]);
@@ -54,6 +81,16 @@ describe('productPresentation.test.ts', () => {
         createComponent.properties.published.rest.form.options.items.map((item: any) => item.value),
         [false, true],
       );
+      assert.equal(
+        createComponent.properties.productContentForm.rest.fieldSource,
+        'productContentForm.descriptionMarkdown',
+      );
+      assert.equal(
+        createComponent.properties.productContentForm.rest.form.render,
+        'basic-markdown:formFieldMarkdown',
+      );
+      assert.equal(createComponent.properties.published.default, false);
+      assertProductFormGroups(createComponent, ['title', 'categoryId', 'published', 'description']);
       const createToolbar = getEntryForm(createComponent);
       assert.deepEqual(
         createToolbar.options.actions.map((action: any) => action.render),
@@ -67,6 +104,7 @@ describe('productPresentation.test.ts', () => {
       assert.deepEqual(Object.keys(updateComponent.properties).sort(), [
         'categoryId',
         'description',
+        'productContentForm',
         'published',
         'title',
       ]);
@@ -78,6 +116,15 @@ describe('productPresentation.test.ts', () => {
         updateComponent.properties.published.rest.form.render,
         'basic-select:formFieldSelect',
       );
+      assert.equal(
+        updateComponent.properties.productContentForm.rest.fieldSource,
+        'productContentForm.descriptionMarkdown',
+      );
+      assert.equal(
+        updateComponent.properties.productContentForm.rest.form.render,
+        'basic-markdown:formFieldMarkdown',
+      );
+      assertProductFormGroups(updateComponent, ['title', 'categoryId', 'published', 'description']);
 
       const viewJson = await app.bean.openapi.generateJsonOfClass(DtoProductView);
       const viewComponent = findComponent(viewJson, properties => {
@@ -104,6 +151,23 @@ describe('productPresentation.test.ts', () => {
         viewComponent.properties.published.rest.form.render,
         'basic-select:formFieldSelect',
       );
+      assert.equal(
+        viewComponent.properties.productContentForm.rest.fieldSource,
+        'productContentForm.descriptionMarkdown',
+      );
+      assert.equal(
+        viewComponent.properties.productContentForm.rest.form.render,
+        'basic-markdown:formFieldMarkdown',
+      );
+      assertProductFormGroups(viewComponent, [
+        'id',
+        'title',
+        'categoryId',
+        'published',
+        'description',
+        'createdAt',
+        'updatedAt',
+      ]);
       const viewToolbar = getEntryForm(viewComponent);
       assert.deepEqual(
         viewToolbar.options.actions.map((action: any) => action.render),
@@ -139,6 +203,21 @@ describe('productPresentation.test.ts', () => {
         ['basic-table:actionUpdate', 'basic-table:actionDelete'],
       );
 
+      const publicProductJson = await app.bean.openapi.generateJsonOfClass(DtoProductPublic);
+      const publicProductComponent = findComponent(
+        publicProductJson,
+        properties => properties?.skuAvailables && properties?.description,
+      );
+      assert.equal(publicProductComponent.properties.descriptionHtml, undefined);
+
+      const publicDetailJson = await app.bean.openapi.generateJsonOfClass(DtoProductPublicDetail);
+      const publicDetailComponent = findComponent(
+        publicDetailJson,
+        properties => properties?.skuAvailables && properties?.descriptionHtml,
+      );
+      assert.deepEqual(publicDetailComponent.properties.descriptionHtml.type, ['string', 'null']);
+      assert.equal(publicDetailComponent.properties.descriptionMarkdown, undefined);
+
       const filterBlock = listComponent.rest.blocks[0].options.blocks[0];
       const filterLayout = filterBlock.options.blocks[0].options.formLayout;
       const section = filterLayout.children[0];

package/vona/src/suite/a-commerce/modules/commerce-payment/package.json

@@ -32,7 +32,9 @@
   },
   "dependencies": {
     "vona-module-a-pay": "workspace:*",
-    "vona-module-pay-paypal": "workspace:*"
+    "vona-module-a-ssr": "workspace:*",
+    "vona-module-pay-paypal": "workspace:*",
+    "vona-module-pay-stripe": "workspace:*"
   },
   "devDependencies": {
     "clean-package": "^2.2.0",
@@ -50,6 +52,7 @@
   "vonaModule": {
     "dependencies": {
       "a-pay": "5.0.0",
+      "a-ssr": "5.0.0",
       "a-vona": "5.0.0"
     },
     "fileVersion": 1