cabloy 5.1.111 → 5.1.112

package/vona/src/suite/a-commerce/modules/commerce-trade/src/dto/stockBalanceCreate.tsx

@@ -0,0 +1,28 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+
+import { $Dto } from 'vona-module-a-orm';
+import { Dto } from 'vona-module-a-web';
+import { ZovaRender } from 'zova-rest-cabloy-basic-admin';
+
+import { ModelStockBalance } from '../model/stockBalance.ts';
+
+export interface IDtoOptionsStockBalanceCreate extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsStockBalanceCreate>({
+  blocks: [
+    ZovaRender.block('basic-pageentry:blockPageEntry', {
+      blocks: [
+        ZovaRender.block('basic-pageentry:blockForm'),
+        ZovaRender.block('basic-pageentry:blockToolbarRow', {
+          actions: [
+            ZovaRender.formActionRow('basic-form:actionSubmit', {
+              permission: { actionInherit: 'update', formScene: ['create', 'edit'] },
+            }),
+            ZovaRender.formActionRow('basic-form:actionBack', { permission: { public: true } }),
+          ],
+        }),
+      ],
+    }),
+  ],
+})
+export class DtoStockBalanceCreate extends $Dto.create(() => ModelStockBalance) {}

package/vona/src/suite/a-commerce/modules/commerce-trade/src/dto/stockBalanceSelectReq.tsx

@@ -0,0 +1,28 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+
+import { $makeSchema, v } from 'vona-module-a-openapiutils';
+import { $Dto } from 'vona-module-a-orm';
+import { Dto } from 'vona-module-a-web';
+import z from 'zod';
+import { ZovaRender } from 'zova-rest-cabloy-basic-admin';
+
+import { EntityStockBalance } from '../entity/stockBalance.tsx';
+
+export interface IDtoOptionsStockBalanceSelectReq extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsStockBalanceSelectReq>({
+  openapi: { filter: { table: 'commerceTradeStockBalance' } },
+  fields: {
+    skuId: $makeSchema(v.optional(), v.tableIdentity()),
+    createdAt: $makeSchema(
+      ZovaRender.field('basic-date:formFieldDateRange'),
+      v.filterTransform('a-web:dateRange'),
+      v.optional(),
+      z.string(),
+    ),
+  },
+})
+export class DtoStockBalanceSelectReq extends $Dto.queryPage(EntityStockBalance, [
+  'skuId',
+  'createdAt',
+]) {}

package/vona/src/suite/a-commerce/modules/commerce-trade/src/dto/stockBalanceSelectRes.tsx

@@ -0,0 +1,11 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+
+import { $Dto } from 'vona-module-a-orm';
+import { Dto } from 'vona-module-a-web';
+
+import { DtoStockBalanceSelectResItem } from './stockBalanceSelectResItem.tsx';
+
+export interface IDtoOptionsStockBalanceSelectRes extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsStockBalanceSelectRes>()
+export class DtoStockBalanceSelectRes extends $Dto.listAndCount(DtoStockBalanceSelectResItem) {}

package/vona/src/suite/a-commerce/modules/commerce-trade/src/dto/stockBalanceSelectResItem.tsx

@@ -0,0 +1,33 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+
+import { Api, v } from 'vona-module-a-openapiutils';
+import { $Dto } from 'vona-module-a-orm';
+import { Dto } from 'vona-module-a-web';
+import { ZovaRender } from 'zova-rest-cabloy-basic-admin';
+
+import { $locale } from '../.metadata/locales.ts';
+import { ModelStockBalance } from '../model/stockBalance.ts';
+
+export interface IDtoOptionsStockBalanceSelectResItem extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsStockBalanceSelectResItem>({
+  blocks: [
+    ZovaRender.block('basic-page:blockPage', {
+      blocks: [
+        ZovaRender.block('basic-page:blockFilter'),
+        ZovaRender.block('basic-page:blockTable'),
+        ZovaRender.block('basic-page:blockPager'),
+      ],
+    }),
+  ],
+})
+export class DtoStockBalanceSelectResItem extends $Dto.get(() => ModelStockBalance) {
+  @Api.field(
+    v.title($locale('Operations')),
+    ZovaRender.order(1, 'max'),
+    ZovaRender.cell('basic-table:actionOperationsRow', {
+      actions: [ZovaRender.tableActionRow('basic-table:actionView')],
+    }),
+  )
+  _operationsRow?: unknown;
+}

