cabloy 5.1.115 → 5.1.116

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

@@ -1,8 +1,10 @@
 import assert from 'node:assert';
 import { randomUUID } from 'node:crypto';
-import { describe, it } from 'node:test';
+import { after, before, describe, it } from 'node:test';
 import { app } from 'vona-mock';
 
+import { acquireTestLock } from './testLock.ts';
+
 interface IFixture {
   categoryId?: number;
   productId?: number;
@@ -48,6 +50,16 @@ async function cleanup(fixture: IFixture) {
 }
 
 describe('checkoutReservation.test.ts', { concurrency: false }, () => {
+  let releaseTestLock: (() => void) | undefined;
+
+  before(async () => {
+    releaseTestLock = await acquireTestLock();
+  });
+
+  after(() => {
+    releaseTestLock?.();
+  });
+
   it('creates an atomic checkout from the persisted cart and replays its correlation', async () => {
     await app.bean.executor.mockCtx(async () => {
       const fixture: IFixture = {};
@@ -155,4 +167,246 @@ describe('checkoutReservation.test.ts', { concurrency: false }, () => {
       }
     });
   });
+
+  it('allows exactly one independently authenticated customer to checkout the final unit', async t => {
+    if (process.env.DATABASE_DEFAULT_CLIENT !== 'pg') {
+      t.skip('requires PostgreSQL row-lock contention');
+      return;
+    }
+
+    const suffix = randomUUID().slice(0, 12);
+    const fixture: {
+      categoryId?: number;
+      productId?: number;
+      skuId?: number;
+      balanceId?: number;
+      customers: Array<{
+        name: string;
+        userId: number;
+        addressId: number;
+        cartId: number;
+        cartItemId: number;
+        correlationId: string;
+      }>;
+    } = { customers: [] };
+
+    const createCustomerCheckout = async (name: string, index: number) => {
+      return await app.bean.executor.mockCtx(async () => {
+        const user = await app.bean.user.register({ name }, true);
+        const trade = app.scope('commerce-trade');
+        await app.bean.passport.signinMock(name as any);
+        try {
+          const addressId = await app.bean.executor.performAction(
+            'post',
+            '/commerce/member/address',
+            {
+              body: {
+                recipientName: `Checkout Contention Customer ${index}`,
+                phone: `1555555012${index}`,
+                countryCode: 'US',
+                region: 'California',
+                city: 'San Francisco',
+                postalCode: '94105',
+                addressLine1: `${index} Market Street`,
+              },
+            },
+          );
+          const cart = await trade.model.cart.insert({ userId: user.id });
+          const cartItem = await trade.model.cartItem.insert({
+            cartId: cart.id,
+            skuId: fixture.skuId!,
+            quantity: 1,
+          });
+          return {
+            name,
+            userId: user.id as number,
+            addressId,
+            cartId: cart.id as number,
+            cartItemId: cartItem.id as number,
+            correlationId: `checkout-contention-${suffix}-${index}`,
+          };
+        } finally {
+          await app.bean.passport.signout();
+        }
+      });
+    };
+
+    try {
+      await app.bean.executor.mockCtx(async () => {
+        await app.bean.passport.signinMock();
+        try {
+          const trade = app.scope('commerce-trade');
+          fixture.categoryId = await app.bean.executor.performAction(
+            'post',
+            '/commerce/catalog/category',
+            { body: { name: `checkout-contention-category-${suffix}`, published: true } },
+          );
+          fixture.productId = await app.bean.executor.performAction(
+            'post',
+            '/commerce/catalog/product',
+            {
+              body: {
+                categoryId: fixture.categoryId,
+                title: `checkout-contention-product-${suffix}`,
+                published: true,
+              },
+            },
+          );
+          fixture.skuId = await app.bean.executor.performAction('post', '/commerce/catalog/sku', {
+            body: {
+              productId: fixture.productId,
+              code: `checkout-contention-sku-${suffix}`,
+              priceCents: 1299,
+              attributes: [],
+              lifecycle: 'active',
+            },
+          });
+          const balance = await trade.service.stockBalance.adjustStock({
+            skuId: fixture.skuId,
+            delta: 1,
+            reason: 'checkout contention fixture',
+            correlationId: `checkout-contention-stock-${suffix}`,
+          });
+          fixture.balanceId = balance.id as number;
+        } finally {
+          await app.bean.passport.signout();
+        }
+      });
+
+      fixture.customers.push(
+        await createCustomerCheckout(`checkout-contention-a-${suffix}`, 1),
+        await createCustomerCheckout(`checkout-contention-b-${suffix}`, 2),
+      );
+      assert.notEqual(fixture.customers[0].userId, fixture.customers[1].userId);
+      assert.notEqual(fixture.customers[0].addressId, fixture.customers[1].addressId);
+      assert.notEqual(fixture.customers[0].cartId, fixture.customers[1].cartId);
+
+      const checkoutInContext = async (customer: (typeof fixture.customers)[number]) => {
+        return await app.bean.executor.mockCtx(async () => {
+          await app.bean.passport.signinMock(customer.name as any);
+          try {
+            return await app.scope('commerce-trade').service.order.checkout({
+              addressId: customer.addressId,
+              correlationId: customer.correlationId,
+            });
+          } finally {
+            await app.bean.passport.signout();
+          }
+        });
+      };
+      const results = await Promise.allSettled(fixture.customers.map(checkoutInContext));
+      assert.equal(
+        results.filter(result => result.status === 'fulfilled').length,
+        1,
+        JSON.stringify(results),
+      );
+      assert.equal(
+        results.filter(result => result.status === 'rejected').length,
+        1,
+        JSON.stringify(results),
+      );
+      const rejected = results.find(result => result.status === 'rejected');
+      assert.equal(
+        (rejected as PromiseRejectedResult | undefined)?.reason?.code,
+        409,
+        String((rejected as PromiseRejectedResult | undefined)?.reason),
+      );
+
+      const winningIndex = results.findIndex(result => result.status === 'fulfilled');
+      assert.notEqual(winningIndex, -1);
+      const winningResult = results[winningIndex];
+      assert.equal(winningResult.status, 'fulfilled');
+      if (winningResult.status !== 'fulfilled') throw new Error('expected a successful checkout');
+      const winner = fixture.customers[winningIndex];
+      const loser = fixture.customers[winningIndex === 0 ? 1 : 0];
+
+      await app.bean.executor.mockCtx(async () => {
+        const trade = app.scope('commerce-trade');
+        const payment = app.scope('commerce-payment');
+        const winningOrder = await trade.model.order.get({ correlationId: winner.correlationId });
+        const losingOrder = await trade.model.order.get({ correlationId: loser.correlationId });
+        assert.ok(winningOrder);
+        assert.equal(winningOrder.id, winningResult.value.orderId);
+        assert.equal(losingOrder, undefined);
+
+        const lines = await trade.model.orderLine.select({ where: { orderId: winningOrder.id } });
+        assert.equal(lines.length, 1);
+        assert.equal(String(lines[0].skuId), String(fixture.skuId));
+        assert.equal(lines[0].quantity, 1);
+        const reservations = await trade.model.stockReservation.select({
+          where: { skuId: fixture.skuId },
+        });
+        assert.equal(reservations.length, 1);
+        assert.equal(String(reservations[0].orderLineId), String(lines[0].id));
+        assert.equal(reservations[0].state, 'reserved');
+
+        const paymentAttempt = await payment.model.paymentAttempt.get({ orderId: winningOrder.id });
+        assert.equal(paymentAttempt?.id, winningResult.value.paymentAttemptId);
+        assert.equal(paymentAttempt?.state, 'created');
+        const orderAudits = await trade.model.orderAudit.select({
+          where: { orderId: winningOrder.id },
+        });
+        assert.deepEqual(
+          orderAudits.map(audit => audit.operation),
+          ['created'],
+        );
+        const stockAudits = await trade.model.stockAudit.select({
+          where: { skuId: fixture.skuId },
+          orders: [['id', 'asc']],
+        });
+        assert.deepEqual(
+          stockAudits.map(audit => audit.operation),
+          ['adjust', 'reserve'],
+        );
+        assert.equal(
+          stockAudits.some(audit => audit.correlationId === `${winner.correlationId}:line:0`),
+          true,
+        );
+
+        const balance = await trade.model.stockBalance.getById(fixture.balanceId!);
+        assert.deepEqual([balance?.onHand, balance?.reserved, balance?.available], [1, 1, 0]);
+        assert.equal(await trade.model.cartItem.getById(winner.cartItemId), undefined);
+        assert.equal((await trade.model.cartItem.getById(loser.cartItemId))?.quantity, 1);
+      });
+    } finally {
+      await app.bean.executor.mockCtx(async () => {
+        const trade = app.scope('commerce-trade');
+        const payment = app.scope('commerce-payment');
+        const catalog = app.scope('commerce-catalog');
+        const member = app.scope('commerce-member');
+        for (const customer of fixture.customers) {
+          const orders = await trade.model.order.select({
+            where: { correlationId: customer.correlationId },
+          });
+          for (const order of orders) {
+            await payment.model.paymentAttempt.delete({ orderId: order.id });
+            await trade.model.orderAudit.delete({ orderId: order.id });
+            const lines = await trade.model.orderLine.select({ where: { orderId: order.id } });
+            for (const line of lines)
+              await trade.model.stockReservation.delete({ orderLineId: line.id });
+            await trade.model.orderLine.delete({ orderId: order.id });
+            await trade.model.order.delete({ id: order.id });
+          }
+          await trade.model.cartItem.delete({ cartId: customer.cartId });
+          await trade.model.cart.delete({ id: customer.cartId });
+          await member.model.address.delete({ id: customer.addressId });
+        }
+        if (fixture.skuId !== undefined) {
+          await trade.model.stockReservation.delete({ skuId: fixture.skuId });
+          await trade.model.stockAudit.delete({ skuId: fixture.skuId });
+        }
+        if (fixture.balanceId !== undefined)
+          await trade.model.stockBalance.delete({ id: fixture.balanceId });
+        if (fixture.skuId !== undefined) await catalog.model.sku.delete({ id: fixture.skuId });
+        if (fixture.productId !== undefined)
+          await catalog.model.product.delete({ id: fixture.productId });
+        if (fixture.categoryId !== undefined)
+          await catalog.model.category.delete({ id: fixture.categoryId });
+        for (const customer of fixture.customers) {
+          await app.scope('home-user').model.roleUser.delete({ userId: customer.userId });
+          await app.bean.user.removeById(customer.userId);
+        }
+      });
+    }
+  });
 });

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

@@ -0,0 +1,208 @@
+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 type { CheckoutFailureStage } from '../src/service/order.ts';
+
+import { acquireTestLock } from './testLock.ts';
+
+interface IFixture {
+  categoryId: number;
+  productId: number;
+  skuId: number;
+  balanceId: number;
+  templateId: number;
+  grantId: number;
+  addressId: number;
+  cartId: number;
+  cartItemId: number;
+  userId: number;
+  correlationId: string;
+}
+
+async function createFixture(suffix: string): Promise<IFixture> {
+  const userId = app.bean.passport.currentUser!.id as number;
+  const categoryId = await app.bean.executor.performAction('post', '/commerce/catalog/category', {
+    body: { name: `checkout-txn-category-${suffix}`, published: true },
+  });
+  const productId = await app.bean.executor.performAction('post', '/commerce/catalog/product', {
+    body: { categoryId, title: `checkout-txn-product-${suffix}`, published: true },
+  });
+  const skuId = await app.bean.executor.performAction('post', '/commerce/catalog/sku', {
+    body: {
+      productId,
+      code: `checkout-txn-sku-${suffix}`,
+      priceCents: 1299,
+      attributes: [],
+      lifecycle: 'active',
+    },
+  });
+  const balance = await app.scope('commerce-trade').service.stockBalance.adjustStock({
+    skuId,
+    delta: 1,
+    reason: 'checkout transaction fixture',
+    correlationId: `checkout-txn-stock-${suffix}`,
+  });
+  const template = await app.scope('commerce-promotion').model.couponTemplate.insert({
+    name: `checkout-txn-coupon-${suffix}`,
+    state: 'active',
+    currency: 'USD',
+    discountCents: 500,
+    minSpendCents: 1000,
+    validFrom: new Date(Date.now() - 1_000),
+    validUntil: new Date(Date.now() + 60_000),
+    issuedCount: 0,
+    redeemedCount: 0,
+  });
+  const grant = await app.scope('commerce-promotion').service.coupon.issue({
+    templateId: template.id,
+    userId,
+    correlationId: `checkout-txn-coupon-${suffix}`,
+    reason: 'checkout transaction fixture',
+  });
+  const addressId = await app.bean.executor.performAction('post', '/commerce/member/address', {
+    body: {
+      recipientName: 'Checkout Transaction Customer',
+      phone: '15555550125',
+      countryCode: 'US',
+      region: 'California',
+      city: 'San Francisco',
+      postalCode: '94105',
+      addressLine1: '3 Market Street',
+    },
+  });
+  const cart = await app.scope('commerce-trade').model.cart.insert({ userId });
+  const cartItem = await app.scope('commerce-trade').model.cartItem.insert({
+    cartId: cart.id,
+    skuId,
+    quantity: 1,
+  });
+  return {
+    categoryId,
+    productId,
+    skuId,
+    balanceId: balance.id as number,
+    templateId: template.id as number,
+    grantId: grant.id as number,
+    addressId,
+    cartId: cart.id as number,
+    cartItemId: cartItem.id as number,
+    userId,
+    correlationId: `checkout-txn-${suffix}`,
+  };
+}
+
+async function cleanup(fixture: IFixture) {
+  const trade = app.scope('commerce-trade');
+  const payment = app.scope('commerce-payment');
+  const promotion = app.scope('commerce-promotion');
+  const catalog = app.scope('commerce-catalog');
+  const member = app.scope('commerce-member');
+  const orders = await trade.model.order.select({
+    where: { correlationId: fixture.correlationId },
+  });
+  for (const order of orders) {
+    await payment.model.paymentAttempt.delete({ orderId: order.id });
+    await trade.model.orderAudit.delete({ orderId: order.id });
+    const lines = await trade.model.orderLine.select({ where: { orderId: order.id } });
+    for (const line of lines) await trade.model.stockReservation.delete({ orderLineId: line.id });
+    await trade.model.orderLine.delete({ orderId: order.id });
+    await trade.model.order.delete({ id: order.id });
+  }
+  await promotion.model.couponAudit.delete({ couponGrantId: fixture.grantId });
+  await promotion.model.couponGrant.delete({ id: fixture.grantId });
+  await promotion.model.couponTemplate.delete({ id: fixture.templateId });
+  await trade.model.cartItem.delete({ cartId: fixture.cartId });
+  await trade.model.cart.delete({ id: fixture.cartId });
+  await trade.model.stockAudit.delete({ skuId: fixture.skuId });
+  await trade.model.stockReservation.delete({ skuId: fixture.skuId });
+  await trade.model.stockBalance.delete({ id: fixture.balanceId });
+  await catalog.model.sku.delete({ id: fixture.skuId });
+  await catalog.model.product.delete({ id: fixture.productId });
+  await catalog.model.category.delete({ id: fixture.categoryId });
+  await member.model.address.delete({ id: fixture.addressId });
+  await app.scope('home-user').model.roleUser.delete({ userId: fixture.userId });
+  await app.bean.user.removeById(fixture.userId);
+}
+
+async function assertRollback(fixture: IFixture) {
+  const trade = app.scope('commerce-trade');
+  const promotion = app.scope('commerce-promotion');
+  assert.equal(await trade.model.order.get({ correlationId: fixture.correlationId }), undefined);
+  assert.equal(await trade.model.stockReservation.get({ skuId: fixture.skuId }), undefined);
+  const cartItem = await trade.model.cartItem.getById(fixture.cartItemId);
+  assert.equal(cartItem?.quantity, 1);
+  const balance = await trade.model.stockBalance.getById(fixture.balanceId);
+  assert.deepEqual([balance?.onHand, balance?.reserved, balance?.available], [1, 0, 1]);
+  const stockAudits = await trade.model.stockAudit.select({ where: { skuId: fixture.skuId } });
+  assert.equal(stockAudits.filter(audit => audit.operation === 'reserve').length, 0);
+  const grant = await promotion.model.couponGrant.getById(fixture.grantId);
+  assert.equal(grant?.state, 'available');
+  assert.equal(grant?.reservationOrderId, undefined);
+  const couponAudits = await promotion.model.couponAudit.select({
+    where: { couponGrantId: fixture.grantId },
+  });
+  assert.deepEqual(
+    couponAudits.map(audit => audit.operation),
+    ['issue'],
+  );
+}
+
+describe('checkoutTransaction.test.ts', { concurrency: false, sequential: true }, () => {
+  let releaseTestLock: (() => void) | undefined;
+
+  before(async () => {
+    releaseTestLock = await acquireTestLock();
+  });
+
+  after(() => {
+    releaseTestLock?.();
+  });
+
+  for (const stage of [
+    'afterOrderSnapshot',
+    'afterCouponReservation',
+    'afterStockReservation',
+    'afterPaymentAttempt',
+    'afterOrderAudit',
+    'afterCartMutation',
+  ] satisfies CheckoutFailureStage[]) {
+    it(`rolls back every checkout write when ${stage} fails`, async () => {
+      await app.bean.executor.mockCtx(async () => {
+        const suffix = randomUUID().slice(0, 12);
+        const customerName = `checkout-txn-customer-${suffix}`;
+        await app.bean.user.register({ name: customerName }, true);
+        await app.bean.passport.signinMock(customerName as any);
+        let fixture: IFixture | undefined;
+        try {
+          fixture = await createFixture(suffix);
+          const [_, error] = await catchError(() =>
+            app.scope('commerce-trade').service.order.checkoutForTest(
+              {
+                addressId: fixture.addressId,
+                couponGrantId: fixture.grantId,
+                correlationId: fixture.correlationId,
+              },
+              async currentStage => {
+                if (currentStage === stage) throw new Error(`checkout test failure: ${stage}`);
+              },
+            ),
+          );
+          assert.match(error?.message ?? '', new RegExp(stage));
+          await assertRollback(fixture);
+          const result = await app.scope('commerce-trade').service.order.checkout({
+            addressId: fixture.addressId,
+            couponGrantId: fixture.grantId,
+            correlationId: fixture.correlationId,
+          });
+          assert.equal(result.state, 'awaiting_payment');
+        } finally {
+          if (fixture) await cleanup(fixture);
+          await app.bean.passport.signout();
+        }
+      });
+    });
+  }
+});

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

@@ -1,8 +1,11 @@
 import { catchError } from '@cabloy/utils';
 import assert from 'node:assert';
-import { describe, it } from 'node:test';
+import { randomUUID } from 'node:crypto';
+import { after, before, describe, it } from 'node:test';
 import { app } from 'vona-mock';
 
+import { acquireTestLock } from './testLock.ts';
+
 interface IFixture {
   categoryId?: number;
   productId?: number;
@@ -11,6 +14,7 @@ interface IFixture {
   orderId?: number;
   couponTemplateId?: number;
   couponGrantId?: number;
+  userId?: number;
 }
 
 async function cleanup(fixture: IFixture) {
@@ -44,13 +48,27 @@ async function cleanup(fixture: IFixture) {
   if (fixture.categoryId !== undefined)
     await catalog.model.category.delete({ id: fixture.categoryId });
   if (fixture.addressId !== undefined) await member.model.address.delete({ id: fixture.addressId });
+  if (fixture.userId !== undefined) {
+    await app.scope('home-user').model.roleUser.delete({ userId: fixture.userId });
+    await app.bean.user.removeById(fixture.userId);
+  }
 }
 
 describe('orderSnapshot.test.ts', { concurrency: false }, () => {
+  let releaseTestLock: (() => void) | undefined;
+
+  before(async () => {
+    releaseTestLock = await acquireTestLock();
+  });
+
+  after(() => {
+    releaseTestLock?.();
+  });
+
   it('persists catalog and address facts independently from later source changes', async () => {
     await app.bean.executor.mockCtx(async () => {
       const fixture: IFixture = {};
-      const suffix = `${Date.now()}`;
+      const suffix = randomUUID().slice(0, 12);
       try {
         await app.bean.passport.signinMock();
         fixture.categoryId = await app.bean.executor.performAction(
@@ -87,7 +105,14 @@ describe('orderSnapshot.test.ts', { concurrency: false }, () => {
           correlationId: `snapshot-stock-${suffix}`,
         });
         await app.bean.passport.signout();
-        await app.bean.passport.signinMock();
+
+        const customerName = `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 customerId = app.bean.passport.currentUser!.id;
+        assert.equal(String(customerId), String(fixture.userId));
+
         fixture.couponTemplateId = (
           await app.scope('commerce-promotion').model.couponTemplate.insert({
             name: `snapshot coupon ${suffix}`,
@@ -101,7 +126,6 @@ describe('orderSnapshot.test.ts', { concurrency: false }, () => {
             redeemedCount: 0,
           })
         ).id as number;
-        const customerId = app.bean.passport.currentUser!.id;
         fixture.couponGrantId = (
           await app.scope('commerce-promotion').service.coupon.issue({
             templateId: fixture.couponTemplateId,