cabloy 5.1.112 → 5.1.113

package/vona/src/suite/a-commerce/modules/commerce-trade/src/entity/stockAudit.tsx

@@ -48,31 +48,63 @@ export class EntityStockAudit extends EntityBase {
   )
   stockReservationId?: TableIdentity;
 
+  @Api.field(v.title($locale('ActorId')), v.optional(), v.tableIdentity(), ZovaRender.order(4))
+  actorId?: TableIdentity;
+
   @Api.field(
     v.title($locale('StockOperation')),
     v.required(),
     z.enum(['adjust', 'reserve', 'consume', 'release', 'restore']),
-    ZovaRender.order(4),
+    ZovaRender.order(5),
   )
   operation: 'adjust' | 'reserve' | 'consume' | 'release' | 'restore';
 
-  @Api.field(v.title($locale('Delta')), v.required(), z.int(), ZovaRender.order(5))
+  @Api.field(v.title($locale('Delta')), v.required(), z.int(), ZovaRender.order(6))
   delta: number;
 
-  @Api.field(v.title($locale('Reason')), v.required(), v.min(1), ZovaRender.order(6))
+  @Api.field(v.title($locale('Reason')), v.required(), v.min(1), ZovaRender.order(7))
   reason: string;
 
-  @Api.field(v.title($locale('CorrelationId')), v.required(), v.min(1), ZovaRender.order(7))
+  @Api.field(v.title($locale('CorrelationId')), v.required(), v.min(1), ZovaRender.order(8))
   correlationId: string;
 
-  @Api.field(v.title($locale('OnHand')), v.required(), z.number().int().min(0), ZovaRender.order(8))
+  @Api.field(
+    v.title($locale('PriorOnHand')),
+    v.required(),
+    z.number().int().min(0),
+    ZovaRender.order(9),
+  )
+  priorOnHand: number;
+
+  @Api.field(
+    v.title($locale('PriorReserved')),
+    v.required(),
+    z.number().int().min(0),
+    ZovaRender.order(10),
+  )
+  priorReserved: number;
+
+  @Api.field(
+    v.title($locale('PriorAvailable')),
+    v.required(),
+    z.number().int().min(0),
+    ZovaRender.order(11),
+  )
+  priorAvailable: number;
+
+  @Api.field(
+    v.title($locale('OnHand')),
+    v.required(),
+    z.number().int().min(0),
+    ZovaRender.order(12),
+  )
   onHand: number;
 
   @Api.field(
     v.title($locale('Reserved')),
     v.required(),
     z.number().int().min(0),
-    ZovaRender.order(9),
+    ZovaRender.order(13),
   )
   reserved: number;
 
@@ -80,7 +112,7 @@ export class EntityStockAudit extends EntityBase {
     v.title($locale('Available')),
     v.required(),
     z.number().int().min(0),
-    ZovaRender.order(10),
+    ZovaRender.order(14),
   )
   available: number;
 }

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

