cabloy 5.1.125 → 5.1.127

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

@@ -0,0 +1,218 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { app } from 'vona-mock';
+import {
+  DtoCategoryCreate,
+  DtoCategorySelectResItem,
+  DtoCategoryUpdate,
+  DtoCategoryView,
+} from 'vona-module-commerce-catalog';
+
+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 getEntryForm(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;
+}
+
+describe('categoryPresentation.test.ts', () => {
+  it('action:category:presentationMetadata', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const createJson = await app.bean.openapi.generateJsonOfClass(DtoCategoryCreate);
+      const createComponent = findComponent(createJson, properties => {
+        return (
+          properties?.name &&
+          properties?.parentId &&
+          properties?.published &&
+          properties?.description
+        );
+      });
+      const createProperties = createComponent.properties;
+      assert.deepEqual(Object.keys(createProperties).sort(), [
+        'description',
+        'name',
+        'parentId',
+        'published',
+      ]);
+      assert.equal(
+        createProperties.parentId.rest.form.render,
+        'basic-resource:formFieldResourcePicker',
+      );
+      assert.deepEqual(createProperties.parentId.rest.form.options, {
+        resource: 'commerce-catalog:category',
+        relationName: 'parent',
+      });
+      assert.equal(createProperties.published.rest.form.render, 'basic-select:formFieldSelect');
+      assert.deepEqual(
+        createProperties.published.rest.form.options.items.map((item: any) => item.value),
+        [false, true],
+      );
+      assert.ok(
+        createProperties.published.rest.form.options.items.every(
+          (item: any) => item.title?.toJSON && item.title?.toString,
+        ),
+      );
+      const createToolbar = getEntryForm(createComponent);
+      assert.deepEqual(
+        createToolbar.options.actions.map((action: any) => action.render),
+        ['basic-form:actionSubmit', 'basic-form:actionBack'],
+      );
+
+      const updateJson = await app.bean.openapi.generateJsonOfClass(DtoCategoryUpdate);
+      const updateComponent = findComponent(updateJson, properties => {
+        return (
+          properties?.name &&
+          properties?.parentId &&
+          properties?.published &&
+          properties?.description
+        );
+      });
+      assert.deepEqual(Object.keys(updateComponent.properties).sort(), [
+        'description',
+        'name',
+        'parentId',
+        'published',
+      ]);
+      assert.equal(
+        updateComponent.properties.parentId.rest.form.render,
+        'basic-resource:formFieldResourcePicker',
+      );
+      assert.equal(
+        updateComponent.properties.published.rest.form.render,
+        'basic-select:formFieldSelect',
+      );
+
+      const viewJson = await app.bean.openapi.generateJsonOfClass(DtoCategoryView);
+      const viewComponent = findComponent(viewJson, properties => {
+        return (
+          properties?.id && properties?.parentId && properties?.parent && properties?.published
+        );
+      });
+      assert.deepEqual(Object.keys(viewComponent.properties.parent.properties).sort(), [
+        'id',
+        'name',
+      ]);
+      assert.equal(viewComponent.properties.iid.rest.visible, false);
+      assert.equal(viewComponent.properties.deleted.rest.visible, false);
+      assert.equal(
+        viewComponent.properties.parentId.rest.form.render,
+        'basic-resource:formFieldResourcePicker',
+      );
+      assert.equal(
+        viewComponent.properties.published.rest.form.render,
+        'basic-select:formFieldSelect',
+      );
+      const viewToolbar = getEntryForm(viewComponent);
+      assert.deepEqual(
+        viewToolbar.options.actions.map((action: any) => action.render),
+        ['basic-form:actionBack'],
+      );
+
+      const listJson = await app.bean.openapi.generateJsonOfClass(DtoCategorySelectResItem);
+      const listComponent = findComponent(listJson, properties => properties?._operationsRow);
+      const listProperties = listComponent.properties;
+      assert.deepEqual(Object.keys(listProperties.parent.properties).sort(), ['id', 'name']);
+      assert.equal(listProperties.parentId.rest.table.render, 'basic-resource:resourcePicker');
+      assert.deepEqual(listProperties.parentId.rest.table.columnProps, {
+        resource: 'commerce-catalog:category',
+        relationName: 'parent',
+      });
+      assert.equal(listProperties.published.rest.table.render, 'basic-select:select');
+      assert.deepEqual(
+        listProperties.published.rest.table.columnProps.items.map((item: any) => item.value),
+        [false, true],
+      );
+      assert.deepEqual(
+        listProperties._operationsRow.rest.table.columnProps.actions.map(
+          (action: any) => action.render,
+        ),
+        ['basic-table:actionUpdate', 'basic-table:actionDelete'],
+      );
+
+      const filterBlock = listComponent.rest.blocks[0].options.blocks[0];
+      const filterLayout = filterBlock.options.blocks[0].options.formLayout;
+      const section = filterLayout.children[0];
+      assert.equal(section.type, 'section');
+      assert.equal(section.layout, 'flow');
+      assert.deepEqual(
+        section.children.slice(0, 2).map((field: any) => field.name),
+        ['name', 'createdAt'],
+      );
+      assert.equal(section.children[2].block.render, 'basic-page:blockFilterActions');
+    });
+  });
+
+  it('action:category:parentProjection', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const suffix = `${Date.now()}`;
+      let parentId: number | string | undefined;
+      let childId: number | string | undefined;
+      await app.bean.passport.signinMock();
+      try {
+        parentId = await app.bean.executor.performAction('post', '/commerce/catalog/category', {
+          body: { name: `presentation-parent-${suffix}`, published: false },
+        });
+        childId = await app.bean.executor.performAction('post', '/commerce/catalog/category', {
+          body: {
+            name: `presentation-child-${suffix}`,
+            parentId,
+            published: true,
+          },
+        });
+
+        const view: any = await app.bean.executor.performAction(
+          'get',
+          '/commerce/catalog/category/:id',
+          { params: { id: childId } },
+        );
+        assert.equal(String(view.parentId), String(parentId));
+        assert.deepEqual(view.parent, { id: parentId, name: `presentation-parent-${suffix}` });
+        assert.equal(view.published, true);
+
+        const select: any = await app.bean.executor.performAction(
+          'get',
+          '/commerce/catalog/category',
+        );
+        const root = select.list.find((item: any) => String(item.id) === String(parentId));
+        const child = select.list.find((item: any) => String(item.id) === String(childId));
+        assert.equal(root.parent, undefined);
+        assert.equal(root.published, false);
+        assert.equal(String(child.parentId), String(parentId));
+        assert.deepEqual(child.parent, { id: parentId, name: `presentation-parent-${suffix}` });
+        assert.equal(child.published, true);
+
+        await assert.rejects(
+          app.bean.executor.performAction('patch', '/commerce/catalog/category/:id', {
+            params: { id: childId },
+            body: {
+              name: `presentation-child-${suffix}`,
+              parentId: childId,
+              published: true,
+            },
+          }),
+        );
+      } finally {
+        if (childId) {
+          await app.bean.executor.performAction('delete', '/commerce/catalog/category/:id', {
+            params: { id: childId },
+          });
+        }
+        if (parentId) {
+          await app.bean.executor.performAction('delete', '/commerce/catalog/category/:id', {
+            params: { id: parentId },
+          });
+        }
+        await app.bean.passport.signout();
+      }
+    });
+  });
+});

