cabloy 5.1.111 → 5.1.112

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

@@ -0,0 +1,305 @@
+import type { TableIdentity } from 'table-identity';
+import type { IQueryParams } from 'vona-module-a-orm';
+
+import { BeanBase } from 'vona';
+import { Service } from 'vona-module-a-bean';
+import { Core } from 'vona-module-a-core';
+
+import type { DtoStockAdjust } from '../dto/stockAdjust.tsx';
+import type { DtoStockBalanceSelectRes } from '../dto/stockBalanceSelectRes.tsx';
+import type { DtoStockBalanceView } from '../dto/stockBalanceView.tsx';
+import type { EntityStockBalance } from '../entity/stockBalance.tsx';
+import type {
+  EntityStockReservation,
+  TypeStockReservationState,
+} from '../entity/stockReservation.tsx';
+import type { ModelStockBalance } from '../model/stockBalance.ts';
+
+export interface IStockReservationCommand {
+  skuId: TableIdentity;
+  quantity: number;
+  correlationId: string;
+  reason: string;
+}
+
+export interface IStockReservationTransition {
+  reservationId: TableIdentity;
+  reason: string;
+}
+
+@Service()
+export class ServiceStockBalance extends BeanBase {
+  async select(params?: IQueryParams<ModelStockBalance>): Promise<DtoStockBalanceSelectRes> {
+    return await this.scope.model.stockBalance.selectAndCount(params);
+  }
+
+  async view(id: TableIdentity): Promise<DtoStockBalanceView | undefined> {
+    return await this.scope.model.stockBalance.getById(id);
+  }
+
+  @Core.transaction({ isolationLevel: 'SERIALIZABLE' })
+  async adjustStock(stockAdjust: DtoStockAdjust): Promise<EntityStockBalance> {
+    const sku = await this.$scope.commerceCatalog.model.sku.getById(stockAdjust.skuId);
+    if (!sku) {
+      this.app.throw(404, 'SKU not found');
+    }
+
+    let stockBalance = await this.scope.model.stockBalance.getForUpdate({
+      skuId: stockAdjust.skuId,
+    });
+    if (!stockBalance) {
+      if (stockAdjust.delta < 0) {
+        throw new Error('stock adjustment would make balance negative');
+      }
+      stockBalance = await this.scope.model.stockBalance.insert({
+        skuId: stockAdjust.skuId,
+        onHand: stockAdjust.delta,
+        reserved: 0,
+        available: stockAdjust.delta,
+      });
+    } else {
+      const onHand = stockBalance.onHand + stockAdjust.delta;
+      const reserved = stockBalance.reserved;
+      const available = onHand - reserved;
+      if (onHand < 0 || reserved < 0 || available < 0) {
+        throw new Error('stock adjustment would make balance negative');
+      }
+      await this.scope.model.stockBalance.updateById(stockBalance.id, {
+        onHand,
+        reserved,
+        available,
+      });
+      stockBalance = {
+        ...stockBalance,
+        onHand,
+        reserved,
+        available,
+      };
+    }
+
+    await this._appendAudit({
+      stockBalance,
+      delta: stockAdjust.delta,
+      operation: 'adjust',
+      reason: stockAdjust.reason,
+      correlationId: stockAdjust.correlationId,
+    });
+    return stockBalance;
+  }
+
+  @Core.transaction({ isolationLevel: 'SERIALIZABLE' })
+  async reserve(command: IStockReservationCommand): Promise<EntityStockReservation> {
+    this._assertReservationCommand(command);
+    const sku = await this.$scope.commerceCatalog.model.sku.getById(command.skuId, {
+      include: {
+        product: {
+          include: {
+            category: true,
+          },
+        },
+      },
+    });
+    if (!sku || sku.lifecycle !== 'active') {
+      this.app.throw(404, 'SKU not found');
+    }
+    if (!sku.product?.published || !sku.product.category?.published) {
+      this.app.throw(409, 'SKU is not sellable');
+    }
+
+    const stockBalance = await this._getLockedBalance(command.skuId);
+    if (!stockBalance) {
+      this.app.throw(409, 'insufficient available stock');
+    }
+    const existingReservation = await this.scope.model.stockReservation.get({
+      correlationId: command.correlationId,
+    });
+    if (existingReservation) {
+      if (
+        String(existingReservation.skuId) !== String(command.skuId) ||
+        existingReservation.quantity !== command.quantity
+      ) {
+        this.app.throw(409, 'stock reservation correlation conflicts with an existing reservation');
+      }
+      return existingReservation;
+    }
+    if (stockBalance.available < command.quantity) {
+      this.app.throw(409, 'insufficient available stock');
+    }
+
+    const reservation = await this.scope.model.stockReservation.insert({
+      stockBalanceId: stockBalance.id,
+      skuId: command.skuId,
+      quantity: command.quantity,
+      state: 'reserved',
+      correlationId: command.correlationId,
+    });
+    const updatedBalance = await this._updateBalance(stockBalance, {
+      onHand: stockBalance.onHand,
+      reserved: stockBalance.reserved + command.quantity,
+    });
+    await this._appendAudit({
+      stockBalance: updatedBalance,
+      stockReservationId: reservation.id,
+      delta: -command.quantity,
+      operation: 'reserve',
+      reason: command.reason,
+      correlationId: command.correlationId,
+    });
+    return reservation;
+  }
+
+  @Core.transaction({ isolationLevel: 'SERIALIZABLE' })
+  async consume(transition: IStockReservationTransition): Promise<EntityStockReservation> {
+    return await this._transitionReservation(
+      transition,
+      'reserved',
+      'consumed',
+      (stockBalance, reservation) => ({
+        onHand: stockBalance.onHand - reservation.quantity,
+        reserved: stockBalance.reserved - reservation.quantity,
+      }),
+    );
+  }
+
+  @Core.transaction({ isolationLevel: 'SERIALIZABLE' })
+  async release(transition: IStockReservationTransition): Promise<EntityStockReservation> {
+    return await this._transitionReservation(
+      transition,
+      'reserved',
+      'released',
+      (stockBalance, reservation) => ({
+        onHand: stockBalance.onHand,
+        reserved: stockBalance.reserved - reservation.quantity,
+      }),
+    );
+  }
+
+  @Core.transaction({ isolationLevel: 'SERIALIZABLE' })
+  async restore(transition: IStockReservationTransition): Promise<EntityStockReservation> {
+    return await this._transitionReservation(
+      transition,
+      'consumed',
+      'restored',
+      (stockBalance, reservation) => ({
+        onHand: stockBalance.onHand + reservation.quantity,
+        reserved: stockBalance.reserved,
+      }),
+    );
+  }
+
+  private async _transitionReservation(
+    transition: IStockReservationTransition,
+    sourceState: TypeStockReservationState,
+    targetState: TypeStockReservationState,
+    calculateBalance: (
+      stockBalance: EntityStockBalance,
+      reservation: EntityStockReservation,
+    ) => Pick<EntityStockBalance, 'onHand' | 'reserved'>,
+  ): Promise<EntityStockReservation> {
+    if (!transition.reason.trim()) {
+      this.app.throw(400, 'stock reservation reason is required');
+    }
+    const reservation = await this.scope.model.stockReservation.getByIdForUpdate(
+      transition.reservationId,
+    );
+    if (!reservation) {
+      this.app.throw(404, 'stock reservation not found');
+    }
+    if (reservation.state === targetState) {
+      return reservation;
+    }
+    if (reservation.state !== sourceState) {
+      this.app.throw(409, `cannot ${targetState} a ${reservation.state} stock reservation`);
+    }
+
+    const stockBalance = await this.scope.model.stockBalance.getByIdForUpdate(
+      reservation.stockBalanceId,
+    );
+    if (!stockBalance) {
+      this.app.throw(404, 'stock balance not found');
+    }
+    const updatedBalance = await this._updateBalance(
+      stockBalance,
+      calculateBalance(stockBalance, reservation),
+    );
+    await this.scope.model.stockReservation.updateById(reservation.id, { state: targetState });
+    const updatedReservation = { ...reservation, state: targetState };
+    const operation =
+      targetState === 'consumed' ? 'consume' : targetState === 'released' ? 'release' : 'restore';
+    await this._appendAudit({
+      stockBalance: updatedBalance,
+      stockReservationId: reservation.id,
+      delta:
+        operation === 'consume'
+          ? -reservation.quantity
+          : operation === 'restore'
+            ? reservation.quantity
+            : 0,
+      operation,
+      reason: transition.reason,
+      correlationId: reservation.correlationId,
+    });
+    return updatedReservation;
+  }
+
+  private async _getLockedBalance(skuId: TableIdentity): Promise<EntityStockBalance | undefined> {
+    return await this.scope.model.stockBalance.getForUpdate({ skuId });
+  }
+
+  private async _updateBalance(
+    stockBalance: EntityStockBalance,
+    values: Pick<EntityStockBalance, 'onHand' | 'reserved'>,
+  ): Promise<EntityStockBalance> {
+    const available = values.onHand - values.reserved;
+    if (values.onHand < 0 || values.reserved < 0 || available < 0) {
+      this.app.throw(409, 'stock balance would become negative');
+    }
+    await this.scope.model.stockBalance.updateById(stockBalance.id, {
+      onHand: values.onHand,
+      reserved: values.reserved,
+      available,
+    });
+    return { ...stockBalance, ...values, available };
+  }
+
+  private async _appendAudit({
+    stockBalance,
+    stockReservationId,
+    delta,
+    operation,
+    reason,
+    correlationId,
+  }: {
+    stockBalance: EntityStockBalance;
+    stockReservationId?: TableIdentity;
+    delta: number;
+    operation: 'adjust' | 'reserve' | 'consume' | 'release' | 'restore';
+    reason: string;
+    correlationId: string;
+  }) {
+    await this.scope.model.stockAudit.insert({
+      stockBalanceId: stockBalance.id,
+      skuId: stockBalance.skuId,
+      stockReservationId,
+      operation,
+      delta,
+      reason,
+      correlationId,
+      onHand: stockBalance.onHand,
+      reserved: stockBalance.reserved,
+      available: stockBalance.available,
+    });
+  }
+
+  private _assertReservationCommand(command: IStockReservationCommand) {
+    if (!Number.isInteger(command.quantity) || command.quantity <= 0) {
+      this.app.throw(400, 'stock reservation quantity must be a positive integer');
+    }
+    if (!command.correlationId.trim()) {
+      this.app.throw(400, 'stock reservation correlationId is required');
+    }
+    if (!command.reason.trim()) {
+      this.app.throw(400, 'stock reservation reason is required');
+    }
+  }
+}

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