package/vona/src/suite/a-commerce/modules/commerce-trade/src/dto/stockBalanceUpdate.tsx

@@ -0,0 +1,28 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+
+import { $Dto } from 'vona-module-a-orm';
+import { Dto } from 'vona-module-a-web';
+import { ZovaRender } from 'zova-rest-cabloy-basic-admin';
+
+import { ModelStockBalance } from '../model/stockBalance.ts';
+
+export interface IDtoOptionsStockBalanceUpdate extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsStockBalanceUpdate>({
+  blocks: [
+    ZovaRender.block('basic-pageentry:blockPageEntry', {
+      blocks: [
+        ZovaRender.block('basic-pageentry:blockForm'),
+        ZovaRender.block('basic-pageentry:blockToolbarRow', {
+          actions: [
+            ZovaRender.formActionRow('basic-form:actionSubmit', {
+              permission: { actionInherit: 'update', formScene: ['create', 'edit'] },
+            }),
+            ZovaRender.formActionRow('basic-form:actionBack', { permission: { public: true } }),
+          ],
+        }),
+      ],
+    }),
+  ],
+})
+export class DtoStockBalanceUpdate extends $Dto.update(() => ModelStockBalance) {}

package/vona/src/suite/a-commerce/modules/commerce-trade/src/dto/stockBalanceView.tsx

@@ -0,0 +1,25 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+
+import { $Dto } from 'vona-module-a-orm';
+import { Dto } from 'vona-module-a-web';
+import { ZovaRender } from 'zova-rest-cabloy-basic-admin';
+
+import { ModelStockBalance } from '../model/stockBalance.ts';
+
+export interface IDtoOptionsStockBalanceView extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsStockBalanceView>({
+  blocks: [
+    ZovaRender.block('basic-pageentry:blockPageEntry', {
+      blocks: [
+        ZovaRender.block('basic-pageentry:blockForm'),
+        ZovaRender.block('basic-pageentry:blockToolbarRow', {
+          actions: [
+            ZovaRender.formActionRow('basic-form:actionBack', { permission: { public: true } }),
+          ],
+        }),
+      ],
+    }),
+  ],
+})
+export class DtoStockBalanceView extends $Dto.get(() => ModelStockBalance) {}

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

@@ -0,0 +1,24 @@
+import type { TableIdentity } from 'table-identity';
+import type { IDecoratorEntityOptions } from 'vona-module-a-orm';
+
+import { $makeMetadata, Api, v } from 'vona-module-a-openapiutils';
+import { Entity, EntityBase } from 'vona-module-a-orm';
+import { ZovaRender } from 'zova-rest-cabloy-basic-admin';
+
+import { $locale } from '../.metadata/locales.ts';
+
+export interface IEntityOptionsCart extends IDecoratorEntityOptions {}
+
+@Entity<IEntityOptionsCart>('commerceTradeCart', {
+  openapi: { title: $locale('Cart') },
+  fields: {
+    id: $makeMetadata(ZovaRender.visible(false)),
+    iid: $makeMetadata(ZovaRender.visible(false)),
+    userId: $makeMetadata(ZovaRender.visible(false)),
+    deleted: $makeMetadata(ZovaRender.visible(false)),
+  },
+})
+export class EntityCart extends EntityBase {
+  @Api.field(v.tableIdentity())
+  userId: TableIdentity;
+}

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

