@revenexx/cover 0.1.18 → 0.1.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@revenexx/cover",
-  "version": "0.1.18",
+  "version": "0.1.19",
   "description": "Cover \u2014 revenexx design system for Nuxt. Distributed as a Nuxt layer: generic UI components, theming tokens and stores shared by the demo shop, custom storefronts and the Blokkli theme.",
   "type": "module",
   "main": "./nuxt.config.ts",

package/server/api/cart/calculate.post.ts

@@ -1,9 +1,73 @@
+import type { H3Event } from "h3";
+import type { Models } from "@revenexx/sdk";
+
 import type { CartCalculationRequest } from "../../../app/interfaces/cart-calculation";
+import type { CartCalculationOverrides } from "../../interfaces/cartCalculation";
+
+/**
+ * Resolve the pricing inputs the BFF must not invent itself — per-item tax
+ * rates (prices app) and the shipping fee + its tax rate (shipping app) — so
+ * the cart/checkout summary matches the totals the orders app will store.
+ * Best-effort: any failure leaves the demo profile to fill in (mock fees).
+ */
+async function resolveLiveOverrides(
+	event: H3Event,
+	body: CartCalculationRequest,
+	subtotal: number,
+): Promise<CartCalculationOverrides> {
+	const overrides: CartCalculationOverrides = {};
+
+	if (resolvePriceServiceKey(event) === "api" && body.items.length) {
+		try {
+			const { prices } = await useRevenexxSdk().prices.pricesResolve({
+				items: body.items.map(it => ({
+					product_id: String(it.id),
+					sku: it.sku ? String(it.sku) : undefined,
+					quantity: Number(it.quantity) || 1,
+				})) as Models.PriceResolveItem[],
+			}) as unknown as { prices: Array<{ product_id: string | null; sku: string | null; tax_rate: number | null }> };
+			const itemTaxRates: Record<string, number> = {};
+			for (const p of prices) {
+				if (p.tax_rate == null) continue;
+				if (p.product_id) itemTaxRates[p.product_id] = p.tax_rate;
+				if (p.sku) itemTaxRates[p.sku] = p.tax_rate;
+			}
+			if (Object.keys(itemTaxRates).length) {
+				overrides.itemTaxRates = itemTaxRates;
+			}
+		}
+		catch (err) {
+			getLogService().error("Cart item tax-rate resolution failed", apiErrorContext(err));
+		}
+	}
+
+	if (resolveShippingServiceKey(event) === "api") {
+		const method = body.deliveryMethod ?? "standard";
+		try {
+			const { rates } = await useRevenexxSdk().shipping.shippingRates({
+				orderValue: subtotal,
+				country: "",
+			}) as unknown as { rates: Array<{ code: string; price: number; tax_rate: number | null }> };
+			const rate = rates.find(r => r.code === method) ?? rates[0];
+			if (rate) {
+				overrides.shipping = { price: rate.price, taxRate: Number(rate.tax_rate ?? 0) };
+			}
+		}
+		catch (err) {
+			getLogService().error("Cart shipping-rate resolution failed", apiErrorContext(err));
+		}
+	}
+
+	return overrides;
+}
 
 /**
  * Calculates the cart: per-line pricing, the ordered totals block, line
  * hints, orderability and triggered spending limits. Works for guests
  * (organization defaults) and logged-in users (role, limits, cost centers).
+ *
+ * Live mode enriches the totals with API-resolved item tax rates and the
+ * shipping fee so the summary equals the order the orders app will store.
  */
 export default defineEventHandler(async (event) => {
 	const body = await readBody<CartCalculationRequest>(event);
@@ -16,7 +80,21 @@ export default defineEventHandler(async (event) => {
 
 	try {
 		const context = await getB2BContextService(event).getContext(user?.$id ?? null, user?.role ?? null);
-		return await getCartCalculationService().calculate(body, context, locale);
+		const service = getCartCalculationService();
+
+		// First pass establishes the subtotal the shipping app prices against;
+		// a second pass folds the live fee + tax rates into the totals. Mock
+		// mode skips the round-trips entirely.
+		const base = await service.calculate(body, context, locale);
+		if (resolvePriceServiceKey(event) !== "api" && resolveShippingServiceKey(event) !== "api") {
+			return base;
+		}
+		const subtotal = base.totals.find(row => row.key === "subtotal")?.amount ?? 0;
+		const overrides = await resolveLiveOverrides(event, body, subtotal);
+		if (!overrides.shipping && !overrides.itemTaxRates) {
+			return base;
+		}
+		return await service.calculate(body, context, locale, overrides);
 	}
 	catch (err) {
 		getLogService().error("Service error: cart/calculate", toErrorContext(err));

package/server/interfaces/cartCalculation.ts

@@ -1,6 +1,19 @@
 import type { B2BContext } from "../../app/interfaces/b2b";
 import type { CartCalculation, CartCalculationRequest } from "../../app/interfaces/cart-calculation";
 
+/**
+ * Server-resolved pricing inputs the BFF must NOT compute itself — they come
+ * from the API (prices + shipping apps) so the cart/checkout summary matches
+ * the totals the orders app will store. Resolved per request in the cart
+ * endpoint; absent in mock mode (then the demo profile fills in).
+ */
+export interface CartCalculationOverrides {
+	/** Live shipping fee + its tax rate for the chosen method. */
+	shipping?: { price: number; taxRate: number };
+	/** Per-item tax rate (percent) keyed by product id or sku, from prices.resolve. */
+	itemTaxRates?: Record<string, number>;
+}
+
 /**
  * Service contract for cart calculation. ERP-backed implementations send
  * the cart downstream and map the document response into the generic
@@ -13,5 +26,6 @@ export interface ICartCalculationService {
 		request: CartCalculationRequest,
 		context: B2BContext,
 		locale: string,
+		overrides?: CartCalculationOverrides,
 	): Promise<CartCalculation>;
 }

package/server/services/MockCartCalculationService.ts

@@ -10,7 +10,7 @@ import type {
 } from "../../app/interfaces/cart-calculation";
 import type { CartItem } from "../../app/interfaces/cart-item";
 
-import type { ICartCalculationService } from "../interfaces/cartCalculation";
+import type { CartCalculationOverrides, ICartCalculationService } from "../interfaces/cartCalculation";
 
 /* ------------------------------------------------------------------ */
 /* Demo rule tables — stand-ins for ERP master data                    */
@@ -86,6 +86,7 @@ export class MockCartCalculationService implements ICartCalculationService {
 		request: CartCalculationRequest,
 		context: B2BContext,
 		locale: string,
+		overrides?: CartCalculationOverrides,
 	): Promise<CartCalculation> {
 		await preloadLocaleNamespaces(locale, ["cart"]);
 		const t = (key: string, params?: Record<string, string | number>) =>
@@ -198,9 +199,14 @@ export class MockCartCalculationService implements ICartCalculationService {
 			});
 		}
 
-		const shipping = (request.deliveryMethod ?? "standard") === "express"
-			? EXPRESS_SHIPPING_FEE
-			: subtotal >= FREE_SHIPPING_THRESHOLD ? 0 : STANDARD_SHIPPING_FEE;
+		// Live mode: the shipping fee comes from the shipping app (resolved in
+		// the cart endpoint), so the summary matches the order. Mock mode keeps
+		// the demo profile's flat/free logic.
+		const shipping = overrides?.shipping
+			? r2(overrides.shipping.price)
+			: (request.deliveryMethod ?? "standard") === "express"
+				? EXPRESS_SHIPPING_FEE
+				: subtotal >= FREE_SHIPPING_THRESHOLD ? 0 : STANDARD_SHIPPING_FEE;
 		totals.push({ key: "shipping", label: t("calc.totals.shipping"), amount: shipping, alwaysVisible: true });
 
 		// Taxable base per rate: line totals + line surcharges, discount applied
@@ -213,14 +219,23 @@ export class MockCartCalculationService implements ICartCalculationService {
 			if (line.priceLabel) {
 				continue;
 			}
-			const rate = normalizeRate(item.taxRate);
+			// Prefer the API-resolved rate (prices app, by id or sku); fall back
+			// to the rate carried on the cart item.
+			const liveRate = overrides?.itemTaxRates?.[item.id] ?? overrides?.itemTaxRates?.[item.sku ?? ""];
+			const rate = normalizeRate(liveRate ?? item.taxRate);
 			const lineSurcharge = line.surcharges.reduce((s, c) => s + c.amountPerUnit * effectiveQty(line), 0);
 			const base = (line.lineTotal * discountFactor) + lineSurcharge;
 			basePerRate.set(rate, (basePerRate.get(rate) ?? 0) + base);
 		}
-		const docCharges = minOrderCharge + shipping;
-		if (docCharges > 0) {
-			basePerRate.set(DEFAULT_TAX_RATE, (basePerRate.get(DEFAULT_TAX_RATE) ?? 0) + docCharges);
+		// The min-order charge is a BFF construct taxed at the default rate;
+		// shipping (a Nebenleistung) is taxed at the rate the shipping app
+		// resolved for the method — in mock mode both fall to the default.
+		if (minOrderCharge > 0) {
+			basePerRate.set(DEFAULT_TAX_RATE, (basePerRate.get(DEFAULT_TAX_RATE) ?? 0) + minOrderCharge);
+		}
+		if (shipping > 0) {
+			const shippingRate = overrides?.shipping ? normalizeRate(overrides.shipping.taxRate) : DEFAULT_TAX_RATE;
+			basePerRate.set(shippingRate, (basePerRate.get(shippingRate) ?? 0) + shipping);
 		}
 
 		let taxSum = 0;