cabloy 5.1.111 → 5.1.113

package/vona/src/suite/a-commerce/modules/commerce-catalog/src/service/product.ts

@@ -0,0 +1,162 @@
+import type { Knex } from 'knex';
+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 { DtoProductCreate } from '../dto/productCreate.tsx';
+import type { DtoProductPublic } from '../dto/productPublic.tsx';
+import type { DtoProductPublicSelectRes } from '../dto/productPublicSelectRes.tsx';
+import type { DtoProductSelectRes } from '../dto/productSelectRes.tsx';
+import type { DtoProductUpdate } from '../dto/productUpdate.tsx';
+import type { DtoProductView } from '../dto/productView.tsx';
+import type { EntityProduct } from '../entity/product.tsx';
+import type { ModelProduct } from '../model/product.ts';
+
+@Service()
+export class ServiceProduct extends BeanBase {
+  async create(product: DtoProductCreate): Promise<EntityProduct> {
+    await this._ensureCategoryExists(product.categoryId);
+    return await this.scope.model.product.insert(product);
+  }
+
+  async select(params?: IQueryParams<ModelProduct>): Promise<DtoProductSelectRes> {
+    return await this.scope.model.product.selectAndCount(params);
+  }
+
+  async selectPublic(params: IQueryParams<ModelProduct>): Promise<DtoProductPublicSelectRes> {
+    const result = await this.scope.model.product.selectAndCount({
+      columns: ['id', 'title', 'description', 'categoryId'],
+      where: this._getPublicProductWhere(params.where),
+      orders: [['id', 'asc']],
+      limit: params.limit ?? 20,
+      offset: params.offset ?? 0,
+      include: {
+        category: { columns: ['id', 'name'] },
+        skuAvailables: true,
+      },
+    });
+    const balancesBySkuId = await this._getBalancesBySkuId(
+      result.list.flatMap((product: any) => product.skuAvailables.map((sku: any) => sku.id)),
+    );
+    return {
+      ...result,
+      list: result.list.flatMap((product: any) => {
+        const item = this._toPublicProduct(product, balancesBySkuId);
+        return item ? [item] : [];
+      }),
+    };
+  }
+
+  async view(id: TableIdentity): Promise<DtoProductView | undefined> {
+    return await this.scope.model.product.getById(id);
+  }
+
+  async viewPublic(id: TableIdentity): Promise<DtoProductPublic | undefined> {
+    const product = await this.scope.model.product.get(this._getPublicProductWhere({ id }), {
+      columns: ['id', 'title', 'description', 'categoryId'],
+      include: {
+        category: { columns: ['id', 'name'] },
+        skuAvailables: true,
+      },
+    });
+    if (!product) return undefined;
+    const balancesBySkuId = await this._getBalancesBySkuId(
+      product.skuAvailables.map(sku => sku.id),
+    );
+    return this._toPublicProduct(product, balancesBySkuId);
+  }
+
+  async update(id: TableIdentity, product: DtoProductUpdate) {
+    if (product.categoryId !== undefined) await this._ensureCategoryExists(product.categoryId);
+    return await this.scope.model.product.updateById(id, product);
+  }
+
+  async delete(id: TableIdentity) {
+    return await this.scope.model.product.deleteById(id);
+  }
+
+  private _getPublicProductWhere(where?: Record<string, unknown>) {
+    const productModel = this.scope.model.product;
+    const categoryModel = this.scope.model.category;
+    const skuModel = this.scope.model.sku;
+    const stockBalanceModel = this.$scope.commerceTrade.model.stockBalance;
+    return {
+      ...where,
+      published: true,
+      _exists_: function (this: Knex.QueryBuilder) {
+        this.select(1)
+          .from('commerceCatalogSku')
+          .innerJoin('commerceTradeStockBalance', function () {
+            this.on('commerceCatalogSku.id', '=', 'commerceTradeStockBalance.skuId').andOn(
+              'commerceCatalogSku.iid',
+              '=',
+              'commerceTradeStockBalance.iid',
+            );
+          });
+        skuModel.prepareWhere(this, 'commerceCatalogSku', { lifecycle: 'active' });
+        this.where('commerceCatalogSku.productId', productModel.ref('commerceCatalogProduct.id'));
+        stockBalanceModel.prepareWhere(this, 'commerceTradeStockBalance', {
+          available: { _gt_: 0 },
+        });
+        this.whereExists(function (this: Knex.QueryBuilder) {
+          this.select(1).from('commerceCatalogCategory');
+          categoryModel.prepareWhere(this, 'commerceCatalogCategory', { published: true });
+          this.where(
+            'commerceCatalogCategory.id',
+            productModel.ref('commerceCatalogProduct.categoryId'),
+          );
+        });
+      } as any,
+    };
+  }
+
+  private async _getBalancesBySkuId(skuIds: TableIdentity[]) {
+    if (skuIds.length === 0) return new Map<string, number>();
+    const balances = await this.$scope.commerceTrade.model.stockBalance.select({
+      columns: ['skuId', 'available'],
+      where: {
+        skuId: skuIds,
+        available: { _gt_: 0 },
+      },
+    });
+    return new Map(balances.map(balance => [String(balance.skuId), balance.available]));
+  }
+
+  private _toPublicProduct(
+    product: any,
+    balancesBySkuId: Map<string, number>,
+  ): DtoProductPublic | undefined {
+    if (!product.category) return undefined;
+    const skuAvailables = product.skuAvailables.flatMap((sku: any) => {
+      const available = balancesBySkuId.get(String(sku.id));
+      if (!available) return [];
+      return [
+        {
+          id: sku.id,
+          code: sku.code,
+          priceCents: sku.priceCents,
+          available,
+        },
+      ];
+    });
+    if (skuAvailables.length === 0) return undefined;
+    return {
+      id: product.id,
+      title: product.title,
+      description: product.description,
+      categoryId: product.category.id,
+      categoryName: product.category.name,
+      priceCents: Math.min(...skuAvailables.map((sku: any) => sku.priceCents)),
+      available: skuAvailables.reduce((total: number, sku: any) => total + sku.available, 0),
+      skuAvailables,
+    };
+  }
+
+  private async _ensureCategoryExists(categoryId: TableIdentity) {
+    if (!(await this.scope.model.category.getById(categoryId))) {
+      this.app.throw(404, 'Product category not found');
+    }
+  }
+}