@@ -47,6 +47,11 @@ export class ServiceStockBalance extends BeanBase {
     let stockBalance = await this.scope.model.stockBalance.getForUpdate({
       skuId: stockAdjust.skuId,
     });
+    const priorBalance = stockBalance ?? {
+      onHand: 0,
+      reserved: 0,
+      available: 0,
+    };
     if (!stockBalance) {
       if (stockAdjust.delta < 0) {
         throw new Error('stock adjustment would make balance negative');
@@ -79,6 +84,7 @@ export class ServiceStockBalance extends BeanBase {
 
     await this._appendAudit({
       stockBalance,
+      priorBalance,
       delta: stockAdjust.delta,
       operation: 'adjust',
       reason: stockAdjust.reason,
@@ -87,8 +93,23 @@ export class ServiceStockBalance extends BeanBase {
     return stockBalance;
   }
 
-  @Core.transaction({ isolationLevel: 'SERIALIZABLE' })
   async reserve(command: IStockReservationCommand): Promise<EntityStockReservation> {
+    const transaction = this.bean.database.current.transaction;
+    if (transaction.inTransaction) {
+      return await this._reserve(command);
+    }
+    for (let attempt = 0; ; attempt++) {
+      try {
+        return await transaction.begin(() => this._reserve(command), {
+          isolationLevel: 'SERIALIZABLE',
+        });
+      } catch (error) {
+        if (!this._isSerializationFailure(error) || attempt >= 1) throw error;
+      }
+    }
+  }
+
+  private async _reserve(command: IStockReservationCommand): Promise<EntityStockReservation> {
     this._assertReservationCommand(command);
     const sku = await this.$scope.commerceCatalog.model.sku.getById(command.skuId, {
       include: {
@@ -133,12 +154,14 @@ export class ServiceStockBalance extends BeanBase {
       state: 'reserved',
       correlationId: command.correlationId,
     });
+    const priorBalance = stockBalance;
     const updatedBalance = await this._updateBalance(stockBalance, {
       onHand: stockBalance.onHand,
       reserved: stockBalance.reserved + command.quantity,
     });
     await this._appendAudit({
       stockBalance: updatedBalance,
+      priorBalance,
       stockReservationId: reservation.id,
       delta: -command.quantity,
       operation: 'reserve',
@@ -218,6 +241,7 @@ export class ServiceStockBalance extends BeanBase {
     if (!stockBalance) {
       this.app.throw(404, 'stock balance not found');
     }
+    const priorBalance = stockBalance;
     const updatedBalance = await this._updateBalance(
       stockBalance,
       calculateBalance(stockBalance, reservation),
@@ -228,6 +252,7 @@ export class ServiceStockBalance extends BeanBase {
       targetState === 'consumed' ? 'consume' : targetState === 'released' ? 'release' : 'restore';
     await this._appendAudit({
       stockBalance: updatedBalance,
+      priorBalance,
       stockReservationId: reservation.id,
       delta:
         operation === 'consume'
@@ -264,6 +289,7 @@ export class ServiceStockBalance extends BeanBase {
 
   private async _appendAudit({
     stockBalance,
+    priorBalance,
     stockReservationId,
     delta,
     operation,
@@ -271,6 +297,7 @@ export class ServiceStockBalance extends BeanBase {
     correlationId,
   }: {
     stockBalance: EntityStockBalance;
+    priorBalance: Pick<EntityStockBalance, 'onHand' | 'reserved' | 'available'>;
     stockReservationId?: TableIdentity;
     delta: number;
     operation: 'adjust' | 'reserve' | 'consume' | 'release' | 'restore';
@@ -281,16 +308,26 @@ export class ServiceStockBalance extends BeanBase {
       stockBalanceId: stockBalance.id,
       skuId: stockBalance.skuId,
       stockReservationId,
+      actorId: this.bean.passport.currentUser?.anonymous
+        ? undefined
+        : this.bean.passport.currentUser?.id,
       operation,
       delta,
       reason,
       correlationId,
+      priorOnHand: priorBalance.onHand,
+      priorReserved: priorBalance.reserved,
+      priorAvailable: priorBalance.available,
       onHand: stockBalance.onHand,
       reserved: stockBalance.reserved,
       available: stockBalance.available,
     });
   }
 
+  private _isSerializationFailure(error: unknown) {
+    return (error as { code?: unknown })?.code === '40001';
+  }
+
   private _assertReservationCommand(command: IStockReservationCommand) {
     if (!Number.isInteger(command.quantity) || command.quantity <= 0) {
       this.app.throw(400, 'stock reservation quantity must be a positive integer');

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

@@ -7,6 +7,14 @@ import { app } from 'vona-mock';
 
 const actionPath = '/commerce/trade/stockBalance/adjustStock';
 
+interface IStockFixture {
+  categoryId: number;
+  productId: number;
+  skuId: number;
+}
+
+type IStockFixturePartial = Partial<IStockFixture>;
+
 function stockAdjust(skuId: number, delta: number, suffix: string): DtoStockAdjust {
   return {
     skuId,
@@ -16,21 +24,50 @@ function stockAdjust(skuId: number, delta: number, suffix: string): DtoStockAdju
   };
 }
 
-async function createSku(suffix: string): Promise<number> {
-  const categoryId = await app.bean.executor.performAction('post', '/commerce/catalog/category', {
-    body: { name: `stock-category-${suffix}`, published: true },
-  });
-  const productId = await app.bean.executor.performAction('post', '/commerce/catalog/product', {
-    body: { categoryId, title: `stock-product-${suffix}`, published: true },
-  });
-  return await app.bean.executor.performAction('post', '/commerce/catalog/sku', {
-    body: {
-      productId,
-      code: `stock-sku-${suffix}`,
-      priceCents: 100,
-      lifecycle: 'active',
-    },
-  });
+async function createSku(suffix: string): Promise<IStockFixture> {
+  const fixture: IStockFixturePartial = {};
+  try {
+    fixture.categoryId = await app.bean.executor.performAction(
+      'post',
+      '/commerce/catalog/category',
+      {
+        body: { name: `stock-category-${suffix}`, published: true },
+      },
+    );
+    fixture.productId = await app.bean.executor.performAction('post', '/commerce/catalog/product', {
+      body: { categoryId: fixture.categoryId, title: `stock-product-${suffix}`, published: true },
+    });
+    fixture.skuId = await app.bean.executor.performAction('post', '/commerce/catalog/sku', {
+      body: {
+        productId: fixture.productId,
+        code: `stock-sku-${suffix}`,
+        priceCents: 100,
+        lifecycle: 'active',
+      },
+    });
+    return fixture as IStockFixture;
+  } catch (error) {
+    await dropStockFixture(fixture);
+    throw error;
+  }
+}
+
+async function dropStockFixture(fixture: IStockFixturePartial | undefined) {
+  if (!fixture) return;
+  const scopeTrade = app.scope('commerce-trade');
+  const scopeCatalog = app.scope('commerce-catalog');
+  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 adjustStock(stockAdjust: DtoStockAdjust): Promise<EntityStockBalance> {
@@ -40,33 +77,48 @@ async function adjustStock(stockAdjust: DtoStockAdjust): Promise<EntityStockBala
 describe('stockBalance.test.ts', () => {
   it('action:stockBalance:adjustStock appends an audit with server-scoped balance', async () => {
     await app.bean.executor.mockCtx(async () => {
+      let fixture: IStockFixture | undefined;
       await app.bean.passport.signinMock();
       try {
-        const skuId = await createSku(`${Date.now()}`);
-        const balance = await adjustStock(stockAdjust(skuId, 8, `${skuId}-initial`));
+        fixture = await createSku(`${Date.now()}`);
+        const balance = await adjustStock(
+          stockAdjust(fixture.skuId, 8, `${fixture.skuId}-initial`),
+        );
         assert.equal(balance.onHand, 8);
         assert.equal(balance.reserved, 0);
         assert.equal(balance.available, 8);
 
-        const adjusted = await adjustStock(stockAdjust(skuId, -3, `${skuId}-decrement`));
+        const adjusted = await adjustStock(
+          stockAdjust(fixture.skuId, -3, `${fixture.skuId}-decrement`),
+        );
         assert.equal(adjusted.id, balance.id);
         assert.equal(adjusted.onHand, 5);
         assert.equal(adjusted.reserved, 0);
         assert.equal(adjusted.available, 5);
 
         const audits = await app.scope('commerce-trade').model.stockAudit.select({
-          where: { skuId },
+          where: { skuId: fixture.skuId },
         });
         assert.equal(audits.length, 2);
         assert.deepEqual(
-          audits.map(item => [item.delta, item.onHand, item.reserved, item.available]),
+          audits.map(item => [
+            item.delta,
+            item.priorOnHand,
+            item.priorReserved,
+            item.priorAvailable,
+            item.onHand,
+            item.reserved,
+            item.available,
+          ]),
           [
-            [8, 8, 0, 8],
-            [-3, 5, 0, 5],
+            [8, 0, 0, 0, 8, 0, 8],
+            [-3, 8, 0, 8, 5, 0, 5],
           ],
         );
+        assert.equal(String(audits[0].actorId), String(app.bean.passport.currentUser!.id));
         assert.equal(audits[1].stockBalanceId, balance.id);
       } finally {
+        await dropStockFixture(fixture);
         await app.bean.passport.signout();
       }
     });
@@ -74,12 +126,15 @@ describe('stockBalance.test.ts', () => {
 
   it('action:stockBalance:adjustStock rejects negative stock without an audit', async () => {
     await app.bean.executor.mockCtx(async () => {
+      let fixture: IStockFixture | undefined;
       await app.bean.passport.signinMock();
       try {
-        const skuId = await createSku(`${Date.now()}`);
-        const balance = await adjustStock(stockAdjust(skuId, 2, `${skuId}-initial`));
+        fixture = await createSku(`${Date.now()}`);
+        const balance = await adjustStock(
+          stockAdjust(fixture.skuId, 2, `${fixture.skuId}-initial`),
+        );
         const [_, err] = await catchError(() =>
-          adjustStock(stockAdjust(skuId, -3, `${skuId}-reject`)),
+          adjustStock(stockAdjust(fixture.skuId, -3, `${fixture.skuId}-reject`)),
         );
         assert.match(err?.message ?? '', /negative/);
 
@@ -87,39 +142,66 @@ describe('stockBalance.test.ts', () => {
         assert.equal(unchanged?.onHand, 2);
         assert.equal(unchanged?.available, 2);
         const audits = await app.scope('commerce-trade').model.stockAudit.select({
-          where: { skuId },
+          where: { skuId: fixture.skuId },
         });
         assert.equal(audits.length, 1);
       } finally {
+        await dropStockFixture(fixture);
         await app.bean.passport.signout();
       }
     });
   });
 
-  it('action:stockBalance:adjustStock rolls back the balance when audit insertion fails', async () => {
+  it('rolls back balance and audit writes in one transaction', async () => {
     await app.bean.executor.mockCtx(async () => {
+      let fixture: IStockFixture | undefined;
       await app.bean.passport.signinMock();
       try {
-        const skuId = await createSku(`${Date.now()}`);
-        const balance = await adjustStock(stockAdjust(skuId, 4, `${skuId}-initial`));
-        const modelStockAudit = app.scope('commerce-trade').model.stockAudit;
-        const insert = modelStockAudit.insert.bind(modelStockAudit);
-        (modelStockAudit as any).insert = async () => {
-          throw new Error('audit insert failure');
-        };
-        try {
-          const [_, err] = await catchError(() =>
-            adjustStock(stockAdjust(skuId, 1, `${skuId}-rollback`)),
-          );
-          assert.match(err?.message ?? '', /audit insert failure/);
-        } finally {
-          (modelStockAudit as any).insert = insert;
-        }
+        fixture = await createSku(`${Date.now()}`);
+        const balance = await adjustStock(
+          stockAdjust(fixture.skuId, 4, `${fixture.skuId}-initial`),
+        );
+        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 modelStockAudit = app.scope('commerce-trade').model.stockAudit.newInstance(db);
+            await modelStockBalance.updateById(balance.id, {
+              onHand: 5,
+              reserved: 0,
+              available: 5,
+            });
+            await modelStockAudit.insert({
+              stockBalanceId: balance.id,
+              skuId: fixture!.skuId,
+              actorId: app.bean.passport.currentUser!.id,
+              operation: 'adjust',
+              delta: 1,
+              reason: 'transaction rollback proof',
+              correlationId: `stock-test-${fixture!.skuId}-rollback`,
+              priorOnHand: 4,
+              priorReserved: 0,
+              priorAvailable: 4,
+              onHand: 5,
+              reserved: 0,
+              available: 5,
+            });
+            throw new Error('transaction rollback proof');
+          });
+        });
+        assert.match(err?.message ?? '', /transaction rollback proof/);
 
         const unchanged = await app.scope('commerce-trade').model.stockBalance.getById(balance.id);
         assert.equal(unchanged?.onHand, 4);
         assert.equal(unchanged?.available, 4);
+        const audits = await app.scope('commerce-trade').model.stockAudit.select({
+          where: { skuId: fixture.skuId },
+        });
+        assert.equal(audits.length, 1);
       } finally {
+        await dropStockFixture(fixture);
         await app.bean.passport.signout();
       }
     });
@@ -149,38 +231,159 @@ describe('stockBalance.test.ts', () => {
   });
 
   it('action:stockBalance:adjustStock treats a cross-instance SKU as not found', async () => {
-    let skuId!: number;
-    await app.bean.executor.mockCtx(async () => {
-      await app.bean.passport.signinMock();
-      try {
-        skuId = await createSku(`${Date.now()}`);
-        await adjustStock(stockAdjust(skuId, 5, `${skuId}-default`));
-      } finally {
-        await app.bean.passport.signout();
-      }
-    });
+    let fixture: IStockFixture | undefined;
+    try {
+      await app.bean.executor.mockCtx(async () => {
+        await app.bean.passport.signinMock();
+        try {
+          fixture = await createSku(`${Date.now()}`);
+          await adjustStock(stockAdjust(fixture.skuId, 5, `${fixture.skuId}-default`));
+        } finally {
+          await app.bean.passport.signout();
+        }
+      });
 
-    await app.bean.executor.mockCtx(
-      async () => {
+      await app.bean.executor.mockCtx(
+        async () => {
+          await app.bean.passport.signinMock();
+          try {
+            const [_, err] = await catchError(() =>
+              adjustStock(stockAdjust(fixture!.skuId, 1, `${fixture!.skuId}-share`)),
+            );
+            assert.equal(err?.code, 404);
+            assert.equal(
+              await app.scope('commerce-trade').model.stockBalance.get({ skuId: fixture!.skuId }),
+              undefined,
+            );
+            assert.deepEqual(
+              await app.scope('commerce-trade').model.stockAudit.select({
+                where: { skuId: fixture!.skuId },
+              }),
+              [],
+            );
+          } finally {
+            await app.bean.passport.signout();
+          }
+        },
+        { instanceName: 'shareTest' as any },
+      );
+    } finally {
+      await app.bean.executor.mockCtx(async () => {
+        await dropStockFixture(fixture);
+      });
+    }
+  });
+
+  it('hides foreign stock balances and audits from operator read APIs', async () => {
+    const suffix = `${Date.now()}`;
+    let fixture: IStockFixture | undefined;
+    let balanceId!: number;
+    let auditId!: number;
+    const reason = `stock read isolation ${suffix}`;
+    const correlationId = `stock-read-isolation-${suffix}`;
+    try {
+      await app.bean.executor.mockCtx(async () => {
+        await app.bean.passport.signinMock();
+        try {
+          fixture = await createSku(suffix);
+          const balance = await adjustStock({
+            skuId: fixture.skuId,
+            delta: 5,
+            reason,
+            correlationId,
+          });
+          balanceId = balance.id;
+          const audits = await app.scope('commerce-trade').model.stockAudit.select({
+            where: { skuId: fixture.skuId },
+          });
+          assert.equal(audits.length, 1);
+          auditId = audits[0].id;
+        } finally {
+          await app.bean.passport.signout();
+        }
+      });
+
+      await app.bean.executor.mockCtx(
+        async () => {
+          await app.bean.passport.signinMock();
+          try {
+            assert.equal(
+              await app.bean.executor.performAction('get', '/commerce/trade/stockBalance/:id', {
+                params: { id: balanceId },
+              }),
+              undefined,
+            );
+            const balances = await app.bean.executor.performAction(
+              'get',
+              '/commerce/trade/stockBalance',
+            );
+            assert.equal(
+              balances.list.some(
+                (balance: { id: unknown }) => String(balance.id) === String(balanceId),
+              ),
+              false,
+            );
+            assert.equal(
+              await app.bean.executor.performAction('get', '/commerce/trade/stockAudit/:id', {
+                params: { id: auditId },
+              }),
+              undefined,
+            );
+            const audits = await app.bean.executor.performAction(
+              'get',
+              '/commerce/trade/stockAudit',
+            );
+            assert.equal(
+              audits.list.some((audit: { id: unknown }) => String(audit.id) === String(auditId)),
+              false,
+            );
+          } finally {
+            await app.bean.passport.signout();
+          }
+        },
+        { instanceName: 'shareTest' as any },
+      );
+
+      await app.bean.executor.mockCtx(async () => {
         await app.bean.passport.signinMock();
         try {
-          const [_, err] = await catchError(() =>
-            adjustStock(stockAdjust(skuId, 1, `${skuId}-share`)),
+          const balance = await app.bean.executor.performAction(
+            'get',
+            '/commerce/trade/stockBalance/:id',
+            { params: { id: balanceId } },
+          );
+          assert.deepEqual(
+            [balance.id, balance.skuId, balance.onHand, balance.reserved, balance.available],
+            [balanceId, fixture!.skuId, 5, 0, 5],
           );
-          assert.equal(err?.code, 404);
-          assert.equal(
-            await app.scope('commerce-trade').model.stockBalance.get({ skuId }),
-            undefined,
+          const audit = await app.bean.executor.performAction(
+            'get',
+            '/commerce/trade/stockAudit/:id',
+            { params: { id: auditId } },
           );
           assert.deepEqual(
-            await app.scope('commerce-trade').model.stockAudit.select({ where: { skuId } }),
-            [],
+            [
+              audit.id,
+              audit.stockBalanceId,
+              audit.skuId,
+              audit.operation,
+              audit.delta,
+              audit.reason,
+              audit.correlationId,
+              audit.onHand,
+              audit.reserved,
+              audit.available,
+            ],
+            [auditId, balanceId, fixture!.skuId, 'adjust', 5, reason, correlationId, 5, 0, 5],
           );
         } finally {
           await app.bean.passport.signout();
         }
-      },
-      { instanceName: 'shareTest' as any },
-    );
+      });
+    } finally {
+      await app.bean.executor.mockCtx(async () => {
+        await dropStockFixture(fixture);
+      });
+    }
   });
 });