cabloy 5.1.112 → 5.1.113

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

@@ -5,32 +5,70 @@ import assert from 'node:assert';
 import { describe, it } from 'node:test';
 import { app } from 'vona-mock';
 
-async function createSku(suffix: string): Promise<number> {
-  const categoryId = await app.bean.executor.performAction('post', '/commerce/catalog/category', {
+interface IStockFixture {
+  categoryId: number;
+  productId: number;
+  skuId: number;
+}
+
+type IStockFixturePartial = Partial<IStockFixture>;
+
+async function createSku(suffix: string, fixtures: IStockFixturePartial[]): Promise<IStockFixture> {
+  const fixture: IStockFixturePartial = {};
+  fixtures.push(fixture);
+  fixture.categoryId = await app.bean.executor.performAction('post', '/commerce/catalog/category', {
     body: { name: `reservation-category-${suffix}`, published: true },
   });
-  const productId = await app.bean.executor.performAction('post', '/commerce/catalog/product', {
-    body: { categoryId, title: `reservation-product-${suffix}`, published: true },
+  fixture.productId = await app.bean.executor.performAction('post', '/commerce/catalog/product', {
+    body: {
+      categoryId: fixture.categoryId,
+      title: `reservation-product-${suffix}`,
+      published: true,
+    },
   });
-  return await app.bean.executor.performAction('post', '/commerce/catalog/sku', {
+  fixture.skuId = await app.bean.executor.performAction('post', '/commerce/catalog/sku', {
     body: {
-      productId,
+      productId: fixture.productId,
       code: `reservation-sku-${suffix}`,
       priceCents: 100,
       lifecycle: 'active',
     },
   });
+  return fixture as IStockFixture;
 }
 
-async function prepareStock(suffix: string, quantity = 3): Promise<number> {
-  const skuId = await createSku(suffix);
+async function prepareStock(
+  suffix: string,
+  fixtures: IStockFixturePartial[],
+  quantity = 3,
+): Promise<IStockFixture> {
+  const fixture = await createSku(suffix, fixtures);
   await app.scope('commerce-trade').service.stockBalance.adjustStock({
-    skuId,
+    skuId: fixture.skuId,
     delta: quantity,
     reason: 'reservation test setup',
     correlationId: `reservation-setup-${suffix}`,
   });
-  return skuId;
+  return fixture;
+}
+
+async function dropStockFixtures(fixtures: IStockFixturePartial[]) {
+  const scopeTrade = app.scope('commerce-trade');
+  const scopeCatalog = app.scope('commerce-catalog');
+  for (const fixture of fixtures.toReversed()) {
+    if (fixture.skuId !== undefined) {
+      await scopeTrade.model.stockAudit.delete({ skuId: fixture.skuId });
+      await scopeTrade.model.stockReservation.delete({ skuId: fixture.skuId });
+      await scopeTrade.model.stockBalance.delete({ skuId: fixture.skuId });
+      await scopeCatalog.model.sku.delete({ id: fixture.skuId });
+    }
+    if (fixture.productId !== undefined) {
+      await scopeCatalog.model.product.delete({ id: fixture.productId });
+    }
+    if (fixture.categoryId !== undefined) {
+      await scopeCatalog.model.category.delete({ id: fixture.categoryId });
+    }
+  }
 }
 
 async function reserve(
@@ -62,14 +100,15 @@ async function assertReservationRejected(skuId: number, suffix: string, expected
 describe('stockReservation.test.ts', () => {
   it('reserves and consumes stock exactly once with traceable audits', async () => {
     await app.bean.executor.mockCtx(async () => {
-      const suffix = `${Date.now()}`;
+      const fixtures: IStockFixturePartial[] = [];
       await app.bean.passport.signinMock();
       try {
-        const skuId = await prepareStock(suffix);
-        const reservation = await reserve(skuId, suffix);
+        const suffix = `${Date.now()}`;
+        const fixture = await prepareStock(suffix, fixtures);
+        const reservation = await reserve(fixture.skuId, suffix);
         const balanceAfterReserve = await app
           .scope('commerce-trade')
-          .model.stockBalance.get({ skuId });
+          .model.stockBalance.get({ skuId: fixture.skuId });
         assert.deepEqual(
           [
             balanceAfterReserve?.onHand,
@@ -79,7 +118,7 @@ describe('stockReservation.test.ts', () => {
           [3, 2, 1],
         );
 
-        const duplicate = await reserve(skuId, suffix);
+        const duplicate = await reserve(fixture.skuId, suffix);
         assert.equal(duplicate.id, reservation.id);
         const consumed = await app.scope('commerce-trade').service.stockBalance.consume({
           reservationId: reservation.id,
@@ -94,7 +133,7 @@ describe('stockReservation.test.ts', () => {
 
         const balanceAfterConsume = await app
           .scope('commerce-trade')
-          .model.stockBalance.get({ skuId });
+          .model.stockBalance.get({ skuId: fixture.skuId });
         assert.deepEqual(
           [
             balanceAfterConsume?.onHand,
@@ -103,15 +142,16 @@ describe('stockReservation.test.ts', () => {
           ],
           [1, 0, 1],
         );
-        const audits = await app
-          .scope('commerce-trade')
-          .model.stockAudit.select({ where: { skuId } });
+        const audits = await app.scope('commerce-trade').model.stockAudit.select({
+          where: { skuId: fixture.skuId },
+        });
         assert.deepEqual(
           audits.map(audit => audit.operation),
           ['adjust', 'reserve', 'consume'],
         );
         assert.equal(audits[1].stockReservationId, reservation.id);
       } finally {
+        await dropStockFixtures(fixtures);
         await app.bean.passport.signout();
       }
     });
@@ -119,36 +159,29 @@ describe('stockReservation.test.ts', () => {
 
   it('rejects reservations for inactive or unpublished catalog data without writes', async () => {
     await app.bean.executor.mockCtx(async () => {
-      const suffix = `${Date.now()}`;
+      const fixtures: IStockFixturePartial[] = [];
       await app.bean.passport.signinMock();
       try {
-        const inactiveSkuId = await prepareStock(`${suffix}-inactive`);
-        await app.scope('commerce-catalog').model.sku.updateById(inactiveSkuId, {
+        const suffix = `${Date.now()}`;
+        const inactiveSku = await prepareStock(`${suffix}-inactive`, fixtures);
+        await app.scope('commerce-catalog').model.sku.updateById(inactiveSku.skuId, {
           lifecycle: 'inactive',
         });
-        await assertReservationRejected(inactiveSkuId, `${suffix}-inactive`, 404);
+        await assertReservationRejected(inactiveSku.skuId, `${suffix}-inactive`, 404);
 
-        const unpublishedProductSkuId = await prepareStock(`${suffix}-product`);
-        const unpublishedProductSku = await app
-          .scope('commerce-catalog')
-          .model.sku.getById(unpublishedProductSkuId);
+        const unpublishedProductSku = await prepareStock(`${suffix}-product`, fixtures);
         await app
           .scope('commerce-catalog')
-          .model.product.updateById(unpublishedProductSku!.productId, { published: false });
-        await assertReservationRejected(unpublishedProductSkuId, `${suffix}-product`, 409);
+          .model.product.updateById(unpublishedProductSku.productId, { published: false });
+        await assertReservationRejected(unpublishedProductSku.skuId, `${suffix}-product`, 409);
 
-        const unpublishedCategorySkuId = await prepareStock(`${suffix}-category`);
-        const unpublishedCategorySku = await app
-          .scope('commerce-catalog')
-          .model.sku.getById(unpublishedCategorySkuId);
-        const unpublishedCategoryProduct = await app
-          .scope('commerce-catalog')
-          .model.product.getById(unpublishedCategorySku!.productId);
+        const unpublishedCategorySku = await prepareStock(`${suffix}-category`, fixtures);
         await app
           .scope('commerce-catalog')
-          .model.category.updateById(unpublishedCategoryProduct!.categoryId, { published: false });
-        await assertReservationRejected(unpublishedCategorySkuId, `${suffix}-category`, 409);
+          .model.category.updateById(unpublishedCategorySku.categoryId, { published: false });
+        await assertReservationRejected(unpublishedCategorySku.skuId, `${suffix}-category`, 409);
       } finally {
+        await dropStockFixtures(fixtures);
         await app.bean.passport.signout();
       }
     });
@@ -156,11 +189,12 @@ describe('stockReservation.test.ts', () => {
 
   it('releases and restores stock only from legal reservation states', async () => {
     await app.bean.executor.mockCtx(async () => {
-      const suffix = `${Date.now()}`;
+      const fixtures: IStockFixturePartial[] = [];
       await app.bean.passport.signinMock();
       try {
-        const skuId = await prepareStock(suffix);
-        const releasedReservation = await reserve(skuId, `${suffix}-release`);
+        const suffix = `${Date.now()}`;
+        const fixture = await prepareStock(suffix, fixtures);
+        const releasedReservation = await reserve(fixture.skuId, `${suffix}-release`);
         const released = await app.scope('commerce-trade').service.stockBalance.release({
           reservationId: releasedReservation.id,
           reason: 'payment failed',
@@ -172,7 +206,7 @@ describe('stockReservation.test.ts', () => {
         });
         assert.equal(duplicateRelease.state, 'released');
 
-        const consumedReservation = await reserve(skuId, `${suffix}-restore`, 1);
+        const consumedReservation = await reserve(fixture.skuId, `${suffix}-restore`, 1);
         await app.scope('commerce-trade').service.stockBalance.consume({
           reservationId: consumedReservation.id,
           reason: 'payment success',
@@ -182,6 +216,11 @@ describe('stockReservation.test.ts', () => {
           reason: 'refund success',
         });
         assert.equal(restored.state, 'restored');
+        const duplicateRestore = await app.scope('commerce-trade').service.stockBalance.restore({
+          reservationId: consumedReservation.id,
+          reason: 'refund success retry',
+        });
+        assert.equal(duplicateRestore.state, 'restored');
 
         const [_, err] = await catchError(() =>
           app.scope('commerce-trade').service.stockBalance.consume({
@@ -190,71 +229,227 @@ describe('stockReservation.test.ts', () => {
           }),
         );
         assert.equal(err?.code, 409);
-        const balance = await app.scope('commerce-trade').model.stockBalance.get({ skuId });
+        const balance = await app
+          .scope('commerce-trade')
+          .model.stockBalance.get({ skuId: fixture.skuId });
         assert.deepEqual([balance?.onHand, balance?.reserved, balance?.available], [3, 0, 3]);
+        const audits = await app.scope('commerce-trade').model.stockAudit.select({
+          where: { skuId: fixture.skuId },
+        });
+        assert.equal(audits.length, 6);
+        assert.deepEqual(
+          audits.map(audit => audit.operation),
+          ['adjust', 'reserve', 'release', 'reserve', 'consume', 'restore'],
+        );
+        assert.deepEqual(
+          audits.map(audit => audit.stockBalanceId),
+          audits.map(() => balance?.id),
+        );
+        assert.deepEqual(
+          audits.map(audit => audit.stockReservationId),
+          [
+            null,
+            releasedReservation.id,
+            releasedReservation.id,
+            consumedReservation.id,
+            consumedReservation.id,
+            consumedReservation.id,
+          ],
+        );
+        assert.deepEqual(
+          audits.map(audit => audit.correlationId),
+          [
+            `reservation-setup-${suffix}`,
+            `reservation-${suffix}-release`,
+            `reservation-${suffix}-release`,
+            `reservation-${suffix}-restore`,
+            `reservation-${suffix}-restore`,
+            `reservation-${suffix}-restore`,
+          ],
+        );
+        assert.deepEqual(
+          audits.map(audit => audit.reason),
+          [
+            'reservation test setup',
+            'reservation test',
+            'payment failed',
+            'reservation test',
+            'payment success',
+            'refund success',
+          ],
+        );
+        assert.deepEqual(
+          audits.map(audit => [
+            audit.delta,
+            audit.priorOnHand,
+            audit.priorReserved,
+            audit.priorAvailable,
+            audit.onHand,
+            audit.reserved,
+            audit.available,
+          ]),
+          [
+            [3, 0, 0, 0, 3, 0, 3],
+            [-2, 3, 0, 3, 3, 2, 1],
+            [0, 3, 2, 1, 3, 0, 3],
+            [-1, 3, 0, 3, 3, 1, 2],
+            [-1, 3, 1, 2, 2, 0, 2],
+            [1, 2, 0, 2, 3, 0, 3],
+          ],
+        );
       } finally {
+        await dropStockFixtures(fixtures);
         await app.bean.passport.signout();
       }
     });
   });
 
-  it('allows exactly one competing reservation for the final unit', async () => {
-    await app.bean.executor.mockCtx(async () => {
-      const suffix = `${Date.now()}`;
-      await app.bean.passport.signinMock();
-      try {
-        const skuId = await prepareStock(suffix, 1);
-        const results = await Promise.allSettled([
-          reserve(skuId, `${suffix}-first`, 1),
-          reserve(skuId, `${suffix}-second`, 1),
-        ]);
-        assert.equal(results.filter(result => result.status === 'fulfilled').length, 1);
-        assert.equal(results.filter(result => result.status === 'rejected').length, 1);
+  it('allows exactly one independent reservation for the final unit', async t => {
+    if (process.env.DATABASE_DEFAULT_CLIENT !== 'pg') {
+      t.skip('requires PostgreSQL row-lock contention');
+      return;
+    }
+    const fixtures: IStockFixturePartial[] = [];
+    const suffix = `${Date.now()}`;
+    let fixture!: IStockFixture;
+    try {
+      await app.bean.executor.mockCtx(async () => {
+        await app.bean.passport.signinMock();
+        try {
+          fixture = await prepareStock(suffix, fixtures, 1);
+        } finally {
+          await app.bean.passport.signout();
+        }
+      });
+
+      const reserveInContext = async (correlationSuffix: string) => {
+        return await app.bean.executor.mockCtx(async () => {
+          await app.bean.passport.signinMock();
+          try {
+            return await reserve(fixture.skuId, correlationSuffix, 1);
+          } finally {
+            await app.bean.passport.signout();
+          }
+        });
+      };
+      const results = await Promise.allSettled([
+        reserveInContext(`${suffix}-first`),
+        reserveInContext(`${suffix}-second`),
+      ]);
+      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 balance = await app.scope('commerce-trade').model.stockBalance.get({ skuId });
+      await app.bean.executor.mockCtx(async () => {
+        const balance = await app
+          .scope('commerce-trade')
+          .model.stockBalance.get({ skuId: fixture.skuId });
         assert.deepEqual([balance?.onHand, balance?.reserved, balance?.available], [1, 1, 0]);
         const reservations = await app.scope('commerce-trade').model.stockReservation.select({
-          where: { skuId },
+          where: { skuId: fixture.skuId },
+        });
+        const audits = await app.scope('commerce-trade').model.stockAudit.select({
+          where: { skuId: fixture.skuId },
         });
-        const audits = await app
-          .scope('commerce-trade')
-          .model.stockAudit.select({ where: { skuId } });
         assert.equal(reservations.length, 1);
         assert.deepEqual(
           audits.map(audit => audit.operation),
           ['adjust', 'reserve'],
         );
-      } finally {
-        await app.bean.passport.signout();
-      }
-    });
+        assert.equal(audits.filter(audit => audit.operation === 'reserve').length, 1);
+        assert.equal(
+          audits.some(audit => audit.correlationId === `reservation-${suffix}-first`) ||
+            audits.some(audit => audit.correlationId === `reservation-${suffix}-second`),
+          true,
+        );
+      });
+    } finally {
+      await app.bean.executor.mockCtx(async () => {
+        await dropStockFixtures(fixtures);
+      });
+    }
   });
 
-  it('rolls back reservation and balance when audit persistence fails', async () => {
+  it('rolls back reservation, balance, and audit writes in one transaction', async () => {
     await app.bean.executor.mockCtx(async () => {
-      const suffix = `${Date.now()}`;
+      const fixtures: IStockFixturePartial[] = [];
       await app.bean.passport.signinMock();
       try {
-        const skuId = await prepareStock(suffix);
-        const modelStockAudit = app.scope('commerce-trade').model.stockAudit;
-        const insert = modelStockAudit.insert.bind(modelStockAudit);
-        (modelStockAudit as any).insert = async () => {
-          throw new Error('reservation audit insert failure');
-        };
-        try {
-          const [_, err] = await catchError(() => reserve(skuId, suffix));
-          assert.match(err?.message ?? '', /reservation audit insert failure/);
-        } finally {
-          (modelStockAudit as any).insert = insert;
-        }
+        const suffix = `${Date.now()}`;
+        const fixture = await prepareStock(suffix, fixtures);
+        const balance = await app.scope('commerce-trade').model.stockBalance.get({
+          skuId: fixture.skuId,
+        });
+        const db = app.ctx.db;
+        const [_, err] = await catchError(async () => {
+          await db.transaction.begin(async () => {
+            const modelStockBalance = app
+              .scope('commerce-trade')
+              .model.stockBalance.newInstance(db);
+            const modelStockReservation = app
+              .scope('commerce-trade')
+              .model.stockReservation.newInstance(db);
+            const modelStockAudit = app.scope('commerce-trade').model.stockAudit.newInstance(db);
+            const reservation = await modelStockReservation.insert({
+              stockBalanceId: balance!.id,
+              skuId: fixture.skuId,
+              quantity: 2,
+              state: 'reserved',
+              correlationId: `reservation-${suffix}-rollback`,
+            });
+            await modelStockBalance.updateById(balance!.id, {
+              onHand: 3,
+              reserved: 2,
+              available: 1,
+            });
+            await modelStockAudit.insert({
+              stockBalanceId: balance!.id,
+              skuId: fixture.skuId,
+              stockReservationId: reservation.id,
+              actorId: app.bean.passport.currentUser!.id,
+              operation: 'reserve',
+              delta: -2,
+              reason: 'transaction rollback proof',
+              correlationId: reservation.correlationId,
+              priorOnHand: 3,
+              priorReserved: 0,
+              priorAvailable: 3,
+              onHand: 3,
+              reserved: 2,
+              available: 1,
+            });
+            throw new Error('transaction rollback proof');
+          });
+        });
+        assert.match(err?.message ?? '', /transaction rollback proof/);
 
-        const balance = await app.scope('commerce-trade').model.stockBalance.get({ skuId });
-        assert.deepEqual([balance?.onHand, balance?.reserved, balance?.available], [3, 0, 3]);
+        const unchanged = await app
+          .scope('commerce-trade')
+          .model.stockBalance.get({ skuId: fixture.skuId });
+        assert.deepEqual([unchanged?.onHand, unchanged?.reserved, unchanged?.available], [3, 0, 3]);
         assert.equal(
-          await app.scope('commerce-trade').model.stockReservation.get({ skuId }),
+          await app.scope('commerce-trade').model.stockReservation.get({ skuId: fixture.skuId }),
           undefined,
         );
+        const audits = await app.scope('commerce-trade').model.stockAudit.select({
+          where: { skuId: fixture.skuId },
+        });
+        assert.equal(audits.length, 1);
       } finally {
+        await dropStockFixtures(fixtures);
         await app.bean.passport.signout();
       }
     });

package/vona/src/suite-vendor/a-vona/modules/a-startup/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-startup",
-  "version": "5.1.14",
+  "version": "5.1.15",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "keywords": [

package/vona/src/suite-vendor/a-vona/modules/a-startup/src/service/startup.ts

@@ -52,12 +52,12 @@ export class ServiceStartup extends BeanBase {
       }
     }
 
-    // version test
+    // version seed
     if (this.app.meta.isTest) {
       const instanceName = '';
       await this.bean.executor.newCtx(
         async () => {
-          await this.$scope.version.service.version.__instanceTest(instanceName);
+          await this.$scope.version.service.version.__instanceSeed(instanceName);
         },
         {
           dbInfo: { level: 1 },

package/vona/src/suite-vendor/a-vona/modules/a-version/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-version",
-  "version": "5.1.14",
+  "version": "5.1.15",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "vona-module-a-version",
   "keywords": [

package/vona/src/suite-vendor/a-vona/modules/a-version/src/service/version.ts

@@ -12,7 +12,7 @@ import type {
   IMetaVersionInit,
   IMetaVersionOptions,
   IMetaVersionOptionsInner,
-  IMetaVersionTest,
+  IMetaVersionSeed,
   IMetaVersionUpdate,
 } from '../types/version.ts';
 
@@ -61,11 +61,11 @@ export class ServiceVersion extends BeanBase {
     }
   }
 
-  async __instanceTest(instanceName: keyof IInstanceRecord) {
-    await this.__check({ scene: 'test', instanceName });
+  async __instanceSeed(instanceName: keyof IInstanceRecord) {
+    await this.__check({ scene: 'seed', instanceName });
   }
 
-  // scene: null/init/test
+  // scene: update/init/seed
   async __check(options: IMetaVersionOptionsInner) {
     options.result = {};
 
@@ -158,11 +158,11 @@ export class ServiceVersion extends BeanBase {
       }
     }
 
-    if (options.scene === 'test') {
-      // test module
+    if (options.scene === 'seed') {
+      // seed module
       await this.bean.executor.newCtx(
         async () => {
-          await this.__testModuleTransaction(module, fileVersionNew, options);
+          await this.__seedModuleTransaction(module, fileVersionNew, options);
         },
         {
           instanceName: options.instanceName,
@@ -260,13 +260,13 @@ export class ServiceVersion extends BeanBase {
     }
   }
 
-  // test module
-  async __testModuleTransaction(module, version, options) {
+  // seed module
+  async __seedModuleTransaction(module, version, options) {
     // bean
-    const beanVersion = this.__getBeanVersion<IMetaVersionTest>(module.info.relativeName, false);
+    const beanVersion = this.__getBeanVersion<IMetaVersionSeed>(module.info.relativeName, false);
     // execute
-    if (beanVersion && beanVersion.test) {
-      await beanVersion.test({ ...options, version });
+    if (beanVersion && beanVersion.seed) {
+      await beanVersion.seed({ ...options, version });
     }
   }
 

package/vona/src/suite-vendor/a-vona/modules/a-version/src/types/version.ts

@@ -2,7 +2,7 @@ import type { IInstanceRecord } from 'vona';
 import type { ConfigInstanceBase } from 'vona-module-a-instance';
 
 export interface IMetaVersionOptions {
-  scene: 'update' | 'init' | 'test';
+  scene: 'update' | 'init' | 'seed';
   instanceName?: keyof IInstanceRecord;
 }
 
@@ -19,7 +19,7 @@ export interface IMetaVersionInitOptions extends ConfigInstanceBase {
   version: number;
 }
 
-export interface IMetaVersionTestOptions {
+export interface IMetaVersionSeedOptions {
   version: number;
   instanceName: string;
 }
@@ -32,8 +32,8 @@ export interface IMetaVersionInit {
   init: (options: IMetaVersionInitOptions) => Promise<void>;
 }
 
-export interface IMetaVersionTest {
-  test: (options: IMetaVersionTestOptions) => Promise<void>;
+export interface IMetaVersionSeed {
+  seed: (options: IMetaVersionSeedOptions) => Promise<void>;
 }
 
 declare module 'vona' {

package/vona/src/suite-vendor/a-vona/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-suite-a-vona",
-  "version": "5.1.70",
+  "version": "5.1.71",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "author": "",