package/vona/src/suite/a-commerce/modules/commerce-catalog/src/service/sku.ts

@@ -0,0 +1,76 @@
+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 { DtoSkuCreate } from '../dto/skuCreate.tsx';
+import type { DtoSkuSelectRes } from '../dto/skuSelectRes.tsx';
+import type { DtoSkuUpdate } from '../dto/skuUpdate.tsx';
+import type { DtoSkuView } from '../dto/skuView.tsx';
+import type { EntitySku } from '../entity/sku.tsx';
+import type { ModelSku } from '../model/sku.ts';
+
+const allowedLifecycleTransitions: Record<EntitySku['lifecycle'], EntitySku['lifecycle'][]> = {
+  draft: ['active', 'archived'],
+  active: ['inactive', 'archived'],
+  inactive: ['active', 'archived'],
+  archived: [],
+};
+
+@Service()
+export class ServiceSku extends BeanBase {
+  async create(sku: DtoSkuCreate): Promise<EntitySku> {
+    await this._ensureProductExists(sku.productId);
+    await this._ensureCodeAvailable(sku.code);
+    return await this.scope.model.sku.insert(sku);
+  }
+
+  async select(params?: IQueryParams<ModelSku>): Promise<DtoSkuSelectRes> {
+    return await this.scope.model.sku.selectAndCount(params);
+  }
+
+  async view(id: TableIdentity): Promise<DtoSkuView | undefined> {
+    return await this.scope.model.sku.getById(id);
+  }
+
+  @Core.transaction({ isolationLevel: 'SERIALIZABLE' })
+  async update(id: TableIdentity, sku: DtoSkuUpdate) {
+    if (sku.lifecycle !== undefined) {
+      const currentSku = await this.scope.model.sku.getByIdForUpdate(id);
+      if (!currentSku) {
+        this.app.throw(404, 'SKU not found');
+      }
+      if (
+        sku.lifecycle !== currentSku.lifecycle &&
+        !allowedLifecycleTransitions[currentSku.lifecycle].includes(sku.lifecycle)
+      ) {
+        this.app.throw(
+          409,
+          `cannot transition SKU lifecycle from ${currentSku.lifecycle} to ${sku.lifecycle}`,
+        );
+      }
+    }
+    if (sku.productId !== undefined) await this._ensureProductExists(sku.productId);
+    if (sku.code) await this._ensureCodeAvailable(sku.code, id);
+    return await this.scope.model.sku.updateById(id, sku);
+  }
+
+  async delete(id: TableIdentity) {
+    return await this.scope.model.sku.deleteById(id);
+  }
+
+  private async _ensureProductExists(productId: TableIdentity) {
+    if (!(await this.scope.model.product.getById(productId))) {
+      this.app.throw(404, 'SKU product not found');
+    }
+  }
+
+  private async _ensureCodeAvailable(code: string, excludedId?: TableIdentity) {
+    const sku = await this.scope.model.sku.get({ code });
+    if (sku && String(sku.id) !== String(excludedId)) {
+      this.app.throw(409, `SKU code already exists: ${code}`);
+    }
+  }
+}