package/vona/src/suite/a-commerce/modules/commerce-member/src/dto/addressMineCreate.tsx

@@ -1,35 +1,14 @@
 import type { IDecoratorDtoOptions } from 'vona-module-a-web';
 
-import { Api, v } from 'vona-module-a-openapiutils';
+import { $Dto } from 'vona-module-a-orm';
 import { Dto } from 'vona-module-a-web';
 
-import { $locale } from '../.metadata/locales.ts';
+import { addressMineWriteColumns } from '../lib/addressMine.ts';
+import { ModelAddress } from '../model/address.ts';
 
 export interface IDtoOptionsAddressMineCreate extends IDecoratorDtoOptions {}
 
 @Dto<IDtoOptionsAddressMineCreate>()
-export class DtoAddressMineCreate {
-  @Api.field(v.title($locale('RecipientName')), v.required(), v.min(2), v.max(100))
-  recipientName: string;
-
-  @Api.field(v.title($locale('Phone')), v.required(), v.min(1), v.max(50))
-  phone: string;
-
-  @Api.field(v.title($locale('CountryCode')), v.required(), v.min(2), v.max(10))
-  countryCode: string;
-
-  @Api.field(v.title($locale('Region')), v.required(), v.min(1), v.max(100))
-  region: string;
-
-  @Api.field(v.title($locale('City')), v.required(), v.min(1), v.max(100))
-  city: string;
-
-  @Api.field(v.title($locale('PostalCode')), v.required(), v.min(1), v.max(30))
-  postalCode: string;
-
-  @Api.field(v.title($locale('AddressLine1')), v.required(), v.min(1), v.max(255))
-  addressLine1: string;
-
-  @Api.field(v.title($locale('AddressLine2')), v.optional(), v.max(255))
-  addressLine2?: string;
-}
+export class DtoAddressMineCreate extends $Dto.create(() => ModelAddress, {
+  columns: addressMineWriteColumns,
+}) {}

