cabloy 5.1.115 → 5.1.116

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

@@ -20,7 +20,12 @@ const serializationRetryOptions = {
   minTimeout: 0,
   maxTimeout: 0,
   randomize: false,
-  errorCodes: ['40001'],
+  errorCodes: ['40001', 'ER_LOCK_DEADLOCK', 'ER_LOCK_WAIT_TIMEOUT'],
+};
+
+const checkoutSerializationRetryOptions = {
+  ...serializationRetryOptions,
+  retries: 3,
 };
 
 export interface IOrderSnapshotLineCommand {
@@ -40,6 +45,16 @@ export interface IOrderSnapshotCreateResult {
   lines: EntityOrderLine[];
 }
 
+export type CheckoutFailureStage =
+  | 'afterOrderSnapshot'
+  | 'afterCouponReservation'
+  | 'afterStockReservation'
+  | 'afterPaymentAttempt'
+  | 'afterOrderAudit'
+  | 'afterCartMutation';
+
+type CheckoutStageCallback = (stage: CheckoutFailureStage) => void | Promise<void>;
+
 interface IPreparedOrderLine {
   index: number;
   skuId: TableIdentity;
@@ -157,8 +172,24 @@ export class ServiceOrder extends BeanBase {
   }
 
   @Core.transaction({ isolationLevel: 'SERIALIZABLE' })
-  @Core.retryable(serializationRetryOptions)
+  @Core.retryable(checkoutSerializationRetryOptions)
   async checkout(command: DtoCheckoutCreate): Promise<DtoCheckoutResult> {
+    return await this._checkout(command);
+  }
+
+  @Core.transaction({ isolationLevel: 'SERIALIZABLE' })
+  @Core.retryable(serializationRetryOptions)
+  async checkoutForTest(
+    command: DtoCheckoutCreate,
+    onStage: CheckoutStageCallback,
+  ): Promise<DtoCheckoutResult> {
+    return await this._checkout(command, onStage);
+  }
+
+  private async _checkout(
+    command: DtoCheckoutCreate,
+    onStage?: CheckoutStageCallback,
+  ): Promise<DtoCheckoutResult> {
     this._assertCheckoutCommand(command);
     const userId = this.bean.passport.currentUser!.id;
     const existingOrder = await this.scope.model.order.getForUpdate({
@@ -211,6 +242,7 @@ export class ServiceOrder extends BeanBase {
       couponGrantId: command.couponGrantId,
       preparedLines,
       reason: 'checkout created',
+      onStage,
     });
     const paymentAttempt = await this.$scope.commercePayment.service.paymentAttempt.create({
       orderId: order.id,
@@ -219,6 +251,7 @@ export class ServiceOrder extends BeanBase {
       amountCents: order.payableTotalCents,
       correlationId: `${command.correlationId}:payment`,
     });
+    await onStage?.('afterPaymentAttempt');
     await this._appendAudit({
       orderId: order.id,
       operation: 'created',
@@ -226,9 +259,11 @@ export class ServiceOrder extends BeanBase {
       correlationId: command.correlationId,
       reason: 'checkout created',
     });
+    await onStage?.('afterOrderAudit');
     for (const item of lockedCartItems) {
       await this.scope.model.cartItem.deleteById(item.id);
     }
+    await onStage?.('afterCartMutation');
     return {
       orderId: order.id,
       paymentAttemptId: paymentAttempt.id,
@@ -315,6 +350,7 @@ export class ServiceOrder extends BeanBase {
     couponGrantId,
     preparedLines,
     reason,
+    onStage,
   }: {
     userId: TableIdentity;
     address: {
@@ -332,6 +368,7 @@ export class ServiceOrder extends BeanBase {
     couponGrantId?: TableIdentity;
     preparedLines: IPreparedOrderLine[];
     reason: string;
+    onStage?: CheckoutStageCallback;
   }): Promise<IOrderSnapshotCreateResult> {
     const eligibleSubtotalCents = preparedLines.reduce((total, line) => {
       const nextTotal = total + line.eligibleSubtotalCents;
@@ -352,6 +389,7 @@ export class ServiceOrder extends BeanBase {
       payableTotalCents: eligibleSubtotalCents,
       reservationExpiresAt: new Date(Date.now() + 30 * 60 * 1000),
     });
+    await onStage?.('afterOrderSnapshot');
     if (couponGrantId) {
       const reservation = await this.$scope.commercePromotion.service.coupon.reserve({
         couponGrantId,
@@ -381,6 +419,7 @@ export class ServiceOrder extends BeanBase {
       order.couponSnapshot = couponSnapshot;
       order.discountCents = reservation.discountCents;
       order.payableTotalCents = eligibleSubtotalCents - reservation.discountCents;
+      await onStage?.('afterCouponReservation');
     }
     const lines: EntityOrderLine[] = [];
     for (const line of preparedLines) {
@@ -403,6 +442,7 @@ export class ServiceOrder extends BeanBase {
         correlationId: `${correlationId}:line:${line.index}`,
         reason,
       });
+      await onStage?.('afterStockReservation');
       lines.push(orderLine);
     }
     return { order, lines };

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

@@ -34,7 +34,7 @@ const serializationRetryOptions = {
   minTimeout: 0,
   maxTimeout: 0,
   randomize: false,
-  errorCodes: ['40001'],
+  errorCodes: ['40001', 'ER_LOCK_DEADLOCK', 'ER_LOCK_WAIT_TIMEOUT'],
   ownerOnly: true,
 };
 
@@ -49,6 +49,7 @@ export class ServiceStockBalance extends BeanBase {
   }
 
   @Core.transaction({ isolationLevel: 'SERIALIZABLE' })
+  @Core.retryable(serializationRetryOptions)
   async adjustStock(stockAdjust: DtoStockAdjust): Promise<EntityStockBalance> {
     const sku = await this.$scope.commerceCatalog.model.sku.getById(stockAdjust.skuId);
     if (!sku) {
@@ -65,7 +66,7 @@ export class ServiceStockBalance extends BeanBase {
     };
     if (!stockBalance) {
       if (stockAdjust.delta < 0) {
-        throw new Error('stock adjustment would make balance negative');
+        this.app.throw(409, 'stock adjustment would make balance negative');
       }
       stockBalance = await this.scope.model.stockBalance.insert({
         skuId: stockAdjust.skuId,
@@ -78,7 +79,7 @@ export class ServiceStockBalance extends BeanBase {
       const reserved = stockBalance.reserved;
       const available = onHand - reserved;
       if (onHand < 0 || reserved < 0 || available < 0) {
-        throw new Error('stock adjustment would make balance negative');
+        this.app.throw(409, 'stock adjustment would make balance negative');
       }
       await this.scope.model.stockBalance.updateById(stockBalance.id, {
         onHand,

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

@@ -3,11 +3,19 @@ import type { DtoCartAddItem, DtoCartUpdateItem } from 'vona-module-commerce-tra
 import { catchError } from '@cabloy/utils';
 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';
+
 const actionPath = '/commerce/trade/cart';
 
+interface ISellableSkuFixture {
+  categoryId: number;
+  productId: number;
+  skuId: number;
+}
+
 function createTestId() {
   return randomUUID().slice(0, 12);
 }
@@ -27,12 +35,12 @@ async function performAs(accessToken: string, method: string, path: string, opti
 }
 
 async function registerAndSignin(name: string) {
-  await app.bean.user.register({ name }, true);
+  const user = await app.bean.user.register({ name }, true);
   const token = await app.bean.passport.signinMock(name as any);
-  return { token: token.accessToken, user: app.bean.passport.currentUser! };
+  return { token: token.accessToken, user };
 }
 
-async function createSellableSku(suffix: string) {
+async function createSellableSku(suffix: string): Promise<ISellableSkuFixture> {
   await app.bean.passport.signinMock();
   try {
     const categoryId = await app.bean.executor.performAction('post', '/commerce/catalog/category', {
@@ -57,13 +65,47 @@ async function createSellableSku(suffix: string) {
         correlationId: `cart-stock-${suffix}`,
       },
     });
-    return skuId;
+    return { categoryId, productId, skuId };
   } finally {
     await app.bean.passport.signout();
   }
 }
 
+async function dropSellableSku(fixture: ISellableSkuFixture | undefined) {
+  if (!fixture) return;
+  const trade = app.scope('commerce-trade');
+  const catalog = app.scope('commerce-catalog');
+  await trade.model.stockAudit.delete({ skuId: fixture.skuId });
+  await trade.model.stockReservation.delete({ skuId: fixture.skuId });
+  await trade.model.stockBalance.delete({ skuId: fixture.skuId });
+  await catalog.model.sku.delete({ id: fixture.skuId });
+  await catalog.model.product.delete({ id: fixture.productId });
+  await catalog.model.category.delete({ id: fixture.categoryId });
+}
+
+async function dropUser(userId: number | undefined) {
+  if (userId === undefined) return;
+  const trade = app.scope('commerce-trade');
+  const carts = await trade.model.cart.select({ where: { userId } });
+  for (const cart of carts) {
+    await trade.model.cartItem.delete({ cartId: cart.id });
+    await trade.model.cart.delete({ id: cart.id });
+  }
+  await app.scope('home-user').model.roleUser.delete({ userId });
+  await app.bean.user.removeById(userId);
+}
+
 describe('cartOwnership.test.ts', { concurrency: false }, () => {
+  let releaseTestLock: (() => void) | undefined;
+
+  before(async () => {
+    releaseTestLock = await acquireTestLock();
+  });
+
+  after(() => {
+    releaseTestLock?.();
+  });
+
   it('denies anonymous cart actions', async () => {
     await app.bean.executor.mockCtx(async () => {
       for (const [method, path, options] of [
@@ -84,96 +126,134 @@ describe('cartOwnership.test.ts', { concurrency: false }, () => {
   it('derives cart ownership from the authenticated customer and scopes every item action', async () => {
     await app.bean.executor.mockCtx(async () => {
       const suffix = createTestId();
-      const skuId = await createSellableSku(suffix);
-      const customerA = await registerAndSignin(`cart-a-${suffix}`);
-      const customerB = await registerAndSignin(`cart-b-${suffix}`);
-
-      const cart = await performAs(customerA.token, 'post', `${actionPath}/items`, {
-        body: { ...cartItem(skuId, 2), userId: customerB.user.id, iid: 999999 } as any,
-      });
-      assert.equal(cart.items.length, 1);
-      assert.equal(cart.items[0].quantity, 2);
-      assert.equal(Object.hasOwn(cart, 'userId'), false);
-      assert.equal(Object.hasOwn(cart, 'iid'), false);
-      const itemId = cart.items[0].id;
-
-      const persistedCart = await app.scope('commerce-trade').model.cart.getById(cart.id);
-      assert.equal(String(persistedCart?.userId), String(customerA.user.id));
-      assert.equal(persistedCart?.iid, app.ctx.instance.id);
-      const persistedItem = await app.scope('commerce-trade').model.cartItem.getById(itemId);
-      assert.equal(String(persistedItem?.cartId), String(cart.id));
-
-      const updated = await performAs(customerA.token, 'patch', `${actionPath}/items/:id`, {
-        params: { id: itemId },
-        body: { quantity: 3 } satisfies DtoCartUpdateItem,
-      });
-      assert.equal(updated.items[0].quantity, 3);
-
-      assert.deepEqual(await performAs(customerB.token, 'get', actionPath), { items: [] });
-      assert.deepEqual(
-        await performAs(customerB.token, 'patch', `${actionPath}/items/:id`, {
-          params: { id: itemId },
-          body: { quantity: 1 },
-        }),
-        { items: [] },
-      );
-      assert.deepEqual(
-        await performAs(customerB.token, 'delete', `${actionPath}/items/:id`, {
-          params: { id: itemId },
-        }),
-        { items: [] },
-      );
-      assert.equal((await app.scope('commerce-trade').model.cartItem.getById(itemId))?.quantity, 3);
+      let sku: ISellableSkuFixture | undefined;
+      let customerA: Awaited<ReturnType<typeof registerAndSignin>> | undefined;
+      let customerB: Awaited<ReturnType<typeof registerAndSignin>> | undefined;
+      try {
+        sku = await createSellableSku(suffix);
+        customerA = await registerAndSignin(`cart-a-${suffix}`);
+        customerB = await registerAndSignin(`cart-b-${suffix}`);
 
-      const merged = await performAs(customerA.token, 'post', `${actionPath}/items`, {
-        body: cartItem(skuId, 2),
-      });
-      assert.equal(merged.items.length, 1);
-      assert.equal(merged.items[0].quantity, 5);
+        const cart = await performAs(customerA.token, 'post', `${actionPath}/items`, {
+          body: { ...cartItem(sku.skuId, 2), userId: customerB.user.id, iid: 999999 } as any,
+        });
+        assert.equal(cart.items.length, 1);
+        assert.equal(cart.items[0].quantity, 2);
+        assert.equal(Object.hasOwn(cart, 'userId'), false);
+        assert.equal(Object.hasOwn(cart, 'iid'), false);
+        const itemId = cart.items[0].id;
 
-      const cleared = await performAs(customerA.token, 'delete', `${actionPath}/items`);
-      assert.deepEqual(cleared.items, []);
-    });
-  });
+        const persistedCart = await app.scope('commerce-trade').model.cart.getById(cart.id);
+        assert.equal(String(persistedCart?.userId), String(customerA.user.id));
+        assert.equal(persistedCart?.iid, app.ctx.instance.id);
+        const persistedItem = await app.scope('commerce-trade').model.cartItem.getById(itemId);
+        assert.equal(String(persistedItem?.cartId), String(cart.id));
 
-  it('treats another instance cart as absent', async () => {
-    let itemId!: number;
-    let customerDefault!: Awaited<ReturnType<typeof registerAndSignin>>;
-    await app.bean.executor.mockCtx(async () => {
-      const suffix = createTestId();
-      const skuId = await createSellableSku(suffix);
-      customerDefault = await registerAndSignin(`cart-default-${suffix}`);
-      const cart = await performAs(customerDefault.token, 'post', `${actionPath}/items`, {
-        body: cartItem(skuId),
-      });
-      itemId = cart.items[0].id;
-    });
+        const updated = await performAs(customerA.token, 'patch', `${actionPath}/items/:id`, {
+          params: { id: itemId },
+          body: { quantity: 3 } satisfies DtoCartUpdateItem,
+        });
+        assert.equal(updated.items[0].quantity, 3);
 
-    await app.bean.executor.mockCtx(
-      async () => {
-        const customer = await registerAndSignin(`cart-share-${Date.now()}`);
-        assert.deepEqual(await performAs(customer.token, 'get', actionPath), { items: [] });
+        assert.deepEqual(await performAs(customerB.token, 'get', actionPath), { items: [] });
         assert.deepEqual(
-          await performAs(customer.token, 'patch', `${actionPath}/items/:id`, {
+          await performAs(customerB.token, 'patch', `${actionPath}/items/:id`, {
             params: { id: itemId },
-            body: { quantity: 2 },
+            body: { quantity: 1 },
           }),
           { items: [] },
         );
         assert.deepEqual(
-          await performAs(customer.token, 'delete', `${actionPath}/items/:id`, {
+          await performAs(customerB.token, 'delete', `${actionPath}/items/:id`, {
             params: { id: itemId },
           }),
           { items: [] },
         );
-      },
-      { instanceName: 'shareTest' as any },
-    );
+        assert.equal(
+          (await app.scope('commerce-trade').model.cartItem.getById(itemId))?.quantity,
+          3,
+        );
 
-    await app.bean.executor.mockCtx(async () => {
-      const cart = await performAs(customerDefault.token, 'get', actionPath);
-      assert.equal(cart.items.length, 1);
-      assert.equal(cart.items[0].id, itemId);
+        const merged = await performAs(customerA.token, 'post', `${actionPath}/items`, {
+          body: cartItem(sku.skuId, 2),
+        });
+        assert.equal(merged.items.length, 1);
+        assert.equal(merged.items[0].quantity, 5);
+
+        const cleared = await performAs(customerA.token, 'delete', `${actionPath}/items`);
+        assert.deepEqual(cleared.items, []);
+      } finally {
+        await app.bean.passport.signout();
+        await dropUser(customerB?.user.id as number | undefined);
+        await dropUser(customerA?.user.id as number | undefined);
+        await dropSellableSku(sku);
+      }
     });
   });
+
+  it('treats another instance cart as absent', async () => {
+    const suffix = createTestId();
+    let itemId!: number;
+    let customerDefault: Awaited<ReturnType<typeof registerAndSignin>> | undefined;
+    let customerShare: Awaited<ReturnType<typeof registerAndSignin>> | undefined;
+    let sku: ISellableSkuFixture | undefined;
+    try {
+      await app.bean.executor.mockCtx(async () => {
+        sku = await createSellableSku(suffix);
+        customerDefault = await registerAndSignin(`cart-default-${suffix}`);
+        const cart = await performAs(customerDefault.token, 'post', `${actionPath}/items`, {
+          body: cartItem(sku.skuId),
+        });
+        itemId = cart.items[0].id;
+      });
+
+      await app.bean.executor.mockCtx(
+        async () => {
+          try {
+            customerShare = await registerAndSignin(`cart-share-${suffix}`);
+            assert.deepEqual(await performAs(customerShare.token, 'get', actionPath), {
+              items: [],
+            });
+            assert.deepEqual(
+              await performAs(customerShare.token, 'patch', `${actionPath}/items/:id`, {
+                params: { id: itemId },
+                body: { quantity: 2 },
+              }),
+              { items: [] },
+            );
+            assert.deepEqual(
+              await performAs(customerShare.token, 'delete', `${actionPath}/items/:id`, {
+                params: { id: itemId },
+              }),
+              { items: [] },
+            );
+          } finally {
+            await app.bean.passport.signout();
+          }
+        },
+        { instanceName: 'shareTest' as any },
+      );
+
+      await app.bean.executor.mockCtx(async () => {
+        try {
+          const cart = await performAs(customerDefault!.token, 'get', actionPath);
+          assert.equal(cart.items.length, 1);
+          assert.equal(cart.items[0].id, itemId);
+        } finally {
+          await app.bean.passport.signout();
+        }
+      });
+    } finally {
+      await app.bean.executor.mockCtx(
+        async () => {
+          await dropUser(customerShare?.user.id as number | undefined);
+        },
+        { instanceName: 'shareTest' as any },
+      );
+      await app.bean.executor.mockCtx(async () => {
+        await dropUser(customerDefault?.user.id as number | undefined);
+        await dropSellableSku(sku);
+      });
+    }
+  });
 });