@revenexx/cover 0.1.18 → 0.1.20

package/app/components/layout/header/LocaleSwitcher.vue

@@ -11,7 +11,7 @@ const { icon } = useIcons();
 const { t, locale, locales } = useI18n();
 const switchLocalePath = useSwitchLocalePath();
 const { markets } = useMarkets();
-const { market, setMarket, region, currencySymbol } = useLocalePreferences(markets);
+const { market, setMarket, region, currencies, currency, currencySymbol, setCurrency } = useLocalePreferences(markets);
 
 const open = ref(false);
 
@@ -44,6 +44,9 @@ async function onLanguageChange(code: string): Promise<void> {
 	}
 }
 
+const currencyItems = computed(() =>
+	currencies.value.map(code => ({ code, name: code, active: code === currency.value })));
+
 async function onMarketChange(code: string): Promise<void> {
 	setMarket(code);
 	// The market may not offer the current language — fall back to its first.
@@ -51,6 +54,18 @@ async function onMarketChange(code: string): Promise<void> {
 	if (fallback && !languageItems.value.some(item => item.active)) {
 		await navigateTo(fallback.to);
 	}
+	// The market may not trade in the current currency — re-resolve prices.
+	reloadNuxtApp({ ttl: 0 });
+}
+
+function onCurrencyChange(code: string): void {
+	if (code === currency.value) {
+		return;
+	}
+	setCurrency(code);
+	// Re-SSR so the catalog, cart and checkout all re-price in the new
+	// currency (prices come from the API, keyed by the currency cookie).
+	reloadNuxtApp({ ttl: 0 });
 }
 
 /** The trigger states the full current selection, e.g. "Deutschland (Deutsch) in €". */
@@ -108,8 +123,24 @@ const triggerLabel = computed(() =>
 					/>
 				</UFormField>
 
-				<!-- Currency: defined by the market -->
-				<div class="flex items-center justify-between text-sm">
+				<!-- Currency: chosen within the currencies the market trades in -->
+				<UFormField
+					v-if="currencyItems.length > 1"
+					:label="t('topbar.localePanel.currency')"
+				>
+					<USelect
+						:model-value="currency"
+						value-key="code"
+						label-key="name"
+						:items="currencyItems"
+						class="w-full"
+						@update:model-value="(code: string) => onCurrencyChange(code)"
+					/>
+				</UFormField>
+				<div
+					v-else
+					class="flex items-center justify-between text-sm"
+				>
 					<span class="text-muted">{{ t('topbar.localePanel.currency') }}</span>
 					<span class="font-medium">{{ currencySymbol }}</span>
 				</div>

package/app/composables/useLocalePreferences.ts

@@ -4,10 +4,11 @@ import type { ShopMarket } from "../interfaces/market";
 
 /**
  * Market-driven locale preferences: the shop's markets (markets app) carry
- * region, currency and the offered locales — the selector picks a market,
- * language stays an independent choice within the market's locales
- * (Smashing Magazine, "Designing A Better Language Selector"). Persisted
- * as a cookie so SSR renders the same selection.
+ * region, the offered locales and the currencies the market trades in — the
+ * selector picks a market, while language and currency stay independent
+ * choices within the market's options (Smashing Magazine, "Designing A Better
+ * Language Selector"). All three persist as cookies so SSR renders the same
+ * selection and the BFF resolves prices in the chosen currency.
  */
 
 const CURRENCY_SYMBOLS: Record<string, string> = {
@@ -22,6 +23,12 @@ export function useLocalePreferences(markets: Ref<ShopMarket[]>) {
 		default: () => "",
 		watch: true,
 	});
+	// Read server-side by the BFF (resolveSelectedCurrency) to price the
+	// catalog, cart and order in the buyer's currency.
+	const currencyCode = useCookie<string>("cover-currency", {
+		default: () => "",
+		watch: true,
+	});
 
 	const market = computed<ShopMarket | null>(() => {
 		if (!markets.value.length) {
@@ -38,8 +45,33 @@ export function useLocalePreferences(markets: Ref<ShopMarket[]>) {
 	};
 
 	const region = computed(() => market.value?.name ?? "");
-	const currency = computed(() => market.value?.currency ?? "EUR");
+
+	/** The currencies the active market offers (falls back to its base currency). */
+	const currencies = computed<string[]>(() => {
+		const offered = market.value?.currencies?.map(c => c.code) ?? [];
+		if (offered.length) {
+			return offered;
+		}
+		return market.value?.currency ? [market.value.currency] : ["EUR"];
+	});
+
+	/** The market's default currency — initial choice and fallback. */
+	const defaultCurrency = computed(() => {
+		const flagged = market.value?.currencies?.find(c => c.isDefault)?.code;
+		return flagged ?? market.value?.currency ?? currencies.value[0] ?? "EUR";
+	});
+
+	/** The active currency: the cookie choice if the market offers it, else the default. */
+	const currency = computed(() => {
+		const chosen = currencyCode.value;
+		return chosen && currencies.value.includes(chosen) ? chosen : defaultCurrency.value;
+	});
+
 	const currencySymbol = computed(() => CURRENCY_SYMBOLS[currency.value] ?? currency.value);
 
-	return { market, setMarket, region, currency, currencySymbol };
+	const setCurrency = (code: string): void => {
+		currencyCode.value = code;
+	};
+
+	return { market, setMarket, region, currencies, currency, defaultCurrency, currencySymbol, setCurrency };
 }

package/app/interfaces/market.ts

@@ -1,6 +1,7 @@
 /**
- * Storefront view of the markets app: a market bundles currency and
- * locales (language + country); the locale selector is driven by this.
+ * Storefront view of the markets app: a market bundles its base currency,
+ * locales (language + country) and the currencies it trades in; the locale
+ * selector is driven by this.
  */
 export interface ShopMarketLocale {
 	/** BCP-47 code, e.g. "de-DE". */
@@ -12,13 +13,25 @@ export interface ShopMarketLocale {
 	isDefault: boolean;
 }
 
+export interface ShopMarketCurrency {
+	/** ISO 4217 code, e.g. "EUR". */
+	code: string;
+	isDefault: boolean;
+}
+
 export interface ShopMarket {
 	id: string;
 	/** Stable market code, e.g. "de". */
 	code: string;
 	name: string;
-	/** ISO 4217, e.g. "EUR". */
+	/** ISO 4217 base currency, e.g. "EUR" — the fallback when none is chosen. */
 	currency: string;
 	isDefault: boolean;
 	locales: ShopMarketLocale[];
+	/**
+	 * The currencies the market trades in (loosely configured in the markets
+	 * app). Empty falls back to the single base `currency`; the selector lets
+	 * the buyer pick one and prices resolve in it.
+	 */
+	currencies: ShopMarketCurrency[];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@revenexx/cover",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "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,90 @@
+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 = {};
+	const currency = resolveSelectedCurrency(event);
+	if (currency) {
+		overrides.currency = currency;
+	}
+
+	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[],
+				...(currency ? { currency } : {}),
+			}) as unknown as { prices: Array<{ product_id: string | null; sku: string | null; tax_rate: number | null; on_request: boolean; unit_price: number | null }> };
+			const itemTaxRates: Record<string, number> = {};
+			const itemUnitPrices: Record<string, number> = {};
+			for (const p of prices) {
+				if (p.tax_rate != null) {
+					if (p.product_id) itemTaxRates[p.product_id] = p.tax_rate;
+					if (p.sku) itemTaxRates[p.sku] = p.tax_rate;
+				}
+				// Re-price in the resolved currency; on-request items keep the
+				// client price (the cart shows them as quote positions).
+				if (!p.on_request && p.unit_price != null) {
+					if (p.product_id) itemUnitPrices[p.product_id] = p.unit_price;
+					if (p.sku) itemUnitPrices[p.sku] = p.unit_price;
+				}
+			}
+			if (Object.keys(itemTaxRates).length) {
+				overrides.itemTaxRates = itemTaxRates;
+			}
+			if (Object.keys(itemUnitPrices).length) {
+				overrides.itemUnitPrices = itemUnitPrices;
+			}
+		}
+		catch (err) {
+			getLogService().error("Cart item price/tax resolution failed", apiErrorContext(err));
+		}
+	}
+
+	if (resolveShippingServiceKey(event) === "api") {
+		const method = body.deliveryMethod ?? "standard";
+		try {
+			const { rates } = await useRevenexxSdk().shipping.shippingRates({
+				orderValue: subtotal,
+				country: "",
+				...(currency ? { currency } : {}),
+			}) 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 +97,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 && !overrides.itemUnitPrices && !overrides.currency) {
+			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

@@ -128,6 +128,11 @@ export default defineEventHandler(async (event) => {
 			throw createError({ status: 422, message: addressError });
 		}
 
+		// The buyer's chosen currency (locale selector cookie) — forwarded to
+		// every resolve so the order is priced, shipped and charged in one
+		// currency. Undefined → the apps fall back to their EUR price lists.
+		const selectedCurrency = resolveSelectedCurrency(event);
+
 		const liveShipping = resolveShippingServiceKey(event) === "api";
 		if (
 			!liveShipping
@@ -174,6 +179,7 @@ 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 ?? ""),
+					...(selectedCurrency ? { currency: selectedCurrency } : {}),
 				}) as unknown as { rates: Array<{ code: string; price: number; tax_rate: number | null }> };
 				const rate = rates.find(r => r.code === body.deliveryMethod);
 				if (!rate) {
@@ -224,26 +230,35 @@ export default defineEventHandler(async (event) => {
 				// 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>();
+				const itemPrice = 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 }> };
+						...(selectedCurrency ? { currency: selectedCurrency } : {}),
+					}) as unknown as { prices: Array<{ product_id: string | null; sku: string | null; tax_rate: number | null; on_request: boolean; unit_price: 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);
+						if (p.tax_rate != null) {
+							if (p.product_id) itemRate.set(p.product_id, p.tax_rate);
+							if (p.sku) itemRate.set(p.sku, p.tax_rate);
+						}
+						// Re-price in the resolved currency (the orders app is the SoR
+						// for totals, but it must be fed prices in the buyer's currency).
+						if (!p.on_request && p.unit_price != null) {
+							if (p.product_id) itemPrice.set(p.product_id, p.unit_price);
+							if (p.sku) itemPrice.set(p.sku, p.unit_price);
+						}
 					}
 				}
 				catch (rateErr) {
-					getLogService().error("Item tax-rate resolution failed", apiErrorContext(rateErr));
+					getLogService().error("Item price/tax resolution failed", apiErrorContext(rateErr));
 				}
 
 				const placed = await useRevenexxSdk().orders.ordersPlace({
 					...(contactId ? { contactId } : {}),
 					...(organizationId ? { organizationId } : {}),
-					currency: calculation.currency,
+					currency: selectedCurrency ?? calculation.currency,
 					...(body.orderNumber ? { customerOrderNumber: body.orderNumber } : {}),
 					buyer: user ? { name: user.name, email: user.email } : { email: body.contactEmail ?? null },
 					billingAddress: (billing ?? null) as object,
@@ -262,7 +277,7 @@ export default defineEventHandler(async (event) => {
 						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),
+						unit_price: itemPrice.get(String(item.id)) ?? itemPrice.get(String(item.sku ?? "")) ?? calculation.lines[index]?.unitPrice ?? Number(item.price ?? 0),
 						tax_rate: itemRate.get(String(item.id)) ?? itemRate.get(String(item.sku ?? "")) ?? 0,
 						product: {
 							...(item.image ? { image: String(item.image) } : {}),
@@ -307,7 +322,7 @@ export default defineEventHandler(async (event) => {
 					methodCode: payment.method,
 					// 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,
+					currency: selectedCurrency ?? calculation.currency,
 					country,
 					orderRef: orderId,
 					idempotencyKey: body.checkoutSessionToken,

package/server/data/markets.json

@@ -8,6 +8,10 @@
 		"locales": [
 			{ "code": "de-DE", "language": "de", "country": "DE", "isDefault": true },
 			{ "code": "en-GB", "language": "en", "country": "GB", "isDefault": false }
+		],
+		"currencies": [
+			{ "code": "EUR", "isDefault": true },
+			{ "code": "USD", "isDefault": false }
 		]
 	},
 	{
@@ -19,6 +23,10 @@
 		"locales": [
 			{ "code": "de-CH", "language": "de", "country": "CH", "isDefault": true },
 			{ "code": "en-GB", "language": "en", "country": "GB", "isDefault": false }
+		],
+		"currencies": [
+			{ "code": "CHF", "isDefault": true },
+			{ "code": "EUR", "isDefault": false }
 		]
 	}
 ]

package/server/interfaces/cartCalculation.ts

@@ -1,6 +1,27 @@
 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 {
+	/** The currency prices/shipping resolved in — becomes the cart currency. */
+	currency?: string;
+	/** 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>;
+	/**
+	 * Per-item unit price (in the resolved currency) keyed by product id or
+	 * sku. Re-prices the cart in the chosen currency instead of trusting the
+	 * client-supplied price — the dumb BFF reads prices from the prices app.
+	 */
+	itemUnitPrices?: 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 +34,6 @@ export interface ICartCalculationService {
 		request: CartCalculationRequest,
 		context: B2BContext,
 		locale: string,
+		overrides?: CartCalculationOverrides,
 	): Promise<CartCalculation>;
 }

package/server/services/ApiMarketService.ts

@@ -1,4 +1,4 @@
-import type { ShopMarket, ShopMarketLocale } from "../../app/interfaces/market";
+import type { ShopMarket, ShopMarketCurrency, ShopMarketLocale } from "../../app/interfaces/market";
 import type { IMarketService } from "../interfaces/market";
 
 interface ApiMarketRow {
@@ -19,6 +19,19 @@ interface ApiLocaleRow {
 	position: number;
 }
 
+interface ApiCurrencyRow {
+	code: string;
+	is_default: boolean;
+	position: number;
+}
+
+// The markets app's /context response. Typed locally because the pinned SDK
+// (0.0.5) predates the `currencies` field — at runtime the app returns it.
+interface ApiMarketContext {
+	locales?: ApiLocaleRow[];
+	currencies?: ApiCurrencyRow[];
+}
+
 interface ApiListPage<T> {
 	items: T[];
 }
@@ -31,8 +44,9 @@ const cache = new Map<string, { markets: ShopMarket[]; loadedAt: number }>();
 
 /**
  * Live markets via the public revenexx API (markets app):
- * GET /v1/markets + each market's locales. Cached briefly — the selector
- * renders on every page and markets change rarely.
+ * GET /v1/markets + each market's /context (locales + currencies in one
+ * call). Cached briefly — the selector renders on every page and markets
+ * change rarely.
  */
 export class ApiMarketService implements IMarketService {
 	async listMarkets(): Promise<ShopMarket[]> {
@@ -49,21 +63,25 @@ export class ApiMarketService implements IMarketService {
 			.sort((a, b) => a.position - b.position || a.code.localeCompare(b.code));
 
 		const markets = await Promise.all(active.map(async (market): Promise<ShopMarket> => {
-			const { items: locales } = await sdk.markets.marketsLocalesList({ marketId: market.id }) as unknown as ApiListPage<ApiLocaleRow>;
+			const context = await sdk.markets.marketsContext({ id: market.id }) as unknown as ApiMarketContext;
+			const locales = (context.locales ?? []).slice().sort((a, b) => a.position - b.position);
+			const currencies = (context.currencies ?? []).slice().sort((a, b) => a.position - b.position);
 			return {
 				id: market.id,
 				code: market.code,
 				name: market.name,
 				currency: market.currency,
 				isDefault: market.is_default,
-				locales: locales
-					.sort((a, b) => a.position - b.position)
-					.map((locale): ShopMarketLocale => ({
-						code: locale.code,
-						language: locale.language,
-						country: locale.country,
-						isDefault: locale.is_default,
-					})),
+				locales: locales.map((locale): ShopMarketLocale => ({
+					code: locale.code,
+					language: locale.language,
+					country: locale.country,
+					isDefault: locale.is_default,
+				})),
+				currencies: currencies.map((currency): ShopMarketCurrency => ({
+					code: currency.code,
+					isDefault: currency.is_default,
+				})),
 			};
 		}));
 

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>) =>
@@ -121,7 +122,10 @@ export class MockCartCalculationService implements ICartCalculationService {
 			}
 
 			const labelCode = PRICE_LABELS[item.id];
-			const unitPrice = labelCode ? 0 : tieredUnitPrice(item, quantity);
+			// Live mode re-prices in the resolved currency (prices app); mock
+			// mode uses the cart item's tier price.
+			const liveUnitPrice = overrides?.itemUnitPrices?.[item.id] ?? overrides?.itemUnitPrices?.[item.sku ?? ""];
+			const unitPrice = labelCode ? 0 : (liveUnitPrice ?? tieredUnitPrice(item, quantity));
 			const lineTotal = r2(unitPrice * quantity);
 
 			const surcharges = !labelCode && SURCHARGE_SKU_PREFIXES.some(p => (item.sku ?? "").startsWith(p))
@@ -198,9 +202,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 +222,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;
@@ -290,7 +308,7 @@ export class MockCartCalculationService implements ICartCalculationService {
 		];
 
 		return {
-			currency: "EUR",
+			currency: overrides?.currency ?? "EUR",
 			lines,
 			totals,
 			orderable,

package/server/utils/currency.ts

@@ -0,0 +1,20 @@
+import type { H3Event } from "h3";
+
+/** Cookie the storefront's locale selector persists the chosen currency in. */
+export const CURRENCY_COOKIE_NAME = "cover-currency";
+
+/**
+ * The buyer's chosen currency for server-side price resolution. Read from the
+ * cookie the locale selector sets — the BFF forwards it to the prices and
+ * shipping apps so the catalog, cart and order all resolve in one currency.
+ * Undefined → the prices app falls back to the price list's currency (EUR),
+ * so the shop works before any choice is made.
+ */
+export function resolveSelectedCurrency(event: H3Event): string | undefined {
+	const raw = getCookie(event, CURRENCY_COOKIE_NAME);
+	if (!raw) {
+		return undefined;
+	}
+	const code = raw.trim().toUpperCase();
+	return /^[A-Z]{3}$/.test(code) ? code : undefined;
+}

package/server/utils/livePrices.ts

@@ -62,9 +62,11 @@ export async function enrichProductsWithLivePrices(event: H3Event, products: Pro
 	if (products.length === 0) {
 		return products;
 	}
+	const currency = resolveSelectedCurrency(event);
 	const { prices } = await useRevenexxSdk().prices.pricesResolve({
 		items: products.map(p => ({ product_id: p.id, sku: p.sku, quantity: 1 })) as Models.PriceResolveItem[],
 		...priceContext(event),
+		...(currency ? { currency } : {}),
 	}) as unknown as { prices: ResolvedPrice[] };
 
 	const byKey = new Map<string, ResolvedPrice>();
@@ -85,9 +87,11 @@ export async function enrichDetailWithLivePrices(event: H3Event, detail: Product
 	if (!product) {
 		return detail;
 	}
+	const currency = resolveSelectedCurrency(event);
 	const { prices } = await useRevenexxSdk().prices.pricesResolve({
 		items: [{ product_id: product.id, sku: product.sku, quantity: 1 }] as Models.PriceResolveItem[],
 		...priceContext(event),
+		...(currency ? { currency } : {}),
 	}) as unknown as { prices: ResolvedPrice[] };
 	const resolved = prices[0];
 	return { ...detail, prices: resolved ? toPriceMap(resolved) : [] };