@@ -0,0 +1,174 @@
+import type { DtoCartAddItem, DtoCartUpdateItem } from 'vona-module-commerce-trade';
+
+import { catchError } from '@cabloy/utils';
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { app } from 'vona-mock';
+
+const actionPath = '/commerce/trade/cart';
+
+function cartItem(skuId: number, quantity = 1): DtoCartAddItem {
+  return { skuId, quantity };
+}
+
+async function performAs(accessToken: string, method: string, path: string, options = {}) {
+  return await app.bean.executor.newCtxIsolate(async () => {
+    return await app.bean.executor.performAction(method, path, {
+      ...options,
+      authToken: accessToken,
+      innerAccess: false,
+    });
+  });
+}
+
+async function registerAndSignin(name: string) {
+  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! };
+}
+
+async function createSellableSku(suffix: string) {
+  await app.bean.passport.signinMock();
+  try {
+    const categoryId = await app.bean.executor.performAction('post', '/commerce/catalog/category', {
+      body: { name: `cart-category-${suffix}`, published: true },
+    });
+    const productId = await app.bean.executor.performAction('post', '/commerce/catalog/product', {
+      body: { categoryId, title: `cart-product-${suffix}`, published: true },
+    });
+    const skuId = await app.bean.executor.performAction('post', '/commerce/catalog/sku', {
+      body: {
+        productId,
+        code: `cart-sku-${suffix}`,
+        priceCents: 100,
+        lifecycle: 'active',
+      },
+    });
+    await app.bean.executor.performAction('post', '/commerce/trade/stockBalance/adjustStock', {
+      body: {
+        skuId,
+        delta: 10,
+        reason: `cart stock ${suffix}`,
+        correlationId: `cart-stock-${suffix}`,
+      },
+    });
+    return skuId;
+  } finally {
+    await app.bean.passport.signout();
+  }
+}
+
+describe('cartOwnership.test.ts', () => {
+  it('denies anonymous cart actions', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      for (const [method, path, options] of [
+        ['get', actionPath, {}],
+        ['post', `${actionPath}/items`, { body: cartItem(1) }],
+        ['patch', `${actionPath}/items/:id`, { params: { id: 999999 }, body: { quantity: 1 } }],
+        ['delete', `${actionPath}/items/:id`, { params: { id: 999999 } }],
+        ['delete', `${actionPath}/items`, {}],
+      ] as const) {
+        const [_, err] = await catchError(() =>
+          app.bean.executor.performAction(method, path, { ...options, innerAccess: false }),
+        );
+        assert.equal(err?.code, 401);
+      }
+    });
+  });
+
+  it('derives cart ownership from the authenticated customer and scopes every item action', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const suffix = `${Date.now()}`;
+      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);
+
+      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 cleared = await performAs(customerA.token, 'delete', `${actionPath}/items`);
+      assert.deepEqual(cleared.items, []);
+    });
+  });
+
+  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 = `${Date.now()}`;
+      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;
+    });
+
+    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(customer.token, 'patch', `${actionPath}/items/:id`, {
+            params: { id: itemId },
+            body: { quantity: 2 },
+          }),
+          { items: [] },
+        );
+        assert.deepEqual(
+          await performAs(customer.token, 'delete', `${actionPath}/items/:id`, {
+            params: { id: itemId },
+          }),
+          { items: [] },
+        );
+      },
+      { instanceName: 'shareTest' as any },
+    );
+
+    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);
+    });
+  });
+});

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