@@ -0,0 +1,30 @@
+import type { TableIdentity } from 'table-identity';
+import type { IDecoratorEntityOptions } from 'vona-module-a-orm';
+
+import { $makeMetadata, Api, v } from 'vona-module-a-openapiutils';
+import { Entity, EntityBase } from 'vona-module-a-orm';
+import { z } from 'zod';
+import { ZovaRender } from 'zova-rest-cabloy-basic-admin';
+
+import { $locale } from '../.metadata/locales.ts';
+
+export interface IEntityOptionsCartItem extends IDecoratorEntityOptions {}
+
+@Entity<IEntityOptionsCartItem>('commerceTradeCartItem', {
+  openapi: { title: $locale('CartItem') },
+  fields: {
+    id: $makeMetadata(ZovaRender.visible(false)),
+    iid: $makeMetadata(ZovaRender.visible(false)),
+    deleted: $makeMetadata(ZovaRender.visible(false)),
+  },
+})
+export class EntityCartItem extends EntityBase {
+  @Api.field(v.tableIdentity())
+  cartId: TableIdentity;
+
+  @Api.field(v.tableIdentity())
+  skuId: TableIdentity;
+
+  @Api.field(v.required(), z.number().int().positive())
+  quantity: number;
+}

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

@@ -0,0 +1,86 @@
+import type { TableIdentity } from 'table-identity';
+import type { IDecoratorEntityOptions } from 'vona-module-a-orm';
+
+import { $makeMetadata, Api, v } from 'vona-module-a-openapiutils';
+import { Entity, EntityBase } from 'vona-module-a-orm';
+import { z } from 'zod';
+import { ZovaRender } from 'zova-rest-cabloy-basic-admin';
+
+import { $locale } from '../.metadata/locales.ts';
+
+export interface IEntityOptionsStockAudit extends IDecoratorEntityOptions {}
+
+@Entity<IEntityOptionsStockAudit>('commerceTradeStockAudit', {
+  openapi: { title: $locale('StockAudit') },
+  fields: {
+    id: $makeMetadata(ZovaRender.order(1, 'core')),
+    iid: $makeMetadata(ZovaRender.visible(false)),
+    deleted: $makeMetadata(ZovaRender.visible(false)),
+    createdAt: $makeMetadata(
+      ZovaRender.order(-2, 'max'),
+      ZovaRender.field('basic-date:formFieldDate'),
+      ZovaRender.cell('basic-date:date'),
+    ),
+    updatedAt: $makeMetadata(
+      ZovaRender.order(-1, 'max'),
+      ZovaRender.field('basic-date:formFieldDate'),
+      ZovaRender.cell('basic-date:date'),
+    ),
+  },
+})
+export class EntityStockAudit extends EntityBase {
+  @Api.field(
+    v.title($locale('StockBalanceId')),
+    v.required(),
+    v.tableIdentity(),
+    ZovaRender.order(1),
+  )
+  stockBalanceId: TableIdentity;
+
+  @Api.field(v.title($locale('SkuId')), v.required(), v.tableIdentity(), ZovaRender.order(2))
+  skuId: TableIdentity;
+
+  @Api.field(
+    v.title($locale('StockReservationId')),
+    v.optional(),
+    v.tableIdentity(),
+    ZovaRender.order(3),
+  )
+  stockReservationId?: TableIdentity;
+
+  @Api.field(
+    v.title($locale('StockOperation')),
+    v.required(),
+    z.enum(['adjust', 'reserve', 'consume', 'release', 'restore']),
+    ZovaRender.order(4),
+  )
+  operation: 'adjust' | 'reserve' | 'consume' | 'release' | 'restore';
+
+  @Api.field(v.title($locale('Delta')), v.required(), z.int(), ZovaRender.order(5))
+  delta: number;
+
+  @Api.field(v.title($locale('Reason')), v.required(), v.min(1), ZovaRender.order(6))
+  reason: string;
+
+  @Api.field(v.title($locale('CorrelationId')), v.required(), v.min(1), ZovaRender.order(7))
+  correlationId: string;
+
+  @Api.field(v.title($locale('OnHand')), v.required(), z.number().int().min(0), ZovaRender.order(8))
+  onHand: number;
+
+  @Api.field(
+    v.title($locale('Reserved')),
+    v.required(),
+    z.number().int().min(0),
+    ZovaRender.order(9),
+  )
+  reserved: number;
+
+  @Api.field(
+    v.title($locale('Available')),
+    v.required(),
+    z.number().int().min(0),
+    ZovaRender.order(10),
+  )
+  available: number;
+}

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

