cabloy 5.1.126 → 5.1.128

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/dto/refundResult.tsx

@@ -18,6 +18,9 @@ export class DtoRefundResult {
   @Api.field(v.optional(), v.tableIdentity())
   refundAttemptId?: TableIdentity;
 
+  @Api.field(v.optional(), v.tableIdentity())
+  refundOperationId?: TableIdentity;
+
   @Api.field(z.enum(['paid', 'refund_requested', 'refund_approved', 'refund_rejected', 'refunded']))
   orderState: 'paid' | 'refund_requested' | 'refund_approved' | 'refund_rejected' | 'refunded';
 

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');
     }
@@ -1157,7 +1165,7 @@ export class ServiceOrder extends BeanBase {
   private _refundResult(
     order: Pick<EntityOrder, 'id' | 'state' | 'currency'>,
     refundRequest: Pick<EntityRefundRequest, 'id' | 'state' | 'amountCents'>,
-    refundAttempt?: Pick<EntityRefundAttempt, 'id' | 'state'>,
+    refundAttempt?: Pick<EntityRefundAttempt, 'id' | 'state' | 'refundOperationId'>,
   ): DtoRefundResult {
     if (
       order.state !== 'paid' &&
@@ -1172,6 +1180,7 @@ export class ServiceOrder extends BeanBase {
       orderId: order.id,
       refundRequestId: refundRequest.id,
       refundAttemptId: refundAttempt?.id,
+      refundOperationId: refundAttempt?.refundOperationId,
       orderState: order.state,
       refundState: refundRequest.state,
       refundAttemptState: refundAttempt?.state,
@@ -1216,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/a-commerce/modules/commerce-trade/test/refundLifecycle.test.ts

@@ -16,6 +16,7 @@ interface IFixture {
   customerName?: string;
   orderId?: number;
   paymentAttemptId?: number;
+  paymentSessionId?: number;
 }
 
 async function cleanup(fixture: IFixture) {
@@ -24,6 +25,21 @@ async function cleanup(fixture: IFixture) {
   const promotion = app.scope('commerce-promotion');
   const catalog = app.scope('commerce-catalog');
   const member = app.scope('commerce-member');
+  const pay = app.scope('a-pay');
+  if (fixture.paymentSessionId !== undefined) {
+    const refundOperations = await pay.model.refundOperation.select({
+      where: { paymentSessionId: fixture.paymentSessionId },
+    });
+    for (const refundOperation of refundOperations) {
+      await pay.model.providerOperation.delete({ refundOperationId: refundOperation.id });
+      await pay.model.outboxEvent.delete({ refundOperationId: refundOperation.id });
+      await pay.model.webhookInbox.delete({ refundOperationId: refundOperation.id });
+      await pay.model.refundOperation.delete({ id: refundOperation.id });
+    }
+    await pay.model.outboxEvent.delete({ paymentSessionId: fixture.paymentSessionId });
+    await pay.model.webhookInbox.delete({ paymentSessionId: fixture.paymentSessionId });
+    await pay.model.providerOperation.delete({ paymentSessionId: fixture.paymentSessionId });
+  }
   if (fixture.orderId !== undefined) {
     const requests = await payment.model.refundRequest.select({
       where: { orderId: fixture.orderId },
@@ -39,6 +55,8 @@ async function cleanup(fixture: IFixture) {
     await payment.model.paymentAudit.delete({ paymentAttemptId: fixture.paymentAttemptId });
     await payment.model.paymentAttempt.delete({ id: fixture.paymentAttemptId });
   }
+  if (fixture.paymentSessionId !== undefined)
+    await pay.model.paymentSession.delete({ id: fixture.paymentSessionId });
   if (fixture.orderId !== undefined)
     await trade.model.orderAudit.delete({ orderId: fixture.orderId });
   if (fixture.skuId !== undefined) await trade.model.stockAudit.delete({ skuId: fixture.skuId });
@@ -152,10 +170,17 @@ async function createPaidOrder(suffix: string): Promise<IFixture> {
   });
   fixture.orderId = checkout.orderId as number;
   fixture.paymentAttemptId = checkout.paymentAttemptId as number;
-  await app.scope('commerce-trade').service.order.applyPaymentOutcome(fixture.paymentAttemptId, {
-    outcome: 'succeeded',
-    idempotencyKey: `refund-payment-${suffix}`,
+  fixture.paymentSessionId = checkout.paymentSessionId as number;
+  const pay = app.scope('a-pay');
+  await pay.service.paymentSession.start(fixture.paymentSessionId);
+  await app
+    .scope('pay-mock')
+    .service.payMock.completePaymentSession(fixture.paymentSessionId, 'succeeded');
+  const outbox = await pay.model.outboxEvent.get({
+    paymentSessionId: fixture.paymentSessionId,
+    eventType: 'payment.outcome.v1',
   });
+  await pay.queue.outboxDispatch.pushAsync({ outboxEventId: outbox!.id });
   return fixture;
 }
 
@@ -310,6 +335,89 @@ describe('refundLifecycle.test.ts', { concurrency: false, sequential: true }, ()
     });
   });
 
+  it('settles an executed mock-provider refund through the durable outbox', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const fixture: IFixture = {};
+      try {
+        Object.assign(fixture, await createPaidOrder(randomUUID().slice(0, 12)));
+        const order = app.scope('commerce-trade').service.order;
+        await order.requestRefund(fixture.orderId!, {
+          reason: 'provider-backed refund',
+          idempotencyKey: 'provider-backed-request-1',
+        });
+        await app.bean.passport.signout();
+        await app.bean.passport.signinMock();
+        await order.approveRefund(fixture.orderId!, {
+          reason: 'provider-backed approval',
+          idempotencyKey: 'provider-backed-approve-1',
+        });
+        const executed = await order.executeRefund(fixture.orderId!);
+        assert.ok(executed.refundAttemptId);
+        assert.ok(executed.refundOperationId);
+        assert.deepEqual(
+          [executed.orderState, executed.refundState, executed.refundAttemptState],
+          ['refund_approved', 'approved', 'created'],
+        );
+        const pay = app.scope('a-pay');
+        const refundOperation = await pay.model.refundOperation.getById(executed.refundOperationId);
+        const refundAttempt = await app
+          .scope('commerce-payment')
+          .model.refundAttempt.getById(executed.refundAttemptId);
+        assert.equal(String(refundAttempt?.refundOperationId), String(executed.refundOperationId));
+        assert.equal(refundOperation?.state, 'pending');
+        const receipt = await app
+          .scope('pay-mock')
+          .service.payMock.completeRefundOperation(executed.refundOperationId, 'succeeded');
+        assert.deepEqual(receipt, {
+          refundOperationId: executed.refundOperationId,
+          accepted: true,
+        });
+        const outbox = await pay.model.outboxEvent.get({
+          refundOperationId: executed.refundOperationId,
+          eventType: 'refund.outcome.v1',
+        });
+        assert.ok(outbox);
+        await pay.queue.outboxDispatch.pushAsync({ outboxEventId: outbox.id });
+        await pay.queue.outboxDispatch.pushAsync({ outboxEventId: outbox.id });
+        const [
+          dispatched,
+          settledOrder,
+          settledRequest,
+          settledAttempt,
+          line,
+          balance,
+          grant,
+          audits,
+        ] = await Promise.all([
+          pay.model.outboxEvent.getById(outbox.id),
+          app.scope('commerce-trade').model.order.getById(fixture.orderId!),
+          app.scope('commerce-payment').model.refundRequest.getById(executed.refundRequestId),
+          app.scope('commerce-payment').model.refundAttempt.getById(executed.refundAttemptId),
+          app.scope('commerce-trade').model.orderLine.get({ orderId: fixture.orderId }),
+          app.scope('commerce-trade').model.stockBalance.getById(fixture.balanceId!),
+          app.scope('commerce-promotion').model.couponGrant.getById(fixture.grantId!),
+          app
+            .scope('commerce-payment')
+            .model.refundAudit.select({ where: { orderId: fixture.orderId } }),
+        ]);
+        const reservation = await app
+          .scope('commerce-trade')
+          .model.stockReservation.get({ orderLineId: line?.id });
+        assert.deepEqual([dispatched?.state, dispatched?.attemptCount], ['dispatched', 1]);
+        assert.deepEqual(
+          [settledOrder?.state, settledRequest?.state, settledAttempt?.state, reservation?.state],
+          ['refunded', 'refunded', 'succeeded', 'restored'],
+        );
+        assert.deepEqual([balance?.onHand, balance?.reserved, balance?.available], [1, 0, 1]);
+        assert.equal(grant?.state, 'redeemed');
+        assert.equal(audits.filter(audit => audit.toRefundState === 'refunded').length, 1);
+      } finally {
+        await app.bean.passport.signout();
+        await cleanup(fixture);
+      }
+    });
+  });
+
   it('preserves rejected and failed cycles while permitting a fresh request', async () => {
     await app.bean.executor.mockCtx(async () => {
       const fixture: IFixture = {};

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"