cabloy 5.1.127 → 5.1.128

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

@@ -0,0 +1,214 @@
+import assert from 'node:assert';
+import { randomUUID } from 'node:crypto';
+import { describe, it } from 'node:test';
+import { app } from 'vona-mock';
+import {
+  DtoProductCreate,
+  DtoProductSelectResItem,
+  DtoProductUpdate,
+  DtoProductView,
+} 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('productPresentation.test.ts', () => {
+  it('action:product:presentationMetadata', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const createJson = await app.bean.openapi.generateJsonOfClass(DtoProductCreate);
+      const createComponent = findComponent(createJson, properties => {
+        return properties?.title && properties?.categoryId && properties?.published;
+      });
+      assert.deepEqual(Object.keys(createComponent.properties).sort(), [
+        'categoryId',
+        'description',
+        'published',
+        'title',
+      ]);
+      assert.equal(
+        createComponent.properties.categoryId.rest.form.render,
+        'basic-resource:formFieldResourcePicker',
+      );
+      assert.deepEqual(createComponent.properties.categoryId.rest.form.options, {
+        resource: 'commerce-catalog:category',
+        relationName: 'category',
+      });
+      assert.equal(
+        createComponent.properties.published.rest.form.render,
+        'basic-select:formFieldSelect',
+      );
+      assert.deepEqual(
+        createComponent.properties.published.rest.form.options.items.map((item: any) => item.value),
+        [false, true],
+      );
+      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(DtoProductUpdate);
+      const updateComponent = findComponent(updateJson, properties => {
+        return properties?.title && properties?.categoryId && properties?.published;
+      });
+      assert.deepEqual(Object.keys(updateComponent.properties).sort(), [
+        'categoryId',
+        'description',
+        'published',
+        'title',
+      ]);
+      assert.equal(
+        updateComponent.properties.categoryId.rest.form.render,
+        'basic-resource:formFieldResourcePicker',
+      );
+      assert.equal(
+        updateComponent.properties.published.rest.form.render,
+        'basic-select:formFieldSelect',
+      );
+
+      const viewJson = await app.bean.openapi.generateJsonOfClass(DtoProductView);
+      const viewComponent = findComponent(viewJson, properties => {
+        return (
+          properties?.id && properties?.categoryId && properties?.category && properties?.published
+        );
+      });
+      assert.deepEqual(Object.keys(viewComponent.properties.category.properties).sort(), [
+        'id',
+        'name',
+        'published',
+      ]);
+      assert.equal(viewComponent.properties.iid.rest.visible, false);
+      assert.equal(viewComponent.properties.deleted.rest.visible, false);
+      assert.equal(
+        viewComponent.properties.categoryId.rest.form.render,
+        'basic-resource:formFieldResourcePicker',
+      );
+      assert.deepEqual(viewComponent.properties.categoryId.rest.form.options, {
+        resource: 'commerce-catalog:category',
+        relationName: 'category',
+      });
+      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(DtoProductSelectResItem);
+      const listComponent = findComponent(listJson, properties => properties?._operationsRow);
+      assert.deepEqual(Object.keys(listComponent.properties.category.properties).sort(), [
+        'id',
+        'name',
+        'published',
+      ]);
+      assert.equal(
+        listComponent.properties.categoryId.rest.table.render,
+        'basic-resource:resourcePicker',
+      );
+      assert.deepEqual(listComponent.properties.categoryId.rest.table.columnProps, {
+        resource: 'commerce-catalog:category',
+        relationName: 'category',
+      });
+      assert.equal(listComponent.properties.published.rest.table.render, 'basic-select:select');
+      assert.deepEqual(
+        listComponent.properties.published.rest.table.columnProps.items.map(
+          (item: any) => item.value,
+        ),
+        [false, true],
+      );
+      assert.deepEqual(
+        listComponent.properties._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),
+        ['title', 'createdAt'],
+      );
+      assert.equal(section.children[2].block.render, 'basic-page:blockFilterActions');
+    });
+  });
+
+  it('action:product:categoryProjection', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const suffix = randomUUID().slice(0, 12);
+      let categoryId: number | string | undefined;
+      let productId: number | string | undefined;
+      await app.bean.passport.signinMock();
+      try {
+        categoryId = await app.bean.executor.performAction('post', '/commerce/catalog/category', {
+          body: { name: `presentation-product-category-${suffix}`, published: true },
+        });
+        productId = await app.bean.executor.performAction('post', '/commerce/catalog/product', {
+          body: {
+            categoryId,
+            title: `presentation-product-${suffix}`,
+            published: false,
+          },
+        });
+
+        const view: any = await app.bean.executor.performAction(
+          'get',
+          '/commerce/catalog/product/:id',
+          {
+            params: { id: productId },
+          },
+        );
+        assert.equal(String(view.categoryId), String(categoryId));
+        assert.deepEqual(view.category, {
+          id: categoryId,
+          name: `presentation-product-category-${suffix}`,
+          published: true,
+        });
+
+        const select: any = await app.bean.executor.performAction(
+          'get',
+          '/commerce/catalog/product',
+        );
+        const item = select.list.find((entry: any) => String(entry.id) === String(productId));
+        assert.ok(item);
+        assert.deepEqual(item.category, {
+          id: categoryId,
+          name: `presentation-product-category-${suffix}`,
+          published: true,
+        });
+        assert.equal(item.published, false);
+      } finally {
+        if (productId) {
+          await app.bean.executor.performAction('delete', '/commerce/catalog/product/:id', {
+            params: { id: productId },
+          });
+        }
+        if (categoryId) {
+          await app.bean.executor.performAction('delete', '/commerce/catalog/category/:id', {
+            params: { id: categoryId },
+          });
+        }
+        await app.bean.passport.signout();
+      }
+    });
+  });
+});

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

