@revenexx/cover 0.1.17 → 0.1.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@revenexx/cover",
-  "version": "0.1.17",
+  "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/api/orders/index.post.ts

@@ -163,7 +163,10 @@ export default defineEventHandler(async (event) => {
 		// Live shipping: the chosen method must be a real rate for this
 		// buyer context; its price replaces the demo calculation's shipping
 		// line in the order totals and the amount the payment is created over.
-		let liveShippingAdjustment = 0;
+		// The chosen live shipping rate carries its own price AND tax_rate
+		// (resolved by the shipping app from markets.tax_classes). The order app
+		// taxes shipping with it — the BFF computes no tax itself.
+		let liveShippingRate: { price: number; tax_rate: number } | null = null;
 		if (liveShipping && body.deliveryMethod) {
 			const address = body.address as Record<string, unknown> | undefined;
 			try {
@@ -171,13 +174,12 @@ export default defineEventHandler(async (event) => {
 					orderValue: calculation.totals.find(row => row.key === "subtotal")?.amount
 						?? calculation.totals.find(row => row.key === "total")?.amount ?? 0,
 					country: String(address?.country ?? ""),
-				}) as unknown as { rates: Array<{ code: string; price: number }> };
+				}) as unknown as { rates: Array<{ code: string; price: number; tax_rate: number | null }> };
 				const rate = rates.find(r => r.code === body.deliveryMethod);
 				if (!rate) {
 					throw createError({ status: 422, message: `Delivery method '${body.deliveryMethod}' is not available for this order` });
 				}
-				const mockShipping = calculation.totals.find(row => row.key === "shipping")?.amount ?? 0;
-				liveShippingAdjustment = rate.price - mockShipping;
+				liveShippingRate = { price: rate.price, tax_rate: Number(rate.tax_rate ?? 0) };
 			}
 			catch (err) {
 				if (isError(err)) {
@@ -196,6 +198,9 @@ export default defineEventHandler(async (event) => {
 		// approvals domain is deliberately not part of OM phase 1.
 		const liveOrders = resolveOrderServiceKey(event) === "api" && blockingApprovals.length === 0;
 		let liveOrderUuid: string | null = null;
+		// The placed order's grand_total (orders app = source of truth) drives
+		// the payment amount, so payment and order can never diverge.
+		let liveOrderTotal: number | null = null;
 		if (liveOrders) {
 			const address = body.address as Record<string, unknown>;
 			const billing = address?.billingAddressSameAsShipping === false
@@ -213,6 +218,28 @@ export default defineEventHandler(async (event) => {
 				// order history, filtered strictly by contact_id).
 				const contactId = refs.contact_id ?? user?.contactId;
 				const organizationId = refs.organization_id ?? user?.organizationId;
+
+				// Per-item tax rate from the prices app (same resolve that prices
+				// the storefront), not a BFF constant — one bulk call. The orders
+				// app then taxes items + shipping and computes grand_total itself.
+				const orderItems = body.items as Array<Record<string, unknown>>;
+				const itemRate = new Map<string, number>();
+				try {
+					const { prices: resolved } = await useRevenexxSdk().prices.pricesResolve({
+						items: orderItems.map(it => ({ product_id: String(it.id), sku: it.sku ? String(it.sku) : undefined, quantity: Number(it.quantity) || 1 })) as Models.PriceResolveItem[],
+						...(contactId ? { contactId } : {}),
+						...(organizationId ? { organizationId } : {}),
+					}) as unknown as { prices: Array<{ product_id: string | null; sku: string | null; tax_rate: number | null }> };
+					for (const p of resolved) {
+						if (p.tax_rate == null) continue;
+						if (p.product_id) itemRate.set(p.product_id, p.tax_rate);
+						if (p.sku) itemRate.set(p.sku, p.tax_rate);
+					}
+				}
+				catch (rateErr) {
+					getLogService().error("Item tax-rate resolution failed", apiErrorContext(rateErr));
+				}
+
 				const placed = await useRevenexxSdk().orders.ordersPlace({
 					...(contactId ? { contactId } : {}),
 					...(organizationId ? { organizationId } : {}),
@@ -222,20 +249,21 @@ export default defineEventHandler(async (event) => {
 					billingAddress: (billing ?? null) as object,
 					shippingAddress: (address ?? null) as object,
 					payment: { method: payment.method },
+					// Shipping price + tax_rate from the shipping app; the orders
+					// app taxes it and computes grand_total — the BFF sends NO
+					// grand_total (orders is the single source of truth).
 					shipping: {
 						method: body.deliveryMethod ?? "standard",
-						price: Math.max(0, (shippingRow?.amount ?? 0) + liveShippingAdjustment),
+						price: Math.max(0, liveShippingRate?.price ?? shippingRow?.amount ?? 0),
+						tax_rate: liveShippingRate?.tax_rate ?? 0,
 					},
-					// The order carries what the customer saw (and the payment
-					// charges): the checkout calculation's total.
-					grandTotal: Math.max(0, Math.round(((totalRow?.amount ?? 0) + liveShippingAdjustment) * 100) / 100),
-					items: (body.items as Array<Record<string, unknown>>).map((item, index) => ({
+					items: orderItems.map((item, index) => ({
 						product_id: String(item.id),
 						sku: String(item.sku ?? "") || undefined,
 						name: String(item.name ?? item.sku ?? item.id),
 						quantity: calculation.lines[index]?.adjustedQuantity ?? Number(item.quantity),
 						unit_price: calculation.lines[index]?.unitPrice ?? Number(item.price ?? 0),
-						tax_rate: 19,
+						tax_rate: itemRate.get(String(item.id)) ?? itemRate.get(String(item.sku ?? "")) ?? 0,
 						product: {
 							...(item.image ? { image: String(item.image) } : {}),
 							...(item.categorySlug ? { categorySlug: String(item.categorySlug) } : {}),
@@ -248,9 +276,10 @@ export default defineEventHandler(async (event) => {
 						...(body.partialDelivery !== undefined ? { partial_delivery: body.partialDelivery } : {}),
 						...(body.requestedDate ? { requested_date: body.requestedDate } : {}),
 					},
-				}) as unknown as { id: string; number: string };
+				}) as unknown as { id: string; number: string; grand_total?: number };
 				orderId = placed.number;
 				liveOrderUuid = placed.id;
+				liveOrderTotal = typeof placed.grand_total === "number" ? placed.grand_total : null;
 			}
 			catch (err) {
 				if (err instanceof RevenexxException && (err.code === 400 || err.code === 422)) {
@@ -276,7 +305,8 @@ export default defineEventHandler(async (event) => {
 			try {
 				const created = await useRevenexxSdk().payments.paymentsCreate({
 					methodCode: payment.method,
-					amount: Math.max(0, Math.round(((totalRow?.amount ?? 0) + liveShippingAdjustment) * 100) / 100),
+					// Charge exactly what the orders app computed (incl. shipping tax).
+					amount: Math.max(0, Math.round((liveOrderTotal ?? totalRow?.amount ?? 0) * 100) / 100),
 					currency: calculation.currency,
 					country,
 					orderRef: orderId,

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;