cabloy 5.1.117 → 5.1.119

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

@@ -1,6 +1,11 @@
 import type { TableIdentity } from 'table-identity';
 import type { IQueryParams } from 'vona-module-a-orm';
 import type { EntityPaymentAttempt } from 'vona-module-commerce-payment';
+import type {
+  EntityRefundAttempt,
+  EntityRefundAudit,
+  EntityRefundRequest,
+} from 'vona-module-commerce-payment';
 
 import { BeanBase } from 'vona';
 import { Service } from 'vona-module-a-bean';
@@ -19,6 +24,10 @@ import type { DtoOrderSummary } from '../dto/orderSummary.tsx';
 import type { DtoOrderView } from '../dto/orderView.tsx';
 import type { DtoPaymentOutcomeCreate } from '../dto/paymentOutcomeCreate.tsx';
 import type { DtoPaymentOutcomeResult } from '../dto/paymentOutcomeResult.tsx';
+import type { DtoRefundOutcomeCreate } from '../dto/refundOutcomeCreate.tsx';
+import type { DtoRefundRequestCreate } from '../dto/refundRequestCreate.tsx';
+import type { DtoRefundResult } from '../dto/refundResult.tsx';
+import type { DtoRefundReview } from '../dto/refundReview.tsx';
 import type { DtoShipmentView } from '../dto/shipmentView.tsx';
 import type { EntityOrder } from '../entity/order.tsx';
 import type { EntityOrderLine } from '../entity/orderLine.tsx';
@@ -29,7 +38,11 @@ const maxOrderCents = 2_147_483_647;
 const customerVisibleOrderStates: EntityOrder['state'][] = [
   'awaiting_payment',
   'paid',
+  'refund_requested',
+  'refund_approved',
+  'refund_rejected',
   'shipped',
+  'refunded',
   'cancelled',
   'expired',
 ];
@@ -88,6 +101,25 @@ export type ShipmentFailureStage = 'afterShipmentInsert' | 'afterOrderState' | '
 
 type ShipmentStageCallback = (stage: ShipmentFailureStage) => void | Promise<void>;
 
