cabloy 5.1.111 → 5.1.113

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

@@ -0,0 +1,152 @@
+import type { TableIdentity } from 'table-identity';
+
+import { BeanBase } from 'vona';
+import { Service } from 'vona-module-a-bean';
+import { Core } from 'vona-module-a-core';
+
+import type { DtoCartAddItem } from '../dto/cartAddItem.tsx';
+import type { DtoCartItem } from '../dto/cartItem.tsx';
+import type { DtoCartUpdateItem } from '../dto/cartUpdateItem.tsx';
+import type { DtoCartView } from '../dto/cartView.tsx';
+import type { EntityCart } from '../entity/cart.tsx';
+
+@Service()
+export class ServiceCart extends BeanBase {
+  async current(): Promise<DtoCartView> {
+    const cart = await this._getCurrentCart();
+    return await this._toCartView(cart);
+  }
+
+  @Core.transaction({ isolationLevel: 'SERIALIZABLE' })
+  async addItem(command: DtoCartAddItem): Promise<DtoCartView> {
+    await this._assertSellableSku(command.skuId, command.quantity);
+    const cart = await this._getOrCreateCurrentCart();
+    const item = await this.scope.model.cartItem.getForUpdate({
+      cartId: cart.id,
+      skuId: command.skuId,
+    });
+    if (item) {
+      const quantity = item.quantity + command.quantity;
+      await this._assertSellableSku(command.skuId, quantity);
+      await this.scope.model.cartItem.updateById(item.id, { quantity });
+    } else {
+      await this.scope.model.cartItem.insert({
+        cartId: cart.id,
+        skuId: command.skuId,
+        quantity: command.quantity,
+      });
+    }
+    return await this._toCartView(cart);
+  }
+
+  @Core.transaction({ isolationLevel: 'SERIALIZABLE' })
+  async updateItem(id: TableIdentity, command: DtoCartUpdateItem): Promise<DtoCartView> {
+    const cart = await this._getCurrentCartForUpdate();
+    if (!cart) return { items: [] };
+    const item = await this.scope.model.cartItem.getForUpdate({ id, cartId: cart.id });
+    if (!item) return await this._toCartView(cart);
+    await this._assertSellableSku(item.skuId, command.quantity);
+    await this.scope.model.cartItem.updateById(item.id, { quantity: command.quantity });
+    return await this._toCartView(cart);
+  }
+
+  @Core.transaction({ isolationLevel: 'SERIALIZABLE' })
+  async deleteItem(id: TableIdentity): Promise<DtoCartView> {
+    const cart = await this._getCurrentCartForUpdate();
+    if (!cart) return { items: [] };
+    const item = await this.scope.model.cartItem.getForUpdate({ id, cartId: cart.id });
+    if (item) await this.scope.model.cartItem.deleteById(item.id);
+    return await this._toCartView(cart);
+  }
+
+  @Core.transaction({ isolationLevel: 'SERIALIZABLE' })
+  async clear(): Promise<DtoCartView> {
+    const cart = await this._getCurrentCartForUpdate();
+    if (!cart) return { items: [] };
+    await this.scope.model.cartItem.delete({ cartId: cart.id });
+    return await this._toCartView(cart);
+  }
+
+  private _getCurrentUserId(): TableIdentity {
+    return this.bean.passport.currentUser!.id;
+  }
+
+  private async _getCurrentCart(): Promise<EntityCart | undefined> {
+    return await this.scope.model.cart.get({ userId: this._getCurrentUserId() });
+  }
+
+  private async _getCurrentCartForUpdate(): Promise<EntityCart | undefined> {
+    return await this.scope.model.cart.getForUpdate({ userId: this._getCurrentUserId() });
+  }
+
+  private async _getOrCreateCurrentCart(): Promise<EntityCart> {
+    let cart = await this._getCurrentCartForUpdate();
+    if (!cart) {
+      cart = await this.scope.model.cart.insert({ userId: this._getCurrentUserId() });
+    }
+    return cart;
+  }
+
+  private async _toCartView(cart: EntityCart | undefined): Promise<DtoCartView> {
+    if (!cart) return { items: [] };
+    const items = await this.scope.model.cartItem.select({
+      where: { cartId: cart.id },
+      orders: [['id', 'asc']],
+    });
+    return {
+      id: cart.id,
+      items: (await Promise.all(items.map(item => this._toCartItem(item)))).flatMap(item =>
+        item ? [item] : [],
+      ),
+    };
+  }
+
+  private async _toCartItem(item: {
+    id: TableIdentity;
+    skuId: TableIdentity;
+    quantity: number;
+  }): Promise<DtoCartItem | undefined> {
+    const sku = await this.$scope.commerceCatalog.model.sku.getById(item.skuId, {
+      include: {
+        product: {
+          include: {
+            category: true,
+          },
+        },
+      },
+    });
+    const balance = await this.scope.model.stockBalance.get({ skuId: item.skuId });
+    if (!sku || !sku.product || !sku.product.category || !balance) return undefined;
+    return {
+      id: item.id,
+      skuId: item.skuId,
+      quantity: item.quantity,
+      skuCode: sku.code,
+      productTitle: sku.product.title,
+      priceCents: sku.priceCents,
+      available: balance.available,
+    };
+  }
+
+  private async _assertSellableSku(skuId: TableIdentity, quantity: number) {
+    const sku = await this.$scope.commerceCatalog.model.sku.getById(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 balance = await this.scope.model.stockBalance.get({ skuId });
+    if (!balance || balance.available < quantity) {
+      this.app.throw(409, 'insufficient available stock');
+    }
+  }
+}

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

@@ -0,0 +1,20 @@
+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 type { DtoStockAuditSelectRes } from '../dto/stockAuditSelectRes.tsx';
+import type { DtoStockAuditView } from '../dto/stockAuditView.tsx';
+import type { ModelStockAudit } from '../model/stockAudit.ts';
+
+@Service()
+export class ServiceStockAudit extends BeanBase {
+  async select(params?: IQueryParams<ModelStockAudit>): Promise<DtoStockAuditSelectRes> {
+    return await this.scope.model.stockAudit.selectAndCount(params);
+  }
+
+  async view(id: TableIdentity): Promise<DtoStockAuditView | undefined> {
+    return await this.scope.model.stockAudit.getById(id);
+  }
+}

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

@@ -0,0 +1,342 @@
+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,
+    });
+    const priorBalance = stockBalance ?? {
+      onHand: 0,
+      reserved: 0,
+      available: 0,
+    };
+    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,
+      priorBalance,
+      delta: stockAdjust.delta,
+      operation: 'adjust',
+      reason: stockAdjust.reason,
+      correlationId: stockAdjust.correlationId,
+    });
+    return stockBalance;
+  }
+
+  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: {
+        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 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',
+      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 priorBalance = stockBalance;
+    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,
+      priorBalance,
+      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,
+    priorBalance,
+    stockReservationId,
+    delta,
+    operation,
+    reason,
+    correlationId,
+  }: {
+    stockBalance: EntityStockBalance;
+    priorBalance: Pick<EntityStockBalance, 'onHand' | 'reserved' | 'available'>;
+    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,
+      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');
+    }
+    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);
+    });
+  });
+});