package/vona/src/suite/a-commerce/modules/commerce-member/src/dto/addressMineItem.tsx

@@ -1,39 +1,14 @@
-import type { TableIdentity } from 'table-identity';
 import type { IDecoratorDtoOptions } from 'vona-module-a-web';
 
-import { Api, v } from 'vona-module-a-openapiutils';
+import { $Dto } from 'vona-module-a-orm';
 import { Dto } from 'vona-module-a-web';
 
-import { $locale } from '../.metadata/locales.ts';
+import { addressMineReadColumns } from '../lib/addressMine.ts';
+import { ModelAddress } from '../model/address.ts';
 
 export interface IDtoOptionsAddressMineItem extends IDecoratorDtoOptions {}
 
 @Dto<IDtoOptionsAddressMineItem>()
-export class DtoAddressMineItem {
-  @Api.field(v.tableIdentity())
-  id: TableIdentity;
-
-  @Api.field(v.title($locale('RecipientName')), v.required(), v.min(2), v.max(100))
-  recipientName: string;
-
-  @Api.field(v.title($locale('Phone')), v.required(), v.min(1), v.max(50))
-  phone: string;
-
-  @Api.field(v.title($locale('CountryCode')), v.required(), v.min(2), v.max(10))
-  countryCode: string;
-
-  @Api.field(v.title($locale('Region')), v.required(), v.min(1), v.max(100))
-  region: string;
-
-  @Api.field(v.title($locale('City')), v.required(), v.min(1), v.max(100))
-  city: string;
-
-  @Api.field(v.title($locale('PostalCode')), v.required(), v.min(1), v.max(30))
-  postalCode: string;
-
-  @Api.field(v.title($locale('AddressLine1')), v.required(), v.min(1), v.max(255))
-  addressLine1: string;
-
-  @Api.field(v.title($locale('AddressLine2')), v.optional(), v.max(255))
-  addressLine2?: string;
-}
+export class DtoAddressMineItem extends $Dto.get(() => ModelAddress, {
+  columns: addressMineReadColumns,
+}) {}

package/vona/src/suite/a-commerce/modules/commerce-member/src/dto/addressMineUpdate.tsx

@@ -1,10 +1,14 @@
 import type { IDecoratorDtoOptions } from 'vona-module-a-web';
 