@@ -0,0 +1,53 @@
+import type { TableIdentity } from 'table-identity';
+import type { IDecoratorEntityOptions } from 'vona-module-a-orm';
+
+import { $makeMetadata, Api, v } from 'vona-module-a-openapiutils';
+import { Entity, EntityBase } from 'vona-module-a-orm';
+import { z } from 'zod';
+import { ZovaRender } from 'zova-rest-cabloy-basic-admin';
+
+import { $locale } from '../.metadata/locales.ts';
+
+export interface IEntityOptionsStockBalance extends IDecoratorEntityOptions {}
+
+@Entity<IEntityOptionsStockBalance>('commerceTradeStockBalance', {
+  openapi: { title: $locale('StockBalance') },
+  fields: {
+    id: $makeMetadata(ZovaRender.order(1, 'core')),
+    iid: $makeMetadata(ZovaRender.visible(false)),
+    deleted: $makeMetadata(ZovaRender.visible(false)),
+    createdAt: $makeMetadata(
+      ZovaRender.order(-2, 'max'),
+      ZovaRender.field('basic-date:formFieldDate'),
+      ZovaRender.cell('basic-date:date'),
+    ),
+    updatedAt: $makeMetadata(
+      ZovaRender.order(-1, 'max'),
+      ZovaRender.field('basic-date:formFieldDate'),
+      ZovaRender.cell('basic-date:date'),
+    ),
+  },
+})
+export class EntityStockBalance extends EntityBase {
+  @Api.field(v.title($locale('SkuId')), v.required(), v.tableIdentity(), ZovaRender.order(1))
+  skuId: TableIdentity;
+
+  @Api.field(v.title($locale('OnHand')), v.required(), z.number().int().min(0), ZovaRender.order(2))
+  onHand: number;
+
+  @Api.field(
+    v.title($locale('Reserved')),
+    v.required(),
+    z.number().int().min(0),
+    ZovaRender.order(3),
+  )
+  reserved: number;
+
+  @Api.field(
+    v.title($locale('Available')),
+    v.required(),
+    z.number().int().min(0),
+    ZovaRender.order(4),
+  )
+  available: number;
+}

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

@@ -0,0 +1,63 @@
+import type { TableIdentity } from 'table-identity';
+import type { IDecoratorEntityOptions } from 'vona-module-a-orm';
+
+import { $makeMetadata, Api, v } from 'vona-module-a-openapiutils';
+import { Entity, EntityBase } from 'vona-module-a-orm';
+import { z } from 'zod';
+import { ZovaRender } from 'zova-rest-cabloy-basic-admin';
+
+import { $locale } from '../.metadata/locales.ts';
+
+export type TypeStockReservationState = 'reserved' | 'consumed' | 'released' | 'restored';
+
+export interface IEntityOptionsStockReservation extends IDecoratorEntityOptions {}
+
+@Entity<IEntityOptionsStockReservation>('commerceTradeStockReservation', {
+  openapi: { title: $locale('StockReservation') },
+  fields: {
+    id: $makeMetadata(ZovaRender.order(1, 'core')),
+    iid: $makeMetadata(ZovaRender.visible(false)),
+    deleted: $makeMetadata(ZovaRender.visible(false)),
+    createdAt: $makeMetadata(
+      ZovaRender.order(-2, 'max'),
+      ZovaRender.field('basic-date:formFieldDate'),
+      ZovaRender.cell('basic-date:date'),
+    ),
+    updatedAt: $makeMetadata(
+      ZovaRender.order(-1, 'max'),
+      ZovaRender.field('basic-date:formFieldDate'),
+      ZovaRender.cell('basic-date:date'),
+    ),
+  },
+})
+export class EntityStockReservation extends EntityBase {
+  @Api.field(
+    v.title($locale('StockBalanceId')),
+    v.required(),
+    v.tableIdentity(),
+    ZovaRender.order(1),
+  )
+  stockBalanceId: TableIdentity;
+
+  @Api.field(v.title($locale('SkuId')), v.required(), v.tableIdentity(), ZovaRender.order(2))
+  skuId: TableIdentity;
+
+  @Api.field(
+    v.title($locale('Quantity')),
+    v.required(),
+    z.number().int().positive(),
+    ZovaRender.order(3),
+  )
+  quantity: number;
+
+  @Api.field(
+    v.title($locale('ReservationState')),
+    v.required(),
+    z.enum(['reserved', 'consumed', 'released', 'restored']),
+    ZovaRender.order(4),
+  )
+  state: TypeStockReservationState;
+
+  @Api.field(v.title($locale('CorrelationId')), v.required(), v.min(1), ZovaRender.order(5))
+  correlationId: string;
+}

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