+export type RefundFailureStage =
+  | 'afterRefundRequestInsert'
+  | 'afterRefundRequestOrderState'
+  | 'afterRefundRequestAudit'
+  | 'afterRefundRequestOrderAudit'
+  | 'afterRefundReviewRequestState'
+  | 'afterRefundAttemptInsert'
+  | 'afterRefundReviewOrderState'
+  | 'afterRefundReviewAudit'
+  | 'afterRefundReviewOrderAudit'
+  | 'afterRefundAttemptState'
+  | 'afterRefundOutcomeRequestState'
+  | 'afterRefundOutcomeOrderState'
+  | 'afterRefundStockRestore'
+  | 'afterRefundOutcomeOrderAudit'
+  | 'afterRefundOutcomeAudit';
+
+type RefundStageCallback = (stage: RefundFailureStage) => void | Promise<void>;
+
 interface IPreparedOrderLine {
   index: number;
   skuId: TableIdentity;
@@ -421,6 +453,205 @@ export class ServiceOrder extends BeanBase {
     return this._paymentOutcomeResult({ ...order, state: orderState }, finalizedAttempt);
   }
 
+  @Core.transaction({ isolationLevel: 'SERIALIZABLE' })
+  @Core.retryable(serializationRetryOptions)
+  async requestRefund(
+    orderId: TableIdentity,
+    command: DtoRefundRequestCreate,
+  ): Promise<DtoRefundResult> {
+    return await this._requestRefund(orderId, command);
+  }
+
+  @Core.transaction({ isolationLevel: 'SERIALIZABLE' })
+  @Core.retryable(serializationRetryOptions)
+  async requestRefundForTest(
+    orderId: TableIdentity,
+    command: DtoRefundRequestCreate,
+    onStage: RefundStageCallback,
+  ): Promise<DtoRefundResult> {
+    return await this._requestRefund(orderId, command, onStage);
+  }
+
+  private async _requestRefund(
+    orderId: TableIdentity,
+    command: DtoRefundRequestCreate,
+    onStage?: RefundStageCallback,
+  ): Promise<DtoRefundResult> {
+    const reason = command.reason.trim();
+    const idempotencyKey = command.idempotencyKey.trim();
+    if (!reason) this.app.throw(400, 'refund reason is required');
+    if (!idempotencyKey) this.app.throw(400, 'refund idempotencyKey is required');
+    const userId = this.bean.passport.currentUser!.id;
+    const order = await this.scope.model.order.getByIdForUpdate(orderId);
+    if (!order || String(order.userId) !== String(userId)) this.app.throw(404, 'order not found');
+
+    const existingAudit = await this.$scope.commercePayment.model.refundAudit.get({
+      orderId: order.id,
+      idempotencyKey,
+    });
+    if (existingAudit) return await this._requestReplayResult(order, existingAudit, reason);
+
+    const activeRequest = await this.$scope.commercePayment.model.refundRequest.getForUpdate({
+      orderId: order.id,
+      state: ['requested', 'approved'],
+    });
+    if (activeRequest) this.app.throw(409, 'order already has an active refund request');
+    if (order.state !== 'paid') this.app.throw(409, 'order is not available for refund');
+
+    const correlationId = `${order.correlationId}:refund:${idempotencyKey}`;
+    const refundRequest = await this.$scope.commercePayment.model.refundRequest.insert({
+      orderId: order.id,
+      userId,
+      state: 'requested',
+      currency: order.currency,
+      amountCents: order.payableTotalCents,
+      correlationId,
+      reason,
+    });
+    await onStage?.('afterRefundRequestInsert');
+    await this.scope.model.order.updateById(order.id, { state: 'refund_requested' });
+    await onStage?.('afterRefundRequestOrderState');
+    await this._appendRefundAudit({
+      refundRequest,
+      order,
+      toRefundState: 'requested',
+      idempotencyKey,
+      correlationId,
+      reason,
+    });
+    await onStage?.('afterRefundRequestAudit');
+    await this._appendAudit({
+      orderId: order.id,
+      operation: 'refund_requested',
+      fromState: 'paid',
+      toState: 'refund_requested',
+      correlationId,
+      reason,
+    });
+    await onStage?.('afterRefundRequestOrderAudit');
+    return this._refundResult({ ...order, state: 'refund_requested' }, refundRequest);
+  }
+
+  @Core.transaction({ isolationLevel: 'SERIALIZABLE' })
+  @Core.retryable(serializationRetryOptions)
+  async approveRefund(orderId: TableIdentity, command: DtoRefundReview): Promise<DtoRefundResult> {
+    return await this._reviewRefund(orderId, command, 'approved');
+  }
+
+  @Core.transaction({ isolationLevel: 'SERIALIZABLE' })
+  @Core.retryable(serializationRetryOptions)
+  async rejectRefund(orderId: TableIdentity, command: DtoRefundReview): Promise<DtoRefundResult> {
+    return await this._reviewRefund(orderId, command, 'rejected');
+  }
+
+  @Core.transaction({ isolationLevel: 'SERIALIZABLE' })
+  @Core.retryable(serializationRetryOptions)
+  async reviewRefundForTest(
+    orderId: TableIdentity,
+    command: DtoRefundReview,
+    decision: 'approved' | 'rejected',
+    onStage: RefundStageCallback,
+  ): Promise<DtoRefundResult> {
+    return await this._reviewRefund(orderId, command, decision, onStage);
+  }
+
+  @Core.transaction({ isolationLevel: 'SERIALIZABLE' })
+  @Core.retryable(serializationRetryOptions)
+  async applyRefundOutcome(
+    orderId: TableIdentity,
+    command: DtoRefundOutcomeCreate,
+  ): Promise<DtoRefundResult> {
+    return await this._applyRefundOutcome(orderId, command);
+  }
+
+  @Core.transaction({ isolationLevel: 'SERIALIZABLE' })
+  @Core.retryable(serializationRetryOptions)
+  async applyRefundOutcomeForTest(
+    orderId: TableIdentity,
+    command: DtoRefundOutcomeCreate,
+    onStage: RefundStageCallback,
+  ): Promise<DtoRefundResult> {
+    return await this._applyRefundOutcome(orderId, command, onStage);
+  }
+
+  private async _applyRefundOutcome(
+    orderId: TableIdentity,
+    command: DtoRefundOutcomeCreate,
+    onStage?: RefundStageCallback,
+  ): Promise<DtoRefundResult> {
+    const idempotencyKey = command.idempotencyKey.trim();
+    if (!idempotencyKey) this.app.throw(400, 'refund idempotencyKey is required');
+    const order = await this.scope.model.order.getByIdForUpdate(orderId);
+    if (!order) this.app.throw(404, 'order not found');
+    const existingAudit = await this.$scope.commercePayment.model.refundAudit.get({
+      orderId: order.id,
+      idempotencyKey,
+    });
+    if (existingAudit)
+      return await this._outcomeReplayResult(order, existingAudit, command.outcome);
+
+    const refundRequest = await this.$scope.commercePayment.model.refundRequest.getForUpdate({
+      orderId: order.id,
+      state: 'approved',
+    });
+    if (!refundRequest) this.app.throw(404, 'approved refund request not found');
+    const refundAttempt = await this.$scope.commercePayment.model.refundAttempt.getForUpdate({
+      refundRequestId: refundRequest.id,
+    });
+    if (!refundAttempt) this.app.throw(404, 'refund attempt not found');
+    if (order.state !== 'refund_approved' || refundAttempt.state !== 'created') {
+      this.app.throw(409, 'refund is not available for execution');
+    }
+
+    const correlationId = `${order.correlationId}:refund:${idempotencyKey}`;
+    const now = new Date();
+    const isSucceeded = command.outcome === 'succeeded';
+    const refundState = isSucceeded ? 'refunded' : 'failed';
+    const orderState = isSucceeded ? 'refunded' : 'paid';
+    const reason = isSucceeded ? 'mock refund succeeded' : 'mock refund failed';
+    await this.$scope.commercePayment.model.refundAttempt.updateById(refundAttempt.id, {
+      state: command.outcome,
+      finalizedAt: now,
+    });
+    await onStage?.('afterRefundAttemptState');
+    await this.$scope.commercePayment.model.refundRequest.updateById(refundRequest.id, {
+      state: refundState,
+      finalizedAt: now,
+    });
+    await onStage?.('afterRefundOutcomeRequestState');
+    await this.scope.model.order.updateById(order.id, { state: orderState });
+    await onStage?.('afterRefundOutcomeOrderState');
+    if (isSucceeded) {
+      await this._restoreConsumedOrderStock(order, reason);
+      await onStage?.('afterRefundStockRestore');
+    }
+    await this._appendAudit({
+      orderId: order.id,
+      operation: isSucceeded ? 'refunded' : 'refund_failed',
+      fromState: 'refund_approved',
+      toState: orderState,
+      correlationId,
+      reason,
+    });
+    await onStage?.('afterRefundOutcomeOrderAudit');
+    await this._appendRefundAudit({
+      refundRequest,
+      refundAttempt,
+      order,
+      toRefundState: refundState,
+      attemptState: command.outcome,
+      idempotencyKey,
+      correlationId,
+      reason,
+    });
+    await onStage?.('afterRefundOutcomeAudit');
+    return this._refundResult(
+      { ...order, state: orderState },
+      { ...refundRequest, state: refundState },
+      { ...refundAttempt, state: command.outcome },
+    );
+  }
+
   @Core.transaction({ isolationLevel: 'SERIALIZABLE' })
   @Core.retryable(serializationRetryOptions)
   async ship(orderId: TableIdentity, command: DtoOrderShip): Promise<DtoShipmentView> {
@@ -534,13 +765,7 @@ export class ServiceOrder extends BeanBase {
     const snapshot = await this._viewMineSnapshot(id);
     if (!snapshot) return undefined;
     const { order, lines } = snapshot;
-    if (
-      order.state !== 'awaiting_payment' &&
-      order.state !== 'paid' &&
-      order.state !== 'shipped' &&
-      order.state !== 'cancelled' &&
-      order.state !== 'expired'
-    ) {
+    if (!customerVisibleOrderStates.includes(order.state)) {
       this.app.throw(409, 'order state is not available to customers');
     }
     const shipment = await this.scope.model.shipment.get({ orderId: order.id });
@@ -584,6 +809,220 @@ export class ServiceOrder extends BeanBase {
     return await this._viewSnapshot(order);
   }
 
+  private async _reviewRefund(
+    orderId: TableIdentity,
+    command: DtoRefundReview,
+    decision: 'approved' | 'rejected',
+    onStage?: RefundStageCallback,
+  ): Promise<DtoRefundResult> {
+    const reason = command.reason.trim();
+    const idempotencyKey = command.idempotencyKey.trim();
+    if (!reason) this.app.throw(400, 'refund review reason is required');
+    if (!idempotencyKey) this.app.throw(400, 'refund idempotencyKey is required');
+    const order = await this.scope.model.order.getByIdForUpdate(orderId);
+    if (!order) this.app.throw(404, 'order not found');
+
+    const existingAudit = await this.$scope.commercePayment.model.refundAudit.get({
+      orderId: order.id,
+      idempotencyKey,
+    });
+    if (existingAudit)
+      return await this._reviewReplayResult(order, existingAudit, decision, reason);
+
+    const refundRequest = await this.$scope.commercePayment.model.refundRequest.getForUpdate({
+      orderId: order.id,
+      state: 'requested',
+    });
+    if (!refundRequest) this.app.throw(404, 'refund request is not available for review');
+    if (order.state !== 'refund_requested')
+      this.app.throw(409, 'refund is not available for review');
+    if (await this.scope.model.shipment.get({ orderId: order.id })) {
+      this.app.throw(409, 'shipped order is not available for refund');
+    }
+
+    const actorId = this.bean.passport.currentUser!.id;
+    const now = new Date();
+    const correlationId = `${order.correlationId}:refund:${decision}:${idempotencyKey}`;
+    const orderState = decision === 'approved' ? 'refund_approved' : 'paid';
+    await this.$scope.commercePayment.model.refundRequest.updateById(refundRequest.id, {
+      state: decision,
+      reviewedBy: actorId,
+      reviewedAt: now,
+    });
+    await onStage?.('afterRefundReviewRequestState');
+    let refundAttempt:
+      | Awaited<ReturnType<typeof this.$scope.commercePayment.model.refundAttempt.insert>>
+      | undefined;
+    if (decision === 'approved') {
+      refundAttempt = await this.$scope.commercePayment.model.refundAttempt.insert({
+        refundRequestId: refundRequest.id,
+        orderId: order.id,
+        userId: refundRequest.userId,
+        state: 'created',
+        currency: refundRequest.currency,
+        amountCents: refundRequest.amountCents,
+        correlationId,
+      });
+      await onStage?.('afterRefundAttemptInsert');
+    }
+    await this.scope.model.order.updateById(order.id, { state: orderState });
+    await onStage?.('afterRefundReviewOrderState');
+    await this._appendRefundAudit({
+      refundRequest,
+      refundAttempt,
+      order,
+      toRefundState: decision,
+      attemptState: refundAttempt?.state,
+      idempotencyKey,
+      correlationId,
+      reason,
+    });
+    await onStage?.('afterRefundReviewAudit');
+    await this._appendAudit({
+      orderId: order.id,
+      operation: decision === 'approved' ? 'refund_approved' : 'refund_rejected',
+      fromState: 'refund_requested',
+      toState: orderState,
+      correlationId,
+      reason,
+    });
+    await onStage?.('afterRefundReviewOrderAudit');
+    return this._refundResult(
+      { ...order, state: orderState },
+      { ...refundRequest, state: decision },
+      refundAttempt,
+    );
+  }
+
+  private async _requestReplayResult(
+    order: EntityOrder,
+    audit: EntityRefundAudit,
+    reason: string,
+  ): Promise<DtoRefundResult> {
+    if (audit.toRefundState !== 'requested' || audit.reason !== reason) {
+      this.app.throw(409, 'refund idempotency key conflicts with an existing request');
+    }
+    const refundRequest = await this.$scope.commercePayment.model.refundRequest.getById(
+      audit.refundRequestId,
+    );
+    if (!refundRequest) this.app.throw(404, 'refund request not found');
+    const refundAttempt = await this.$scope.commercePayment.model.refundAttempt.get({
+      refundRequestId: refundRequest.id,
+    });
+    return this._refundResult(order, refundRequest, refundAttempt);
+  }
+
+  private async _reviewReplayResult(
+    order: EntityOrder,
+    audit: EntityRefundAudit,
+    decision: 'approved' | 'rejected',
+    reason: string,
+  ): Promise<DtoRefundResult> {
+    if (audit.toRefundState !== decision || audit.reason !== reason) {
+      this.app.throw(409, 'refund idempotency key conflicts with an existing review');
+    }
+    const refundRequest = await this.$scope.commercePayment.model.refundRequest.getById(
+      audit.refundRequestId,
+    );
+    if (!refundRequest) this.app.throw(404, 'refund request not found');
+    const refundAttempt = audit.refundAttemptId
+      ? await this.$scope.commercePayment.model.refundAttempt.getById(audit.refundAttemptId)
+      : undefined;
+    return this._refundResult(order, refundRequest, refundAttempt);
+  }
+
+  private async _outcomeReplayResult(
+    order: EntityOrder,
+    audit: EntityRefundAudit,
+    outcome: 'succeeded' | 'failed',
+  ): Promise<DtoRefundResult> {
+    if (audit.attemptState !== outcome) {
+      this.app.throw(409, 'refund idempotency key conflicts with an existing outcome');
+    }
+    const refundRequest = await this.$scope.commercePayment.model.refundRequest.getById(
+      audit.refundRequestId,
+    );
+    const refundAttempt = audit.refundAttemptId
+      ? await this.$scope.commercePayment.model.refundAttempt.getById(audit.refundAttemptId)
+      : undefined;
+    if (!refundRequest || !refundAttempt) this.app.throw(404, 'refund attempt not found');
+    return this._refundResult(order, refundRequest, refundAttempt);
+  }
+
+  private async _restoreConsumedOrderStock(order: EntityOrder, reason: string) {
+    const lines = await this.scope.model.orderLine.select({
+      where: { orderId: order.id },
+      orders: [['skuId', 'asc']],
+    });
+    for (const line of lines) {
+      const reservation = await this.scope.model.stockReservation.get({ orderLineId: line.id });
+      if (reservation)
+        await this.scope.service.stockBalance.restore({ reservationId: reservation.id, reason });
+    }
+  }
+
+  private _refundResult(
+    order: Pick<EntityOrder, 'id' | 'state' | 'currency'>,
+    refundRequest: Pick<EntityRefundRequest, 'id' | 'state' | 'amountCents'>,
+    refundAttempt?: Pick<EntityRefundAttempt, 'id' | 'state'>,
+  ): DtoRefundResult {
+    if (
+      order.state !== 'paid' &&
+      order.state !== 'refund_requested' &&
+      order.state !== 'refund_approved' &&
+      order.state !== 'refund_rejected' &&
+      order.state !== 'refunded'
+    ) {
+      this.app.throw(409, 'refund result is not available');
+    }
+    return {
+      orderId: order.id,
+      refundRequestId: refundRequest.id,
+      refundAttemptId: refundAttempt?.id,
+      orderState: order.state,
+      refundState: refundRequest.state,
+      refundAttemptState: refundAttempt?.state,
+      currency: order.currency,
+      amountCents: refundRequest.amountCents,
+    };
+  }
+
+  private async _appendRefundAudit({
+    refundRequest,
+    refundAttempt,
+    order,
+    toRefundState,
+    attemptState,
+    idempotencyKey,
+    correlationId,
+    reason,
+  }: {
+    refundRequest: Pick<EntityRefundRequest, 'id' | 'userId'>;
+    refundAttempt?: Pick<EntityRefundAttempt, 'id'>;
+    order: Pick<EntityOrder, 'id'>;
+    toRefundState: 'requested' | 'approved' | 'rejected' | 'refunded' | 'failed';
+    attemptState?: 'created' | 'succeeded' | 'failed';
+    idempotencyKey?: string;
+    correlationId: string;
+    reason: string;
+  }) {
+    await this.$scope.commercePayment.model.refundAudit.insert({
+      refundRequestId: refundRequest.id,
+      refundAttemptId: refundAttempt?.id,
+      orderId: order.id,
+      userId: refundRequest.userId,
+      toRefundState,
+      attemptState,
+      idempotencyKey,
+      correlationId,
+      reason,
+      actorId: this.bean.passport.currentUser?.anonymous
+        ? undefined
+        : this.bean.passport.currentUser?.id,
+      processedAt: new Date(),
+    });
+  }
+
   private async _expireLockedOrder(order: EntityOrder) {
     const correlationId = `${order.correlationId}:expiry`;
     const reason = 'unpaid order expired';
@@ -810,9 +1249,19 @@ export class ServiceOrder extends BeanBase {
     reason,
   }: {
     orderId: TableIdentity;
-    operation: 'created' | 'paid' | 'cancelled' | 'expired' | 'shipped';
-    fromState?: 'awaiting_payment' | 'paid' | 'cancelled' | 'expired' | 'shipped';
-    toState: 'awaiting_payment' | 'paid' | 'cancelled' | 'expired' | 'shipped';
+    operation:
+      | 'created'
+      | 'paid'
+      | 'cancelled'
+      | 'expired'
+      | 'shipped'
+      | 'refund_requested'
+      | 'refund_approved'
+      | 'refund_rejected'
+      | 'refund_failed'
+      | 'refunded';
+    fromState?: EntityOrder['state'];
+    toState: EntityOrder['state'];
     correlationId: string;
     reason: string;
   }) {

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

@@ -4,9 +4,7 @@ import { catchError } from '@cabloy/utils';
 import assert from 'node:assert';
 import { randomUUID } from 'node:crypto';
 import { after, before, describe, it } from 'node:test';
-import { app } from 'vona-mock';
-
-import { acquireTestLock } from './testLock.ts';
+import { acquireTestLock, app } from 'vona-mock';
 
 const actionPath = '/commerce/trade/cart';
 
@@ -99,7 +97,7 @@ describe('cartOwnership.test.ts', { concurrency: false }, () => {
   let releaseTestLock: (() => void) | undefined;
 
   before(async () => {
-    releaseTestLock = await acquireTestLock();
+    releaseTestLock = await acquireTestLock('a-commerce');
   });
 
   after(() => {

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

@@ -2,9 +2,7 @@ import { catchError } from '@cabloy/utils';
 import assert from 'node:assert';
 import { randomUUID } from 'node:crypto';
 import { after, before, describe, it } from 'node:test';
-import { app } from 'vona-mock';
-
-import { acquireTestLock } from './testLock.ts';
+import { acquireTestLock, app } from 'vona-mock';
 
 interface IFixture {
   categoryId?: number;
@@ -68,7 +66,7 @@ describe('checkoutReservation.test.ts', { concurrency: false }, () => {
   let releaseTestLock: (() => void) | undefined;
 
   before(async () => {
-    releaseTestLock = await acquireTestLock();
+    releaseTestLock = await acquireTestLock('a-commerce');
   });
 
   after(() => {

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

@@ -2,12 +2,10 @@ import { catchError } from '@cabloy/utils';
 import assert from 'node:assert';
 import { randomUUID } from 'node:crypto';
 import { after, before, describe, it } from 'node:test';
-import { app } from 'vona-mock';
+import { acquireTestLock, app } from 'vona-mock';
 
 import type { CheckoutFailureStage } from '../src/service/order.ts';
 
-import { acquireTestLock } from './testLock.ts';
-
 interface IFixture {
   categoryId: number;
   productId: number;
@@ -158,7 +156,7 @@ describe('checkoutTransaction.test.ts', { concurrency: false, sequential: true }
   let releaseTestLock: (() => void) | undefined;
 
   before(async () => {
-    releaseTestLock = await acquireTestLock();
+    releaseTestLock = await acquireTestLock('a-commerce');
   });
 
   after(() => {

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

@@ -2,9 +2,7 @@ import { catchError } from '@cabloy/utils';
 import assert from 'node:assert';
 import { randomUUID } from 'node:crypto';
 import { after, before, describe, it } from 'node:test';
-import { app } from 'vona-mock';
-
-import { acquireTestLock } from './testLock.ts';
+import { acquireTestLock, app } from 'vona-mock';
 
 interface IFixture {
   categoryId?: number;
@@ -58,7 +56,7 @@ describe('orderSnapshot.test.ts', { concurrency: false }, () => {
   let releaseTestLock: (() => void) | undefined;
 
   before(async () => {
-    releaseTestLock = await acquireTestLock();
+    releaseTestLock = await acquireTestLock('a-commerce');
   });
 
   after(() => {

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

@@ -1,9 +1,7 @@
 import assert from 'node:assert';
 import { randomUUID } from 'node:crypto';
 import { after, before, describe, it } from 'node:test';
-import { app } from 'vona-mock';
-
-import { acquireTestLock } from './testLock.ts';
+import { acquireTestLock, app } from 'vona-mock';
 
 interface IFixture {
   categoryId?: number;
@@ -161,7 +159,7 @@ describe('paymentOutcome.test.ts', { concurrency: false, sequential: true }, ()
   let releaseTestLock: (() => void) | undefined;
 
   before(async () => {
-    releaseTestLock = await acquireTestLock();
+    releaseTestLock = await acquireTestLock('a-commerce');
   });
 
   after(() => {