@@ -1,4 +1,8 @@
-import type { IPaymentOutcomeEvent, IRefundOutcomeEvent } from 'vona-module-a-pay';
+import type {
+  EntityPaymentSession,
+  IPaymentOutcomeEvent,
+  IRefundOutcomeEvent,
+} from 'vona-module-a-pay';
 
 import { BeanBase } from 'vona';
 import { PayScene } from 'vona-module-a-pay';
@@ -8,8 +12,33 @@ import { PayScene } from 'vona-module-a-pay';
     { 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,
+  isProviderAvailable: (_ctx, input) => {
+    if (input.candidate.key === 'mock') return true;
+    if (input.candidate.key !== 'paypal') return false;
+    const { clientOptions } = _ctx.bean.payProvider.resolveByName(
+      input.candidate.providerName,
+      input.candidate.clientName,
+    );
+    const options = clientOptions as {
+      secretCredential?: { clientId?: string; clientSecret?: string };
+      webhookId?: string;
+      merchantReference?: string;
+    };
+    const server = _ctx.app.config.server.serve;
+    return !!(
+      options.secretCredential?.clientId &&
+      options.secretCredential.clientSecret &&
+      options.webhookId &&
+      options.merchantReference &&
+      server.protocol &&
+      server.host
+    );
+  },
+  resolveProvider: (_ctx, input) => {
+    const mock = input.providers.find(item => item.key === 'mock');
+    if (!mock) return input.providers[0]!.key;
+    return mock.key;
+  },
   currencies: ['USD'],
   captureMode: 'automatic',
   sessionExpiresIn: 30 * 60 * 1000,
@@ -19,11 +48,18 @@ import { PayScene } from 'vona-module-a-pay';
   },
 })
 export class PaySceneCommerceOrder extends BeanBase {
+  async getPaymentCallbackPath(session: EntityPaymentSession): Promise<string> {
+    const attempt = await this.scope.model.paymentAttempt.get({ paymentSessionId: session.id });
+    if (!attempt) this.app.throw(404, 'commerce payment attempt not found');
+    return `/commerce/payment/${session.id}/${attempt.orderId}`;
+  }
+
   async onPaymentOutcome(event: IPaymentOutcomeEvent): Promise<void> {
     await this.$scope.commerceTrade.service.order.settlePaymentFromProvider(event);
   }
 
   async onRefundOutcome(event: IRefundOutcomeEvent): Promise<void> {
+    if (event.businessReference.startsWith('late-capture:')) return;
     await this.$scope.commerceTrade.service.order.settleRefundFromProvider(event);
   }
 }

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

