cabloy 5.1.122 → 5.1.124

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

@@ -1153,13 +1153,11 @@ declare module 'vona-module-commerce-trade' {
 export * from '../controller/cart.ts';
 export * from '../controller/checkout.ts';
 export * from '../controller/order.ts';
-export * from '../controller/payment.ts';
 export * from '../controller/stockAudit.ts';
 export * from '../controller/stockBalance.ts';
 import type { IControllerOptionsCart } from '../controller/cart.ts';
 import type { IControllerOptionsCheckout } from '../controller/checkout.ts';
 import type { IControllerOptionsOrder } from '../controller/order.ts';
-import type { IControllerOptionsPayment } from '../controller/payment.ts';
 import type { IControllerOptionsStockAudit } from '../controller/stockAudit.ts';
 import type { IControllerOptionsStockBalance } from '../controller/stockBalance.ts';
 import 'vona-module-a-web';
@@ -1169,7 +1167,6 @@ declare module 'vona-module-a-web' {
       'commerce-trade:cart': IControllerOptionsCart;
 'commerce-trade:checkout': IControllerOptionsCheckout;
 'commerce-trade:order': IControllerOptionsOrder;
-'commerce-trade:payment': IControllerOptionsPayment;
 'commerce-trade:stockAudit': IControllerOptionsStockAudit;
 'commerce-trade:stockBalance': IControllerOptionsStockBalance;
     }
@@ -1211,17 +1208,6 @@ declare module 'vona-module-commerce-trade' {
             get $onionOptions(): IControllerOptionsOrder;
           }
 
-        export interface ControllerPayment {
-          /** @internal */
-          get scope(): ScopeModuleCommerceTrade;
-        }
-
-          export interface ControllerPayment {
-            get $beanFullName(): 'commerce-trade.controller.payment';
-            get $onionName(): 'commerce-trade:payment';
-            get $onionOptions(): IControllerOptionsPayment;
-          }
-
         export interface ControllerStockAudit {
           /** @internal */
           get scope(): ScopeModuleCommerceTrade;
@@ -1253,8 +1239,6 @@ import type { ControllerCheckout } from '../controller/checkout.ts';
 // @ts-ignore ignore
 import type { ControllerOrder } from '../controller/order.ts';
 // @ts-ignore ignore
-import type { ControllerPayment } from '../controller/payment.ts';
-// @ts-ignore ignore
 import type { ControllerStockAudit } from '../controller/stockAudit.ts';
 // @ts-ignore ignore
 import type { ControllerStockBalance } from '../controller/stockBalance.ts';
@@ -1272,10 +1256,6 @@ declare module 'vona-module-commerce-trade' {
       actions?: TypeControllerOptionsActions<ControllerOrder>;
     }
 
-    export interface IControllerOptionsPayment {
-      actions?: TypeControllerOptionsActions<ControllerPayment>;
-    }
-
     export interface IControllerOptionsStockAudit {
       actions?: TypeControllerOptionsActions<ControllerStockAudit>;
     }
@@ -1304,7 +1284,6 @@ export interface IApiPathPostRecord{
 '/commerce/trade/order/:id/rejectRefund': undefined;
 '/commerce/trade/order/:id/refundOutcome': undefined;
 '/commerce/trade/order/:id/ship': undefined;
-'/commerce/trade/payment/:attemptId/outcome': undefined;
 '/commerce/trade/stockBalance/adjustStock': undefined;
     }
 export interface IApiPathPatchRecord{

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

@@ -15,6 +15,9 @@ export class DtoCheckoutResult {
   @Api.field(v.tableIdentity())
   paymentAttemptId: TableIdentity;
 
+  @Api.field(v.tableIdentity())
+  paymentSessionId: TableIdentity;
+
   @Api.field(z.enum(['awaiting_payment', 'paid', 'cancelled', 'expired']))
   state: 'awaiting_payment' | 'paid' | 'cancelled' | 'expired';
 

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

@@ -1,5 +1,6 @@
 import type { TableIdentity } from 'table-identity';
 import type { IQueryParams } from 'vona-module-a-orm';
+import type { IPaymentOutcomeEvent } from 'vona-module-a-pay';
 import type { EntityPaymentAttempt } from 'vona-module-commerce-payment';
 import type {
   EntityRefundAttempt,
@@ -106,6 +107,7 @@ export type ShipmentFailureStage =
 type ShipmentStageCallback = (stage: ShipmentFailureStage) => void | Promise<void>;
 
 export type RefundFailureStage =
+  | 'beforeRefundOutcomeOrderLock'
   | 'afterRefundRequestInsert'
   | 'afterRefundRequestOrderState'
   | 'afterRefundRequestAudit'
@@ -336,6 +338,7 @@ export class ServiceOrder extends BeanBase {
     return {
       orderId: order.id,
       paymentAttemptId: paymentAttempt.id,
+      paymentSessionId: paymentAttempt.paymentSessionId!,
       state: 'awaiting_payment',
       paymentAttemptState: 'created',
       currency: order.currency,
@@ -344,6 +347,80 @@ export class ServiceOrder extends BeanBase {
     };
   }
 
+  @Core.transaction({ isolationLevel: 'SERIALIZABLE' })
+  @Core.retryable(serializationRetryOptions)
+  async settlePaymentFromProvider(event: IPaymentOutcomeEvent): Promise<DtoPaymentOutcomeResult> {
+    const attempt = await this.$scope.commercePayment.model.paymentAttempt.get({
+      paymentSessionId: event.paymentSessionId,
+    });
+    if (!attempt || String(attempt.id) !== event.businessReference) {
+      this.app.throw(404, 'commerce payment attempt not found');
+    }
+    const order = await this.scope.model.order.getByIdForUpdate(attempt.orderId);
+    if (!order) this.app.throw(404, 'order not found');
+    const lockedAttempt = await this.$scope.commercePayment.model.paymentAttempt.getByIdForUpdate(
+      attempt.id,
+    );
+    if (!lockedAttempt) this.app.throw(404, 'commerce payment attempt not found');
+    if (
+      lockedAttempt.amountCents !== event.amountMinor ||
+      lockedAttempt.currency !== event.currency ||
+      String(lockedAttempt.paymentSessionId) !== String(event.paymentSessionId) ||
+      lockedAttempt.providerName !== event.providerName
+    ) {
+      this.app.throw(409, 'provider event conflicts with the commerce payment attempt');
+    }
+    const existingAudit = await this.$scope.commercePayment.model.paymentAudit.get({
+      paymentAttemptId: lockedAttempt.id,
+      providerEventId: event.eventId,
+    });
+    if (existingAudit) return this._paymentOutcomeResult(order, lockedAttempt);
+    if (order.state !== 'awaiting_payment' || lockedAttempt.state !== 'created') {
+      this.app.throw(409, 'payment attempt is no longer available');
+    }
+    const correlationId = `${order.correlationId}:provider:${event.eventId}`;
+    const orderState = event.state === 'succeeded' ? 'paid' : 'cancelled';
+    const reason = `provider payment ${event.state}`;
+    await this.scope.model.order.updateById(order.id, { state: orderState });
+    const finalizedAttempt = await this.$scope.commercePayment.service.paymentAttempt.finalize(
+      order.id,
+      event.state,
+    );
+    if (!finalizedAttempt) this.app.throw(404, 'commerce payment attempt not found');
+    await this.$scope.commercePayment.model.paymentAttempt.updateById(finalizedAttempt.id, {
+      providerName: event.providerName,
+      providerCaptureId: event.providerCaptureId,
+    });
+    if (event.state === 'succeeded') {
+      await this._consumeReservedOrderResources(order, correlationId, reason);
+    } else {
+      await this._releaseReservedOrderResources(order, correlationId, reason);
+    }
+    await this.$scope.commercePayment.model.paymentAudit.insert({
+      paymentAttemptId: finalizedAttempt.id,
+      orderId: order.id,
+      userId: order.userId,
+      provider: event.providerName,
+      providerEventId: event.eventId,
+      outcome: event.state,
+      fromAttemptState: 'created',
+      toOrderState: orderState,
+      idempotencyKey: event.eventId.slice(0, 100),
+      correlationId,
+      reason,
+      processedAt: new Date(),
+    });
+    await this._appendAudit({
+      orderId: order.id,
+      operation: orderState === 'paid' ? 'paid' : 'cancelled',
+      fromState: 'awaiting_payment',
+      toState: orderState,
+      correlationId,
+      reason,
+    });
+    return this._paymentOutcomeResult({ ...order, state: orderState }, finalizedAttempt);
+  }
+
   @Core.transaction({ isolationLevel: 'SERIALIZABLE' })
   @Core.retryable(serializationRetryOptions)
   async applyPaymentOutcome(
@@ -585,6 +662,7 @@ export class ServiceOrder extends BeanBase {
   ): Promise<DtoRefundResult> {
     const idempotencyKey = command.idempotencyKey.trim();
     if (!idempotencyKey) this.app.throw(400, 'refund idempotencyKey is required');
+    await onStage?.('beforeRefundOutcomeOrderLock');
     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({
@@ -1132,6 +1210,7 @@ export class ServiceOrder extends BeanBase {
     return {
       orderId: order.id,
       paymentAttemptId: paymentAttempt.id,
+      paymentSessionId: paymentAttempt.paymentSessionId!,
       state: order.state,
       paymentAttemptState: paymentAttempt.state,
       currency: order.currency,

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

@@ -9,7 +9,9 @@ interface IFixture {
   productId?: number;
   skuId?: number;
   addressId?: number;
+  cartId?: number;
   orderId?: number;
+  paymentAttemptId?: number;
   couponTemplateId?: number;
   couponGrantId?: number;
   userId?: number;
@@ -17,10 +19,27 @@ interface IFixture {
 
 async function cleanup(fixture: IFixture) {
   const promotion = app.scope('commerce-promotion');
+  const payment = app.scope('commerce-payment');
   const trade = app.scope('commerce-trade');
   const catalog = app.scope('commerce-catalog');
   const member = app.scope('commerce-member');
   if (fixture.orderId !== undefined) {
+    const requests = await payment.model.refundRequest.select({
+      where: { orderId: fixture.orderId },
+    });
+    for (const request of requests) {
+      await payment.model.refundAudit.delete({ refundRequestId: request.id });
+      await payment.model.refundAttempt.delete({ refundRequestId: request.id });
+    }
+    await payment.model.refundRequest.delete({ orderId: fixture.orderId });
+    await trade.model.shipment.delete({ orderId: fixture.orderId });
+  }
+  if (fixture.paymentAttemptId !== undefined) {
+    await payment.model.paymentAudit.delete({ paymentAttemptId: fixture.paymentAttemptId });
+    await payment.model.paymentAttempt.delete({ id: fixture.paymentAttemptId });
+  }
+  if (fixture.orderId !== undefined) {
+    await trade.model.orderAudit.delete({ orderId: fixture.orderId });
     const lines = await trade.model.orderLine.select({ where: { orderId: fixture.orderId } });
     for (const line of lines) {
       await trade.model.stockReservation.delete({ orderLineId: line.id });
@@ -28,6 +47,10 @@ async function cleanup(fixture: IFixture) {
     await trade.model.orderLine.delete({ orderId: fixture.orderId });
     await trade.model.order.delete({ id: fixture.orderId });
   }
+  if (fixture.cartId !== undefined) {
+    await trade.model.cartItem.delete({ cartId: fixture.cartId });
+    await trade.model.cart.delete({ id: fixture.cartId });
+  }
   if (fixture.couponGrantId !== undefined) {
     await promotion.model.couponAudit.delete({ couponGrantId: fixture.couponGrantId });
     await promotion.model.couponGrant.delete({ id: fixture.couponGrantId });
@@ -222,4 +245,208 @@ describe('orderSnapshot.test.ts', { concurrency: false }, () => {
       }
     });
   });
+
+  it('keeps immutable purchase facts in the refunded customer order view', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const fixture: IFixture = {};
+      const suffix = randomUUID().slice(0, 12);
+      const original = {
+        addressCity: 'San Francisco',
+        addressLine1: '1 Market Street',
+        couponName: `refund snapshot coupon ${suffix}`,
+        productTitle: `refund snapshot product ${suffix}`,
+        skuCode: `refund-snapshot-sku-${suffix}`,
+        attributes: [{ name: 'Color', value: 'Black' }],
+      };
+      try {
+        await app.bean.passport.signinMock();
+        fixture.categoryId = await app.bean.executor.performAction(
+          'post',
+          '/commerce/catalog/category',
+          { body: { name: `refund snapshot category ${suffix}`, published: true } },
+        );
+        fixture.productId = await app.bean.executor.performAction(
+          'post',
+          '/commerce/catalog/product',
+          {
+            body: { categoryId: fixture.categoryId, title: original.productTitle, published: true },
+          },
+        );
+        fixture.skuId = await app.bean.executor.performAction('post', '/commerce/catalog/sku', {
+          body: {
+            productId: fixture.productId,
+            code: original.skuCode,
+            priceCents: 1299,
+            attributes: original.attributes,
+            lifecycle: 'active',
+          },
+        });
+        await app.scope('commerce-trade').service.stockBalance.adjustStock({
+          skuId: fixture.skuId,
+          delta: 1,
+          reason: 'refund snapshot fixture',
+          correlationId: `refund-snapshot-stock-${suffix}`,
+        });
+        await app.bean.passport.signout();
+
+        const customerName = `refund-snapshot-customer-${suffix}`;
+        const customer = await app.bean.user.register({ name: customerName }, true);
+        fixture.userId = customer.id as number;
+        await app.bean.passport.signinMock(customerName as any);
+        const userId = app.bean.passport.currentUser!.id;
+        fixture.couponTemplateId = (
+          await app.scope('commerce-promotion').model.couponTemplate.insert({
+            name: original.couponName,
+            state: 'active',
+            currency: 'USD',
+            discountCents: 500,
+            minSpendCents: 1_000,
+            validFrom: new Date(Date.now() - 1_000),
+            validUntil: new Date(Date.now() + 60_000),
+            issuedCount: 0,
+            redeemedCount: 0,
+          })
+        ).id as number;
+        fixture.couponGrantId = (
+          await app.scope('commerce-promotion').service.coupon.issue({
+            templateId: fixture.couponTemplateId,
+            userId,
+            correlationId: `refund-snapshot-coupon-${suffix}`,
+            reason: 'refund snapshot fixture',
+          })
+        ).id as number;
+        fixture.addressId = await app.bean.executor.performAction(
+          'post',
+          '/commerce/member/address/createMine',
+          {
+            body: {
+              recipientName: 'Refund Snapshot Recipient',
+              phone: '15555550123',
+              countryCode: 'US',
+              region: 'California',
+              city: original.addressCity,
+              postalCode: '94105',
+              addressLine1: original.addressLine1,
+            },
+          },
+        );
+        const cart = await app.scope('commerce-trade').model.cart.insert({ userId });
+        fixture.cartId = cart.id as number;
+        await app.scope('commerce-trade').model.cartItem.insert({
+          cartId: cart.id,
+          skuId: fixture.skuId,
+          quantity: 1,
+        });
+        const checkout = await app.scope('commerce-trade').service.order.checkout({
+          addressId: fixture.addressId,
+          couponGrantId: fixture.couponGrantId,
+          correlationId: `refund-snapshot-checkout-${suffix}`,
+        });
+        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-snapshot-payment-${suffix}`,
+          });
+
+        await app.scope('commerce-catalog').model.product.updateById(fixture.productId, {
+          title: 'Changed refund product title',
+          published: false,
+        });
+        await app.scope('commerce-catalog').model.sku.updateById(fixture.skuId, {
+          code: 'changed-refund-sku-code',
+          priceCents: 9999,
+          attributes: [{ name: 'Color', value: 'Blue' }],
+          lifecycle: 'inactive',
+        });
+        await app.scope('commerce-member').model.address.updateById(fixture.addressId, {
+          city: 'Oakland',
+          addressLine1: 'Changed refund address',
+        });
+        await app
+          .scope('commerce-promotion')
+          .model.couponTemplate.updateById(fixture.couponTemplateId, {
+            name: 'Changed refund coupon',
+            discountCents: 999,
+          });
+
+        await app.scope('commerce-trade').service.order.requestRefund(fixture.orderId, {
+          reason: 'snapshot refund request',
+          idempotencyKey: `refund-snapshot-request-${suffix}`,
+        });
+        await app.bean.passport.signout();
+        await app.bean.passport.signinMock();
+        await app.scope('commerce-trade').service.order.approveRefund(fixture.orderId, {
+          reason: 'snapshot refund approval',
+          idempotencyKey: `refund-snapshot-approval-${suffix}`,
+        });
+        await app.scope('commerce-trade').service.order.applyRefundOutcome(fixture.orderId, {
+          outcome: 'succeeded',
+          idempotencyKey: `refund-snapshot-outcome-${suffix}`,
+        });
+        await app.bean.passport.signout();
+        await app.bean.passport.signinMock(customerName as any);
+
+        const detail = await app.scope('commerce-trade').service.order.viewMine(fixture.orderId);
+        assert.equal(detail?.state, 'refunded');
+        assert.equal(detail?.shipment, undefined);
+        assert.equal(detail?.addressSnapshot.city, original.addressCity);
+        assert.equal(detail?.addressSnapshot.addressLine1, original.addressLine1);
+        assert.equal(detail?.couponSnapshot?.templateName, original.couponName);
+        assert.equal(detail?.couponSnapshot?.fixedDiscountCents, 500);
+        assert.equal(detail?.discountCents, 500);
+        assert.equal(detail?.payableTotalCents, 799);
+        assert.equal(detail?.lines.length, 1);
+        assert.deepEqual(
+          detail?.lines[0] && {
+            skuCodeSnapshot: detail.lines[0].skuCodeSnapshot,
+            titleSnapshot: detail.lines[0].titleSnapshot,
+            skuAttributesSnapshot: detail.lines[0].skuAttributesSnapshot,
+            unitPriceCents: detail.lines[0].unitPriceCents,
+            quantity: detail.lines[0].quantity,
+            lineTotalCents: detail.lines[0].lineTotalCents,
+          },
+          {
+            skuCodeSnapshot: original.skuCode,
+            titleSnapshot: original.productTitle,
+            skuAttributesSnapshot: original.attributes,
+            unitPriceCents: 1299,
+            quantity: 1,
+            lineTotalCents: 1299,
+          },
+        );
+        const liveProduct = await app
+          .scope('commerce-catalog')
+          .model.product.getById(fixture.productId);
+        const liveSku = await app.scope('commerce-catalog').model.sku.getById(fixture.skuId);
+        const liveAddress = await app
+          .scope('commerce-member')
+          .model.address.getById(fixture.addressId);
+        const liveCoupon = await app
+          .scope('commerce-promotion')
+          .model.couponTemplate.getById(fixture.couponTemplateId);
+        assert.deepEqual(
+          [
+            liveProduct?.title,
+            liveSku?.code,
+            liveSku?.priceCents,
+            liveAddress?.city,
+            liveCoupon?.name,
+          ],
+          [
+            'Changed refund product title',
+            'changed-refund-sku-code',
+            9999,
+            'Oakland',
+            'Changed refund coupon',
+          ],
+        );
+      } finally {
+        await cleanup(fixture);
+        await app.bean.passport.signout();
+      }
+    });
+  });
 });

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

@@ -1,7 +1,7 @@
 import assert from 'node:assert';
-import { randomUUID } from 'node:crypto';
-import { after, before, describe, it } from 'node:test';
-import { acquireTestLock, app } from 'vona-mock';
+import { createHmac, randomUUID } from 'node:crypto';
+import { describe, it } from 'node:test';
+import { app } from 'vona-mock';
 
 interface IFixture {
   categoryId?: number;
@@ -17,6 +17,7 @@ interface IFixture {
   checkoutCorrelationId?: string;
   orderId?: number;
   paymentAttemptId?: number;
+  paymentSessionId?: number;
 }
 
 async function cleanup(fixture: IFixture) {
@@ -25,10 +26,18 @@ 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) {
+    await pay.model.outboxEvent.delete({ paymentSessionId: fixture.paymentSessionId });
+    await pay.model.paymentAudit.delete({ paymentSessionId: fixture.paymentSessionId });
+    await pay.model.webhookInbox.delete({ paymentSessionId: fixture.paymentSessionId });
+  }
   if (fixture.paymentAttemptId !== undefined)
     await payment.model.paymentAudit.delete({ paymentAttemptId: fixture.paymentAttemptId });
   if (fixture.paymentAttemptId !== undefined)
     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,18 +161,81 @@ async function createCheckoutFixture(suffix: string, withCoupon = true): Promise
   });
   fixture.orderId = checkout.orderId as number;
   fixture.paymentAttemptId = checkout.paymentAttemptId as number;
+  fixture.paymentSessionId = checkout.paymentSessionId as number;
   return fixture;
 }
 
 describe('paymentOutcome.test.ts', { concurrency: false, sequential: true }, () => {
-  let releaseTestLock: (() => void) | undefined;
-
-  before(async () => {
-    releaseTestLock = await acquireTestLock('a-commerce');
-  });
-
-  after(() => {
-    releaseTestLock?.();
+  it('delivers a signed webhook through the durable outbox to Commerce exactly once', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const fixture: IFixture = {};
+      try {
+        Object.assign(fixture, await createCheckoutFixture(randomUUID().slice(0, 12)));
+        const eventId = `provider-${randomUUID().slice(0, 12)}`;
+        const rawBody = JSON.stringify({
+          paymentSessionId: String(fixture.paymentSessionId),
+          currency: 'USD',
+          amountMinor: 799,
+          eventType: 'payment.succeeded',
+          eventId,
+          state: 'succeeded',
+          providerPaymentId: `payment-${eventId}`,
+          providerCaptureId: `capture-${eventId}`,
+        });
+        const options = app.bean.payProvider.getOptions('pay-mock:mock', 'default');
+        assert.equal(typeof options.secretWebhook, 'string');
+        const signature = createHmac('sha256', options.secretWebhook).update(rawBody).digest('hex');
+        const webhookPath = app.util.getAbsoluteUrlByApiPath('/pay/webhook/pay-mock:mock/default');
+        const webhookUrl = webhookPath.startsWith('http')
+          ? webhookPath
+          : `http://127.0.0.1:${app.config.server.listen.port}${webhookPath}`;
+        const response = await fetch(webhookUrl, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'x-pay-mock-signature': signature,
+          },
+          body: rawBody,
+        });
+        assert.equal(response.status, 200);
+        const pay = app.scope('a-pay');
+        const outbox = await pay.model.outboxEvent.get({
+          paymentSessionId: fixture.paymentSessionId,
+        });
+        assert.ok(outbox);
+        await pay.queue.outboxDispatch.pushAsync({ outboxEventId: outbox.id });
+        await pay.queue.outboxDispatch.pushAsync({ outboxEventId: outbox.id });
+        const [dispatched, order, attempt, line, balance, grant, paymentAudits] = await Promise.all(
+          [
+            pay.model.outboxEvent.getById(outbox.id),
+            app.scope('commerce-trade').model.order.getById(fixture.orderId!),
+            app.scope('commerce-payment').model.paymentAttempt.getById(fixture.paymentAttemptId!),
+            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.paymentAudit.select({
+              where: { paymentAttemptId: fixture.paymentAttemptId },
+            }),
+          ],
+        );
+        const reservation = await app.scope('commerce-trade').model.stockReservation.get({
+          orderLineId: line?.id,
+        });
+        assert.deepEqual([dispatched?.state, dispatched?.attemptCount], ['dispatched', 1]);
+        assert.equal(dispatched?.claimToken, undefined);
+        assert.deepEqual(
+          [order?.state, attempt?.state, reservation?.state],
+          ['paid', 'succeeded', 'consumed'],
+        );
+        assert.deepEqual([balance?.onHand, balance?.reserved, balance?.available], [0, 0, 0]);
+        assert.equal(grant?.state, 'redeemed');
+        assert.equal(paymentAudits.length, 1);
+        assert.equal(paymentAudits[0]?.providerEventId, eventId);
+      } finally {
+        await cleanup(fixture);
+        await app.bean.passport.signout();
+      }
+    });
   });
 
   it('settles a successful payment exactly once with stock and coupon consumption', async () => {
@@ -214,6 +286,43 @@ describe('paymentOutcome.test.ts', { concurrency: false, sequential: true }, ()
     });
   });
 
+  it('settles a provider event without customer Passport authority', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const fixture: IFixture = {};
+      try {
+        Object.assign(fixture, await createCheckoutFixture(randomUUID().slice(0, 12)));
+        await app.bean.passport.signout();
+        const event = {
+          eventId: `provider-${randomUUID().slice(0, 12)}`,
+          paymentSessionId: fixture.paymentSessionId!,
+          businessReference: String(fixture.paymentAttemptId),
+          providerName: 'pay-mock:mock',
+          state: 'succeeded' as const,
+          providerCaptureId: `capture-${randomUUID().slice(0, 12)}`,
+          amountMinor: 799,
+          currency: 'USD',
+        };
+        const first = await app
+          .scope('commerce-trade')
+          .service.order.settlePaymentFromProvider(event);
+        const replay = await app
+          .scope('commerce-trade')
+          .service.order.settlePaymentFromProvider(event);
+        assert.deepEqual(replay, first);
+        assert.deepEqual([first.orderState, first.paymentAttemptState], ['paid', 'succeeded']);
+        const audits = await app.scope('commerce-payment').model.paymentAudit.select({
+          where: { paymentAttemptId: fixture.paymentAttemptId },
+        });
+        assert.equal(audits.length, 1);
+        assert.equal(audits[0]?.providerEventId, event.eventId);
+        assert.equal(audits[0]?.actorId, undefined);
+      } finally {
+        await cleanup(fixture);
+        await app.bean.passport.signout();
+      }
+    });
+  });
+
   it('accepts one concurrent PostgreSQL success event without duplicate effects', async t => {
     if (process.env.DATABASE_DEFAULT_CLIENT !== 'pg') {
       t.skip('requires PostgreSQL row-lock contention');
@@ -438,9 +547,8 @@ describe('paymentOutcome.test.ts', { concurrency: false, sequential: true }, ()
             innerAccess: false,
           }),
         () =>
-          app.bean.executor.performAction('post', '/commerce/trade/payment/1/outcome', {
+          app.bean.executor.performAction('get', '/payment-session/1', {
             innerAccess: false,
-            body: { outcome: 'succeeded', idempotencyKey: 'anonymous-payment-1' },
           }),
       ];
       for (const request of requests) {