@@ -0,0 +1,37 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { app } from 'vona-mock';
+
+describe('stockAudit.test.ts', () => {
+  it('action:stockAudit permits system-admin read actions only', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      await app.bean.passport.signinMock();
+      try {
+        const actions = ['select', 'view'];
+        const permissions = await Promise.all(
+          actions.map(action =>
+            app.bean.permission.retrievePermissionAction('commerce-trade:stockAudit', action),
+          ),
+        );
+        assert.deepEqual(
+          permissions,
+          actions.map(() => true),
+        );
+        assert.equal(
+          await app.bean.permission.retrievePermissionAction('commerce-trade:stockAudit', 'create'),
+          false,
+        );
+        assert.equal(
+          await app.bean.permission.retrievePermissionAction('commerce-trade:stockAudit', 'update'),
+          false,
+        );
+        assert.equal(
+          await app.bean.permission.retrievePermissionAction('commerce-trade:stockAudit', 'delete'),
+          false,
+        );
+      } finally {
+        await app.bean.passport.signout();
+      }
+    });
+  });
+});

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

@@ -0,0 +1,186 @@
+import type { DtoStockAdjust, EntityStockBalance } from 'vona-module-commerce-trade';
+
+import { catchError } from '@cabloy/utils';
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { app } from 'vona-mock';
+
+const actionPath = '/commerce/trade/stockBalance/adjustStock';
+
+function stockAdjust(skuId: number, delta: number, suffix: string): DtoStockAdjust {
+  return {
+    skuId,
+    delta,
+    reason: `test adjustment ${suffix}`,
+    correlationId: `stock-test-${suffix}`,
+  };
+}
+
+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 adjustStock(stockAdjust: DtoStockAdjust): Promise<EntityStockBalance> {
+  return await app.bean.executor.performAction('post', actionPath, { body: stockAdjust });
+}
+
+describe('stockBalance.test.ts', () => {
+  it('action:stockBalance:adjustStock appends an audit with server-scoped balance', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      await app.bean.passport.signinMock();
+      try {
+        const skuId = await createSku(`${Date.now()}`);
+        const balance = await adjustStock(stockAdjust(skuId, 8, `${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`));
+        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 },
+        });
+        assert.equal(audits.length, 2);
+        assert.deepEqual(
+          audits.map(item => [item.delta, item.onHand, item.reserved, item.available]),
+          [
+            [8, 8, 0, 8],
+            [-3, 5, 0, 5],
+          ],
+        );
+        assert.equal(audits[1].stockBalanceId, balance.id);
+      } finally {
+        await app.bean.passport.signout();
+      }
+    });
+  });
+
+  it('action:stockBalance:adjustStock rejects negative stock without an audit', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      await app.bean.passport.signinMock();
+      try {
+        const skuId = await createSku(`${Date.now()}`);
+        const balance = await adjustStock(stockAdjust(skuId, 2, `${skuId}-initial`));
+        const [_, err] = await catchError(() =>
+          adjustStock(stockAdjust(skuId, -3, `${skuId}-reject`)),
+        );
+        assert.match(err?.message ?? '', /negative/);
+
+        const unchanged = await app.scope('commerce-trade').model.stockBalance.getById(balance.id);
+        assert.equal(unchanged?.onHand, 2);
+        assert.equal(unchanged?.available, 2);
+        const audits = await app.scope('commerce-trade').model.stockAudit.select({
+          where: { skuId },
+        });
+        assert.equal(audits.length, 1);
+      } finally {
+        await app.bean.passport.signout();
+      }
+    });
+  });
+
+  it('action:stockBalance:adjustStock rolls back the balance when audit insertion fails', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      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;
+        }
+
+        const unchanged = await app.scope('commerce-trade').model.stockBalance.getById(balance.id);
+        assert.equal(unchanged?.onHand, 4);
+        assert.equal(unchanged?.available, 4);
+      } finally {
+        await app.bean.passport.signout();
+      }
+    });
+  });
+
+  it('action:stockBalance:adjustStock treats a missing SKU as not found', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      await app.bean.passport.signinMock();
+      try {
+        const skuId = 999999999;
+        const [_, err] = await catchError(() =>
+          adjustStock(stockAdjust(skuId, 1, `${skuId}-missing`)),
+        );
+        assert.equal(err?.code, 404);
+        assert.equal(
+          await app.scope('commerce-trade').model.stockBalance.get({ skuId }),
+          undefined,
+        );
+        assert.deepEqual(
+          await app.scope('commerce-trade').model.stockAudit.select({ where: { skuId } }),
+          [],
+        );
+      } finally {
+        await app.bean.passport.signout();
+      }
+    });
+  });
+
+  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();
+      }
+    });
+
+    await app.bean.executor.mockCtx(
+      async () => {
+        await app.bean.passport.signinMock();
+        try {
+          const [_, err] = await catchError(() =>
+            adjustStock(stockAdjust(skuId, 1, `${skuId}-share`)),
+          );
+          assert.equal(err?.code, 404);
+          assert.equal(
+            await app.scope('commerce-trade').model.stockBalance.get({ skuId }),
+            undefined,
+          );
+          assert.deepEqual(
+            await app.scope('commerce-trade').model.stockAudit.select({ where: { skuId } }),
+            [],
+          );
+        } finally {
+          await app.bean.passport.signout();
+        }
+      },
+      { instanceName: 'shareTest' as any },
+    );
+  });
+});