+import { $Dto } from 'vona-module-a-orm';
 import { Dto } from 'vona-module-a-web';
 
-import { DtoAddressMineCreate } from './addressMineCreate.tsx';
+import { addressMineWriteColumns } from '../lib/addressMine.ts';
+import { ModelAddress } from '../model/address.ts';
 
 export interface IDtoOptionsAddressMineUpdate extends IDecoratorDtoOptions {}
 
 @Dto<IDtoOptionsAddressMineUpdate>()
-export class DtoAddressMineUpdate extends DtoAddressMineCreate {}
+export class DtoAddressMineUpdate extends $Dto.update(() => ModelAddress, {
+  columns: addressMineWriteColumns,
+}) {}

package/vona/src/suite/a-commerce/modules/commerce-member/src/lib/addressMine.ts

@@ -0,0 +1,16 @@
+import type { EntityAddress } from '../entity/address.tsx';
+
+export const addressMineWriteColumns = [
+  'recipientName',
+  'phone',
+  'countryCode',
+  'region',
+  'city',
+  'postalCode',
+  'addressLine1',
+  'addressLine2',
+] satisfies Array<keyof EntityAddress>;
+
+export const addressMineReadColumns = ['id', ...addressMineWriteColumns] satisfies Array<
+  keyof EntityAddress
+>;

package/vona/src/suite/a-commerce/modules/commerce-member/src/service/address.ts

@@ -1,5 +1,5 @@
 import type { TableIdentity } from 'table-identity';
-import type { IQueryParams, TypeModelColumns } from 'vona-module-a-orm';
+import type { IQueryParams } from 'vona-module-a-orm';
 
 import { BeanBase } from 'vona';
 import { Service } from 'vona-module-a-bean';
@@ -10,22 +10,9 @@ import type { DtoAddressMineUpdate } from '../dto/addressMineUpdate.tsx';
 import type { DtoAddressMineView } from '../dto/addressMineView.tsx';
 import type { DtoAddressSelectRes } from '../dto/addressSelectRes.tsx';
 import type { DtoAddressView } from '../dto/addressView.tsx';
-import type { EntityAddress } from '../entity/address.tsx';
 import type { ModelAddress } from '../model/address.ts';
 