@@ -9,7 +9,19 @@ import type { EntityPaymentAttempt } from '../entity/paymentAttempt.tsx';
 
 @Service()
 export class ServiceCommercePayScene extends BeanBase {
-  async createSession(attempt: EntityPaymentAttempt) {
+  async availableProviderCandidates(userId: TableIdentity) {
+    return await this.bean.payScene.getAvailableProviderCandidates(
+      'commerce-payment:commerceOrder',
+      {
+        userId,
+        businessReference: 'checkout-preview',
+        amountMinor: 0,
+        currency: 'USD',
+      },
+    );
+  }
+
+  async createSession(attempt: EntityPaymentAttempt, providerCandidateKey?: string) {
     const session = await this.$scope.pay.service.paymentSession.create({
       userId: attempt.userId,
       payScene: 'commerce-payment:commerceOrder',
@@ -17,6 +29,7 @@ export class ServiceCommercePayScene extends BeanBase {
       amountMinor: attempt.amountCents,
       currency: attempt.currency,
       correlationId: `${attempt.correlationId}:session`,
+      providerCandidateKey,
     });
     await this.scope.model.paymentAttempt.updateById(attempt.id, {
       paymentSessionId: session.id,

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

@@ -12,6 +12,7 @@ export interface IPaymentAttemptCreateCommand {
   currency: 'USD';
   amountCents: number;
   correlationId: string;
+  providerCandidateKey?: string;
 }
 
 export type TypePaymentAttemptFinalState = Extract<
@@ -30,7 +31,10 @@ export class ServicePaymentAttempt extends BeanBase {
       amountCents: command.amountCents,
       correlationId: command.correlationId,
     });
-    const session = await this.scope.service.commercePayScene.createSession(attempt);
+    const session = await this.scope.service.commercePayScene.createSession(
+      attempt,
+      command.providerCandidateKey,
+    );
     return {
       ...attempt,
       paymentSessionId: session.id,

package/vona/src/suite/a-commerce/modules/commerce-trade/src/.metadata/index.ts

@@ -834,6 +834,8 @@ export * from '../dto/cartItem.tsx';
 export * from '../dto/cartUpdateItem.tsx';
 export * from '../dto/cartView.tsx';
 export * from '../dto/checkoutCreate.tsx';
+export * from '../dto/checkoutPaymentMethod.tsx';
+export * from '../dto/checkoutPaymentMethods.tsx';
 export * from '../dto/checkoutResult.tsx';
 export * from '../dto/orderAddressSnapshot.tsx';
 export * from '../dto/orderCouponSnapshot.tsx';
@@ -872,6 +874,8 @@ import type { IDtoOptionsCartItem } from '../dto/cartItem.tsx';
 import type { IDtoOptionsCartUpdateItem } from '../dto/cartUpdateItem.tsx';
 import type { IDtoOptionsCartView } from '../dto/cartView.tsx';
 import type { IDtoOptionsCheckoutCreate } from '../dto/checkoutCreate.tsx';
+import type { IDtoOptionsCheckoutPaymentMethod } from '../dto/checkoutPaymentMethod.tsx';
+import type { IDtoOptionsCheckoutPaymentMethods } from '../dto/checkoutPaymentMethods.tsx';
 import type { IDtoOptionsCheckoutResult } from '../dto/checkoutResult.tsx';
 import type { IDtoOptionsOrderAddressSnapshot } from '../dto/orderAddressSnapshot.tsx';
 import type { IDtoOptionsOrderCouponSnapshot } from '../dto/orderCouponSnapshot.tsx';
@@ -914,6 +918,8 @@ declare module 'vona-module-a-web' {
 'commerce-trade:cartUpdateItem': IDtoOptionsCartUpdateItem;
 'commerce-trade:cartView': IDtoOptionsCartView;
 'commerce-trade:checkoutCreate': IDtoOptionsCheckoutCreate;
+'commerce-trade:checkoutPaymentMethod': IDtoOptionsCheckoutPaymentMethod;
+'commerce-trade:checkoutPaymentMethods': IDtoOptionsCheckoutPaymentMethods;
 'commerce-trade:checkoutResult': IDtoOptionsCheckoutResult;
 'commerce-trade:orderAddressSnapshot': IDtoOptionsOrderAddressSnapshot;
 'commerce-trade:orderCouponSnapshot': IDtoOptionsOrderCouponSnapshot;
@@ -961,6 +967,8 @@ import type { DtoCartItem } from '../dto/cartItem.tsx';
 import type { DtoCartUpdateItem } from '../dto/cartUpdateItem.tsx';
 import type { DtoCartView } from '../dto/cartView.tsx';
 import type { DtoCheckoutCreate } from '../dto/checkoutCreate.tsx';
+import type { DtoCheckoutPaymentMethod } from '../dto/checkoutPaymentMethod.tsx';
+import type { DtoCheckoutPaymentMethods } from '../dto/checkoutPaymentMethods.tsx';
 import type { DtoCheckoutResult } from '../dto/checkoutResult.tsx';
 import type { DtoOrderAddressSnapshot } from '../dto/orderAddressSnapshot.tsx';
 import type { DtoOrderCouponSnapshot } from '../dto/orderCouponSnapshot.tsx';
@@ -1016,6 +1024,14 @@ declare module 'vona-module-commerce-trade' {
       fields?: TypeEntityOptionsFields<DtoCheckoutCreate, IDtoOptionsCheckoutCreate[TypeSymbolKeyFieldsMore]>;
     }
 
+    export interface IDtoOptionsCheckoutPaymentMethod {
+      fields?: TypeEntityOptionsFields<DtoCheckoutPaymentMethod, IDtoOptionsCheckoutPaymentMethod[TypeSymbolKeyFieldsMore]>;
+    }
+
+    export interface IDtoOptionsCheckoutPaymentMethods {
+      fields?: TypeEntityOptionsFields<DtoCheckoutPaymentMethods, IDtoOptionsCheckoutPaymentMethods[TypeSymbolKeyFieldsMore]>;
+    }
+
     export interface IDtoOptionsCheckoutResult {
       fields?: TypeEntityOptionsFields<DtoCheckoutResult, IDtoOptionsCheckoutResult[TypeSymbolKeyFieldsMore]>;
     }
@@ -1267,6 +1283,7 @@ declare module 'vona-module-commerce-trade' {
 declare module 'vona-module-a-web' {
   export interface IApiPathGetRecord{
         '/commerce/trade/cart': undefined;
+'/commerce/trade/checkout/payment-methods': undefined;
 '/commerce/trade/order/mine': undefined;
 '/commerce/trade/order/viewMine/:id': undefined;
 '/commerce/trade/order': undefined;

package/vona/src/suite/a-commerce/modules/commerce-trade/src/controller/checkout.ts

@@ -1,3 +1,4 @@
+import type { IUser } from 'vona-module-a-user';
 import type { IDecoratorControllerOptions } from 'vona-module-a-web';
 
 import { BeanBase } from 'vona';
@@ -5,12 +6,29 @@ import { Api } from 'vona-module-a-openapiutils';
 import { Arg, Controller, Web } from 'vona-module-a-web';
 
 import { DtoCheckoutCreate } from '../dto/checkoutCreate.tsx';
+import { DtoCheckoutPaymentMethods } from '../dto/checkoutPaymentMethods.tsx';
 import { DtoCheckoutResult } from '../dto/checkoutResult.tsx';
 
 export interface IControllerOptionsCheckout extends IDecoratorControllerOptions {}
 
 @Controller<IControllerOptionsCheckout>('checkout')
 export class ControllerCheckout extends BeanBase {
+  @Web.get('payment-methods')
+  @Api.body(DtoCheckoutPaymentMethods)
+  async paymentMethods(@Arg.user() user: IUser): Promise<DtoCheckoutPaymentMethods> {
+    const candidates =
+      await this.$scope.commercePayment.service.commercePayScene.availableProviderCandidates(
+        user.id,
+      );
+    const items = candidates.map(candidate => ({
+      key: candidate.key,
+      label: candidate.key === 'paypal' ? 'PayPal' : 'Mock payment',
+      interaction: candidate.key === 'paypal' ? ('redirect' as const) : ('embedded' as const),
+    }));
+    const defaultKey = items.find(item => item.key === 'mock')?.key ?? items[0]!.key;
+    return { items, defaultKey };
+  }
+
   @Web.post()
   @Api.body(DtoCheckoutResult)
   async create(@Arg.body() command: DtoCheckoutCreate): Promise<DtoCheckoutResult> {

package/vona/src/suite/a-commerce/modules/commerce-trade/src/dto/checkoutCreate.tsx

@@ -16,4 +16,7 @@ export class DtoCheckoutCreate {
 
   @Api.field(v.required(), v.min(1), v.max(80))
   correlationId: string;
+
+  @Api.field(v.optional(), v.min(1), v.max(100))
+  providerCandidateKey?: string;
 }

package/vona/src/suite/a-commerce/modules/commerce-trade/src/dto/checkoutPaymentMethod.tsx

@@ -0,0 +1,19 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+
+import { Api, v } from 'vona-module-a-openapiutils';
+import { Dto } from 'vona-module-a-web';
+import { z } from 'zod';
+
+export interface IDtoOptionsCheckoutPaymentMethod extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsCheckoutPaymentMethod>()
+export class DtoCheckoutPaymentMethod {
+  @Api.field(v.required(), v.min(1), v.max(100))
+  key: string;
+
+  @Api.field(v.required(), v.min(1), v.max(100))
+  label: string;
+
+  @Api.field(z.enum(['redirect', 'embedded']))
+  interaction: 'redirect' | 'embedded';
+}

package/vona/src/suite/a-commerce/modules/commerce-trade/src/dto/checkoutPaymentMethods.tsx

@@ -0,0 +1,17 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+
+import { Api, v } from 'vona-module-a-openapiutils';
+import { Dto } from 'vona-module-a-web';
+
+import { DtoCheckoutPaymentMethod } from './checkoutPaymentMethod.tsx';
+
+export interface IDtoOptionsCheckoutPaymentMethods extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsCheckoutPaymentMethods>()
+export class DtoCheckoutPaymentMethods {
+  @Api.field(v.array(DtoCheckoutPaymentMethod))
+  items: DtoCheckoutPaymentMethod[];
+
+  @Api.field(v.required(), v.min(1), v.max(100))
+  defaultKey: string;
+}

package/vona/src/suite/a-commerce/modules/commerce-trade/src/service/order.ts

@@ -322,6 +322,7 @@ export class ServiceOrder extends BeanBase {
       currency: order.currency,
       amountCents: order.payableTotalCents,
       correlationId: `${command.correlationId}:payment`,
+      providerCandidateKey: command.providerCandidateKey,
     });
     await onStage?.('afterPaymentAttempt');
     await this._appendAudit({
@@ -376,6 +377,13 @@ export class ServiceOrder extends BeanBase {
       providerEventId: event.eventId,
     });
     if (existingAudit) return this._paymentOutcomeResult(order, lockedAttempt);
+    if (
+      order.state === 'expired' &&
+      lockedAttempt.state === 'cancelled' &&
+      event.state === 'succeeded'
+    ) {
+      return await this._scheduleLateCaptureCompensation(order, lockedAttempt, event);
+    }
     if (order.state !== 'awaiting_payment' || lockedAttempt.state !== 'created') {
       this.app.throw(409, 'payment attempt is no longer available');
     }
@@ -1217,6 +1225,49 @@ export class ServiceOrder extends BeanBase {
     });
   }
 
+  private async _scheduleLateCaptureCompensation(
+    order: EntityOrder,
+    attempt: EntityPaymentAttempt,
+    event: IPaymentOutcomeEvent,
+  ) {
+    if (!event.providerCaptureId)
+      this.app.throw(409, 'late payment outcome has no provider capture');
+    await this.$scope.commercePayment.model.paymentAttempt.updateById(attempt.id, {
+      providerCaptureId: event.providerCaptureId,
+    });
+    const correlationId = `${order.correlationId}:late-capture:${event.eventId}`;
+    const existingAudit = await this.$scope.commercePayment.model.paymentAudit.get({
+      paymentAttemptId: attempt.id,
+      providerEventId: event.eventId,
+    });
+    if (existingAudit) return this._paymentOutcomeResult(order, attempt);
+    await this.$scope.commercePayment.model.paymentAudit.insert({
+      paymentAttemptId: attempt.id,
+      orderId: order.id,
+      userId: order.userId,
+      provider: event.providerName,
+      providerEventId: event.eventId,
+      outcome: 'succeeded',
+      fromAttemptState: attempt.state,
+      toOrderState: 'expired',
+      idempotencyKey: event.eventId.slice(0, 100),
+      correlationId,
+      reason: 'late provider capture requires automatic compensation',
+      processedAt: new Date(),
+    });
+    const session = await this.$scope.pay.model.paymentSession.getById(event.paymentSessionId);
+    if (!session) this.app.throw(404, 'payment session not found');
+    await this.$scope.pay.service.refundOperation.create({
+      paymentSessionId: session.id,
+      businessReference: `late-capture:${attempt.id}`,
+      amountMinor: event.amountMinor,
+      currency: event.currency,
+      idempotencyKey: `${correlationId}:refund`,
+      correlationId,
+    });
+    return this._paymentOutcomeResult(order, attempt);
+  }
+
   private async _expireLockedOrder(order: EntityOrder) {
     const correlationId = `${order.correlationId}:expiry`;
     const reason = 'unpaid order expired';

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

@@ -550,6 +550,7 @@ describe('paymentOutcome.test.ts', { concurrency: false, sequential: true }, ()
 
   it('denies anonymous customer payment and order actions', async () => {
     await app.bean.executor.mockCtx(async () => {
+      await app.bean.passport.signout();
       const requests = [
         () =>
           app.bean.executor.performAction('get', '/commerce/trade/order/mine', {
@@ -564,7 +565,7 @@ describe('paymentOutcome.test.ts', { concurrency: false, sequential: true }, ()
             innerAccess: false,
           }),
         () =>
-          app.bean.executor.performAction('get', '/payment-session/1', {
+          app.bean.executor.performAction('get', '/pay/payment-session/1', {
             innerAccess: false,
           }),
       ];

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

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-pay",
-  "version": "5.0.3",
+  "version": "5.0.4",
   "description": "",
   "keywords": [
     "Vona Module"