@@ -1 +1,2 @@
+export * from './.metadata/locales.ts';
 export * from './.metadata/index.ts';

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

@@ -0,0 +1,17 @@
+import type { IDecoratorModelOptions } from 'vona-module-a-orm';
+
+import { $relation, BeanModelBase, Model } from 'vona-module-a-orm';
+
+import { EntityCart } from '../entity/cart.tsx';
+
+export interface IModelOptionsCart extends IDecoratorModelOptions<EntityCart> {}
+
+@Model<IModelOptionsCart>({
+  entity: EntityCart,
+  relations: {
+    items: $relation.hasMany('commerce-trade:cartItem', 'cartId', {
+      columns: ['id', 'skuId', 'quantity'],
+    }),
+  },
+})
+export class ModelCart extends BeanModelBase<EntityCart> {}

package/vona/src/suite/a-commerce/modules/commerce-trade/src/model/cartItem.ts

@@ -0,0 +1,10 @@
+import type { IDecoratorModelOptions } from 'vona-module-a-orm';
+
+import { BeanModelBase, Model } from 'vona-module-a-orm';
+
+import { EntityCartItem } from '../entity/cartItem.tsx';
+
+export interface IModelOptionsCartItem extends IDecoratorModelOptions<EntityCartItem> {}
+
+@Model<IModelOptionsCartItem>({ entity: EntityCartItem })
+export class ModelCartItem extends BeanModelBase<EntityCartItem> {}

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

@@ -0,0 +1,10 @@
+import type { IDecoratorModelOptions } from 'vona-module-a-orm';
+
+import { BeanModelBase, Model } from 'vona-module-a-orm';
+
+import { EntityStockAudit } from '../entity/stockAudit.tsx';
+
+export interface IModelOptionsStockAudit extends IDecoratorModelOptions<EntityStockAudit> {}
+
+@Model<IModelOptionsStockAudit>({ entity: EntityStockAudit })
+export class ModelStockAudit extends BeanModelBase<EntityStockAudit> {}

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

@@ -0,0 +1,15 @@
+import type { IDecoratorModelOptions } from 'vona-module-a-orm';
+
+import { BeanModelBase, Model } from 'vona-module-a-orm';
+
+import { EntityStockBalance } from '../entity/stockBalance.tsx';
+
+export interface IModelOptionsStockBalance extends IDecoratorModelOptions<EntityStockBalance> {}
+
+@Model<IModelOptionsStockBalance>({
+  entity: EntityStockBalance,
+  cache: {
+    modelsClear: 'commerce-catalog:sku',
+  },
+})
+export class ModelStockBalance extends BeanModelBase<EntityStockBalance> {}

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

@@ -0,0 +1,10 @@
+import type { IDecoratorModelOptions } from 'vona-module-a-orm';
+
+import { BeanModelBase, Model } from 'vona-module-a-orm';
+
+import { EntityStockReservation } from '../entity/stockReservation.tsx';
+
+export interface IModelOptionsStockReservation extends IDecoratorModelOptions<EntityStockReservation> {}
+
+@Model<IModelOptionsStockReservation>({ entity: EntityStockReservation })
+export class ModelStockReservation extends BeanModelBase<EntityStockReservation> {}

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);
+  }
+}