-const addressColumns: TypeModelColumns<EntityAddress> = [
-  'id',
-  'recipientName',
-  'phone',
-  'countryCode',
-  'region',
-  'city',
-  'postalCode',
-  'addressLine1',
-  'addressLine2',
-  'createdAt',
-  'updatedAt',
-];
+import { addressMineReadColumns } from '../lib/addressMine.ts';
 
 @Service()
 export class ServiceAddress extends BeanBase {
@@ -43,7 +30,7 @@ export class ServiceAddress extends BeanBase {
   async mine(params?: IQueryParams<ModelAddress>): Promise<DtoAddressMineRes> {
     return await this.scope.model.address.selectAndCount({
       ...params,
-      columns: addressColumns,
+      columns: addressMineReadColumns,
       where: { ...params?.where, userId: this._getCurrentUserId() },
       orders: params?.orders ?? [['id', 'asc']],
     });
@@ -79,7 +66,7 @@ export class ServiceAddress extends BeanBase {
   private async _getOwnedAddress(id: TableIdentity) {
     return await this.scope.model.address.get(
       { id, userId: this._getCurrentUserId() },
-      { columns: addressColumns },
+      { columns: addressMineReadColumns },
     );
   }
 }

package/vona/src/suite/a-commerce/modules/commerce-member/test/addressOwnership.test.ts

@@ -1,14 +1,14 @@
-import type {
-  DtoAddressMineCreate,
-  DtoAddressMineUpdate,
-  EntityAddress,
-} from 'vona-module-commerce-member';
-
 import { catchError } from '@cabloy/utils';
 import assert from 'node:assert';
 import { randomUUID } from 'node:crypto';
 import { describe, it } from 'node:test';
 import { app } from 'vona-mock';
+import {
+  DtoAddressMineCreate,
+  DtoAddressMineItem,
+  DtoAddressMineUpdate,
+  DtoAddressMineView,
+} from 'vona-module-commerce-member';
 
 const actionPath = '/commerce/member/address';
 const minePath = `${actionPath}/mine`;
@@ -16,6 +16,7 @@ const viewMinePath = `${actionPath}/viewMine/:id`;
 const createMinePath = `${actionPath}/createMine`;
 const updateMinePath = `${actionPath}/updateMine/:id`;
 const deleteMinePath = `${actionPath}/deleteMine/:id`;
+const addressMineExcludedFields = ['userId', 'iid', 'deleted', 'createdAt', 'updatedAt'] as const;
 
 function createTestId() {
   return randomUUID().slice(0, 12);
@@ -57,6 +58,38 @@ async function deleteOwnedAddresses(ids: Array<number | string | undefined>) {
 }
 
 describe('addressOwnership.test.ts', () => {
+  it('emits aligned Mine DTO schemas', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const expectedWriteFields = [
+        'recipientName',
+        'phone',
+        'countryCode',
+        'region',
+        'city',
+        'postalCode',
+        'addressLine1',
+        'addressLine2',
+      ].sort();
+      const expectedRequiredFields = expectedWriteFields.filter(name => name !== 'addressLine2');
+      for (const DtoClass of [DtoAddressMineCreate, DtoAddressMineUpdate]) {
+        const apiJson = await app.bean.openapi.generateJsonOfClass(DtoClass);
+        const component = Object.values(apiJson.components!.schemas as any).find(item => {
+          return (item as any).properties?.recipientName && (item as any).properties?.addressLine1;
+        }) as any;
+        assert.deepEqual(Object.keys(component.properties).sort(), expectedWriteFields);
+        assert.deepEqual(component.required?.sort(), expectedRequiredFields);
+      }
+      const expectedReadFields = ['id', ...expectedWriteFields].sort();
+      for (const DtoClass of [DtoAddressMineItem, DtoAddressMineView]) {
+        const apiJson = await app.bean.openapi.generateJsonOfClass(DtoClass);
+        const component = Object.values(apiJson.components!.schemas as any).find(item => {
+          return (item as any).properties?.id && (item as any).properties?.recipientName;
+        }) as any;
+        assert.deepEqual(Object.keys(component.properties).sort(), expectedReadFields);
+      }
+    });
+  });
+
   it('denies anonymous Admin and Web Address actions', async () => {
     await app.bean.executor.mockCtx(async () => {
       for (const [method, path, options] of [
@@ -97,14 +130,12 @@ describe('addressOwnership.test.ts', () => {
           ownList.list.some(item => String(item.id) === String(addressId)),
           true,
         );
-        assert.equal(
-          ownList.list.every(item => !Object.hasOwn(item, 'userId')),
-          true,
-        );
-        assert.equal(
-          ownList.list.every(item => !Object.hasOwn(item, 'iid')),
-          true,
-        );
+        for (const field of addressMineExcludedFields) {
+          assert.equal(
+            ownList.list.every(item => !Object.hasOwn(item, field)),
+            true,
+          );
+        }
 
         const { addressLine2: _, ...update } = {
           ...addressData,
@@ -117,13 +148,26 @@ describe('addressOwnership.test.ts', () => {
           }),
           null,
         );
-        const ownAddress: EntityAddress = await performAs(customerA.token, 'get', viewMinePath, {
-          params: { id: addressId },
-        });
+        const ownAddress: DtoAddressMineView = await performAs(
+          customerA.token,
+          'get',
+          viewMinePath,
+          {
+            params: { id: addressId },
+          },
+        );
         assert.equal(ownAddress.city, update.city);
         assert.equal(ownAddress.addressLine2, addressData.addressLine2);
-        assert.equal(Object.hasOwn(ownAddress, 'userId'), false);
-        assert.equal(Object.hasOwn(ownAddress, 'iid'), false);
+        for (const field of addressMineExcludedFields) {
+          assert.equal(Object.hasOwn(ownAddress, field), false);
+        }
+        const [, incompleteUpdateError] = await catchError(() =>
+          performAs(customerA.token, 'patch', updateMinePath, {
+            params: { id: addressId },
+            body: { city: 'Berkeley' },
+          }),
+        );
+        assert.equal(incompleteUpdateError?.code, 422);
 
         const foreignList = await performAs(customerB.token, 'get', minePath);
         assert.equal(

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

@@ -31,7 +31,8 @@
     "postpack": "clean-package restore"
   },
   "dependencies": {
-    "vona-module-a-pay": "workspace:*"
+    "vona-module-a-pay": "workspace:*",
+    "vona-module-pay-paypal": "workspace:*"
   },
   "devDependencies": {
     "clean-package": "^2.2.0",

package/vona/src/suite/a-commerce/modules/commerce-payment/src/bean/payScene.commerceOrder.ts

@@ -1,10 +1,15 @@
-import type { IPaymentOutcomeEvent } from 'vona-module-a-pay';
+import type { IPaymentOutcomeEvent, IRefundOutcomeEvent } from 'vona-module-a-pay';
 
 import { BeanBase } from 'vona';
 import { PayScene } from 'vona-module-a-pay';
 
 @PayScene({
-  providers: [{ key: 'mock', providerName: 'pay-mock:mock', clientName: 'default' }],
+  providers: [
+    { key: 'mock', providerName: 'pay-mock:mock', clientName: 'default' },
+    { key: 'paypal', providerName: 'pay-paypal:paypal', clientName: 'default' },
+  ],
+  resolveProvider: (_ctx, input) =>
+    input.providers.find(item => item.key === 'mock')?.key ?? input.providers[0]!.key,
   currencies: ['USD'],
   captureMode: 'automatic',
   sessionExpiresIn: 30 * 60 * 1000,
@@ -17,4 +22,8 @@ export class PaySceneCommerceOrder extends BeanBase {
   async onPaymentOutcome(event: IPaymentOutcomeEvent): Promise<void> {
     await this.$scope.commerceTrade.service.order.settlePaymentFromProvider(event);
   }
+
+  async onRefundOutcome(event: IRefundOutcomeEvent): Promise<void> {
+    await this.$scope.commerceTrade.service.order.settleRefundFromProvider(event);
+  }
 }

package/vona/src/suite/a-commerce/modules/commerce-payment/src/service/commercePayScene.ts

@@ -29,10 +29,36 @@ export class ServiceCommercePayScene extends BeanBase {
   async linkRefundOperation(refundAttemptId: TableIdentity, refundOperationId: TableIdentity) {
     const refundAttempt = await this.scope.model.refundAttempt.getByIdForUpdate(refundAttemptId);
     if (!refundAttempt) this.app.throw(404, 'commerce refund attempt not found');
+    if (
+      refundAttempt.refundOperationId &&
+      String(refundAttempt.refundOperationId) !== String(refundOperationId)
+    ) {
+      this.app.throw(409, 'commerce refund attempt is linked to another refund operation');
+    }
     await this.scope.model.refundAttempt.updateById(refundAttempt.id, { refundOperationId });
     return { ...refundAttempt, refundOperationId };
   }
 
+  async createRefundOperation(refundAttemptId: TableIdentity) {
+    const refundAttempt = await this.scope.model.refundAttempt.getById(refundAttemptId);
+    if (!refundAttempt) this.app.throw(404, 'commerce refund attempt not found');
+    const paymentAttempt = await this.scope.model.paymentAttempt.get({
+      orderId: refundAttempt.orderId,
+    });
+    if (!paymentAttempt?.paymentSessionId)
+      this.app.throw(409, 'commerce payment session is unavailable');
+    const refund = await this.$scope.pay.service.refundOperation.create({
+      paymentSessionId: paymentAttempt.paymentSessionId,
+      businessReference: String(refundAttempt.id),
+      amountMinor: refundAttempt.amountCents,
+      currency: refundAttempt.currency,
+      idempotencyKey: `${refundAttempt.correlationId}:refund`,
+      correlationId: refundAttempt.correlationId,
+    });
+    await this.linkRefundOperation(refundAttempt.id, refund.id);
+    return refund;
+  }
+
   @Core.transaction({ isolationLevel: 'SERIALIZABLE' })
   async acceptRefundOutcome(event: IRefundOutcomeEvent) {
     const refundAttempt = await this.scope.model.refundAttempt.getForUpdate({

package/vona/src/suite/a-commerce/modules/commerce-payment/test/paymentAttempt.test.ts

@@ -1,9 +1,26 @@
 import assert from 'node:assert';
 import { randomUUID } from 'node:crypto';
-import { describe, it } from 'node:test';
-import { app } from 'vona-mock';
+import { after, before, describe, it } from 'node:test';
+import { acquireTestLock, app } from 'vona-mock';
 
 describe('paymentAttempt.test.ts', { concurrency: false }, () => {
+  const releaseTestLocks: Array<() => void> = [];
+
+  before(async () => {
+    try {
+      for (const scene of ['a-commerce', 'a-pay']) {
+        releaseTestLocks.push(await acquireTestLock(scene));
+      }
+    } catch (error) {
+      for (const release of releaseTestLocks.reverse()) release();
+      throw error;
+    }
+  });
+
+  after(() => {
+    for (const release of releaseTestLocks.reverse()) release();
+  });
+
   it('creates and internally cancels an attempt exactly once', async () => {
     await app.bean.executor.mockCtx(async () => {
       const scope = app.scope('commerce-payment');

package/vona/src/suite/a-commerce/modules/commerce-promotion/src/config/locale/en-us.ts

@@ -10,14 +10,17 @@ export default {
   CouponTemplate: 'Coupon Template',
   CouponTemplateId: 'Coupon Template ID',
   CouponTemplateState: 'Template State',
+  CouponTemplateStateActive: 'Active',
+  CouponTemplateStateDisabled: 'Disabled',
+  CouponTemplateStateDraft: 'Draft',
   CorrelationId: 'Correlation ID',
   Currency: 'Currency',
   Description: 'Description',
-  DiscountCents: 'Fixed Discount (Cents)',
+  DiscountCents: 'Fixed Discount',
   DiscountPolicy: 'Discount Policy',
   FromState: 'Previous State',
   IssuedCount: 'Issued Count',
-  MinSpendCents: 'Minimum Spend (Cents)',
+  MinSpendCents: 'Minimum Spend',
   Name: 'Name',
   Operations: 'Operations',
   OrderId: 'Order ID',

package/vona/src/suite/a-commerce/modules/commerce-promotion/src/config/locale/zh-cn.ts

@@ -10,14 +10,17 @@ export default {
   CouponTemplate: '优惠券模板',
   CouponTemplateId: '优惠券模板 ID',
   CouponTemplateState: '模板状态',
+  CouponTemplateStateActive: '已启用',
+  CouponTemplateStateDisabled: '已停用',
+  CouponTemplateStateDraft: '草稿',
   CorrelationId: '关联 ID',
   Currency: '币种',
   Description: '描述',
-  DiscountCents: '固定优惠（分）',
+  DiscountCents: '固定优惠',
   DiscountPolicy: '优惠策略',
   FromState: '原状态',
   IssuedCount: '已发放数',
-  MinSpendCents: '最低消费（分）',
+  MinSpendCents: '最低消费',
   Name: '名称',
   Operations: '操作',
   OrderId: '订单 ID',