@labdigital/commercetools-mock 2.59.0 → 2.60.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@labdigital/commercetools-mock",
-  "version": "2.59.0",
+  "version": "2.60.0",
   "license": "MIT",
   "author": "Michael van Tellingen",
   "type": "module",

package/src/lib/tax.test.ts

@@ -0,0 +1,119 @@
+import type {
+	TaxCategory,
+	TaxRate,
+	TaxedItemPrice,
+} from "@commercetools/platform-sdk";
+import { describe, expect, test } from "vitest";
+import {
+	calculateTaxTotals,
+	calculateTaxedPrice,
+	calculateTaxedPriceFromRate,
+} from "~src/lib/tax";
+
+const money = (centAmount: number) => ({
+	type: "centPrecision" as const,
+	currencyCode: "EUR",
+	centAmount,
+	fractionDigits: 2,
+});
+
+const createTaxedItemPrice = (net: number, gross: number, rate = 0.21) => ({
+	totalNet: money(net),
+	totalGross: money(gross),
+	totalTax: money(gross - net),
+	taxPortions: [
+		{
+			rate,
+			amount: money(gross - net),
+		},
+	],
+});
+
+describe("tax helpers", () => {
+	test("calculateTaxTotals aggregates line, custom, and shipping taxes", () => {
+		const lineTaxed = createTaxedItemPrice(1000, 1210);
+		const customTaxed = createTaxedItemPrice(500, 605);
+		const shippingTaxed: TaxedItemPrice = createTaxedItemPrice(300, 363);
+
+		const resource = {
+			lineItems: [{ taxedPrice: lineTaxed }] as any,
+			customLineItems: [{ taxedPrice: customTaxed }] as any,
+			shippingInfo: { taxedPrice: shippingTaxed } as any,
+			totalPrice: money(0),
+		};
+
+		const { taxedPrice, taxedShippingPrice } = calculateTaxTotals(resource);
+
+		expect(taxedPrice).toBeDefined();
+		expect(taxedPrice?.totalNet.centAmount).toBe(1000 + 500 + 300);
+		expect(taxedPrice?.totalGross.centAmount).toBe(1210 + 605 + 363);
+		expect(taxedPrice?.totalTax?.centAmount).toBe(210 + 105 + 63);
+		expect(taxedPrice?.taxPortions).toHaveLength(1);
+		expect(taxedPrice?.taxPortions?.[0].amount.centAmount).toBe(378);
+		expect(taxedShippingPrice).toEqual(shippingTaxed);
+	});
+
+	test("calculateTaxedPriceFromRate handles net amounts", () => {
+		const rate: TaxRate = {
+			amount: 0.2,
+			includedInPrice: false,
+			name: "Standard",
+			country: "NL",
+			id: "rate",
+			subRates: [],
+		};
+
+		const taxed = calculateTaxedPriceFromRate(1000, "EUR", rate)!;
+		expect(taxed.totalNet.centAmount).toBe(1000);
+		expect(taxed.totalGross.centAmount).toBe(1200);
+		expect(taxed.totalTax?.centAmount).toBe(200);
+	});
+
+	test("calculateTaxedPriceFromRate handles gross amounts", () => {
+		const rate: TaxRate = {
+			amount: 0.25,
+			includedInPrice: true,
+			name: "Gross",
+			id: "gross",
+			country: "BE",
+			subRates: [],
+		};
+
+		const taxed = calculateTaxedPriceFromRate(1250, "EUR", rate)!;
+		expect(taxed.totalGross.centAmount).toBe(1250);
+		expect(taxed.totalNet.centAmount).toBe(1000);
+		expect(taxed.totalTax?.centAmount).toBe(250);
+	});
+
+	test("calculateTaxedPrice selects matching tax rate from category", () => {
+		const taxCategory: TaxCategory = {
+			id: "tax-cat",
+			version: 1,
+			createdAt: "2024-01-01T00:00:00.000Z",
+			lastModifiedAt: "2024-01-01T00:00:00.000Z",
+			name: "Standard",
+			rates: [
+				{
+					id: "default",
+					amount: 0.1,
+					includedInPrice: false,
+					country: "DE",
+					name: "DE",
+					subRates: [],
+				},
+				{
+					id: "nl",
+					amount: 0.21,
+					includedInPrice: false,
+					country: "NL",
+					name: "NL",
+					subRates: [],
+				},
+			],
+		};
+
+		const taxed = calculateTaxedPrice(1000, taxCategory, "EUR", "NL")!;
+		expect(taxed.totalGross.centAmount).toBe(1210);
+		expect(taxed.totalTax?.centAmount).toBe(210);
+	});
+});

package/src/lib/tax.ts

@@ -0,0 +1,186 @@
+import type {
+	Cart,
+	TaxCategory,
+	TaxPortion,
+	TaxRate,
+	TaxedItemPrice,
+	TaxedPrice,
+} from "@commercetools/platform-sdk";
+import { createCentPrecisionMoney } from "~src/repositories/helpers";
+
+type TaxableResource = Pick<
+	Cart,
+	"lineItems" | "customLineItems" | "shippingInfo" | "totalPrice"
+>;
+
+export const calculateTaxTotals = (
+	resource: TaxableResource,
+): {
+	taxedPrice?: TaxedPrice;
+	taxedShippingPrice?: TaxedItemPrice;
+} => {
+	const taxedItemPrices: TaxedItemPrice[] = [];
+
+	resource.lineItems.forEach((item) => {
+		if (item.taxedPrice) {
+			taxedItemPrices.push(item.taxedPrice);
+		}
+	});
+
+	resource.customLineItems.forEach((item) => {
+		if (item.taxedPrice) {
+			taxedItemPrices.push(item.taxedPrice);
+		}
+	});
+
+	let taxedShippingPrice: TaxedItemPrice | undefined;
+	if (resource.shippingInfo?.taxedPrice) {
+		taxedShippingPrice = resource.shippingInfo.taxedPrice;
+		taxedItemPrices.push(resource.shippingInfo.taxedPrice);
+	}
+
+	if (!taxedItemPrices.length) {
+		return {
+			taxedPrice: undefined,
+			taxedShippingPrice,
+		};
+	}
+
+	const currencyCode = resource.totalPrice.currencyCode;
+	const toMoney = (centAmount: number) =>
+		createCentPrecisionMoney({
+			currencyCode,
+			centAmount,
+		});
+
+	let totalNet = 0;
+	let totalGross = 0;
+	let totalTax = 0;
+
+	const taxPortionsByRate = new Map<
+		string,
+		{ rate: number; name?: string; centAmount: number }
+	>();
+
+	taxedItemPrices.forEach((price) => {
+		totalNet += price.totalNet.centAmount;
+		totalGross += price.totalGross.centAmount;
+		const priceTax = price.totalTax
+			? price.totalTax.centAmount
+			: price.totalGross.centAmount - price.totalNet.centAmount;
+		totalTax += Math.max(priceTax, 0);
+
+		price.taxPortions?.forEach((portion) => {
+			const key = `${portion.rate}-${portion.name ?? ""}`;
+			const existing = taxPortionsByRate.get(key) ?? {
+				rate: portion.rate,
+				name: portion.name,
+				centAmount: 0,
+			};
+			existing.centAmount += portion.amount.centAmount;
+			taxPortionsByRate.set(key, existing);
+		});
+	});
+
+	const taxPortions: TaxPortion[] = Array.from(taxPortionsByRate.values()).map(
+		(portion) => ({
+			rate: portion.rate,
+			name: portion.name,
+			amount: toMoney(portion.centAmount),
+		}),
+	);
+
+	return {
+		taxedPrice: {
+			totalNet: toMoney(totalNet),
+			totalGross: toMoney(totalGross),
+			taxPortions,
+			totalTax: totalTax > 0 ? toMoney(totalTax) : undefined,
+		},
+		taxedShippingPrice,
+	};
+};
+
+export const buildTaxedPriceFromRate = (
+	amount: number,
+	currencyCode: string,
+	taxRate?: TaxRate,
+): TaxedItemPrice | undefined => {
+	if (!taxRate) {
+		return undefined;
+	}
+
+	const toMoney = (centAmount: number) =>
+		createCentPrecisionMoney({
+			type: "centPrecision",
+			currencyCode,
+			centAmount,
+		});
+
+	let netAmount: number;
+	let grossAmount: number;
+	let taxAmount: number;
+
+	if (taxRate.includedInPrice) {
+		grossAmount = amount;
+		taxAmount = Math.round(
+			(grossAmount * taxRate.amount) / (1 + taxRate.amount),
+		);
+		netAmount = grossAmount - taxAmount;
+	} else {
+		netAmount = amount;
+		taxAmount = Math.round(netAmount * taxRate.amount);
+		grossAmount = netAmount + taxAmount;
+	}
+
+	return {
+		totalNet: toMoney(netAmount),
+		totalGross: toMoney(grossAmount),
+		totalTax: taxAmount > 0 ? toMoney(taxAmount) : undefined,
+		taxPortions:
+			taxAmount > 0
+				? [
+						{
+							rate: taxRate.amount,
+							name: taxRate.name,
+							amount: toMoney(taxAmount),
+						},
+					]
+				: [],
+	};
+};
+
+export const calculateTaxedPriceFromRate = (
+	amount: number,
+	currencyCode: string,
+	taxRate?: TaxRate,
+): TaxedItemPrice | undefined =>
+	buildTaxedPriceFromRate(amount, currencyCode, taxRate);
+
+export const calculateTaxedPrice = (
+	amount: number,
+	taxCategory: TaxCategory | undefined,
+	currency: string,
+	country: string | undefined,
+): TaxedPrice | undefined => {
+	if (!taxCategory || !taxCategory.rates.length) {
+		return undefined;
+	}
+
+	const taxRate =
+		taxCategory.rates.find(
+			(rate) => !rate.country || rate.country === country,
+		) || taxCategory.rates[0];
+
+	const taxedItemPrice = buildTaxedPriceFromRate(amount, currency, taxRate);
+	if (!taxedItemPrice) {
+		return undefined;
+	}
+
+	return {
+		totalNet: taxedItemPrice.totalNet,
+		totalGross: taxedItemPrice.totalGross,
+		taxPortions: taxedItemPrice.taxPortions,
+		totalTax: taxedItemPrice.totalTax,
+	};
+};

package/src/repositories/cart/actions.ts

@@ -28,6 +28,7 @@ import type {
 	CartSetDirectDiscountsAction,
 	CartSetLineItemCustomFieldAction,
 	CartSetLineItemCustomTypeAction,
+	CartSetLineItemPriceAction,
 	CartSetLineItemShippingDetailsAction,
 	CartSetLocaleAction,
 	CartSetShippingAddressAction,
@@ -740,6 +741,72 @@ export class CartUpdateHandler
 		}
 	}
 
+	setLineItemPrice(
+		context: RepositoryContext,
+		resource: Writable<Cart>,
+		{ lineItemId, lineItemKey, externalPrice }: CartSetLineItemPriceAction,
+	) {
+		const lineItem = resource.lineItems.find(
+			(x) =>
+				(lineItemId && x.id === lineItemId) ||
+				(lineItemKey && x.key === lineItemKey),
+		);
+
+		if (!lineItem) {
+			throw new CommercetoolsError<GeneralError>({
+				code: "General",
+				message: lineItemKey
+					? `A line item with key '${lineItemKey}' not found.`
+					: `A line item with ID '${lineItemId}' not found.`,
+			});
+		}
+
+		if (!externalPrice && lineItem.priceMode !== "ExternalPrice") {
+			return;
+		}
+
+		if (
+			externalPrice &&
+			externalPrice.currencyCode !== resource.totalPrice.currencyCode
+		) {
+			throw new CommercetoolsError<GeneralError>({
+				code: "General",
+				message: `Currency mismatch. Expected '${resource.totalPrice.currencyCode}' but got '${externalPrice.currencyCode}'.`,
+			});
+		}
+
+		if (externalPrice) {
+			lineItem.priceMode = "ExternalPrice";
+			const priceValue = createTypedMoney(externalPrice);
+
+			lineItem.price = lineItem.price ?? { id: uuidv4() };
+			lineItem.price.value = priceValue;
+		} else {
+			lineItem.priceMode = "Platform";
+
+			const price = selectPrice({
+				prices: lineItem.variant.prices,
+				currency: resource.totalPrice.currencyCode,
+				country: resource.country,
+			});
+
+			if (!price) {
+				throw new Error(
+					`No valid price found for ${lineItem.productId} for country ${resource.country} and currency ${resource.totalPrice.currencyCode}`,
+				);
+			}
+
+			lineItem.price = price;
+		}
+
+		const lineItemTotal = calculateLineItemTotalPrice(lineItem);
+		lineItem.totalPrice = createCentPrecisionMoney({
+			...lineItem.price!.value,
+			centAmount: lineItemTotal,
+		});
+		resource.totalPrice.centAmount = calculateCartTotalPrice(resource);
+	}
+
 	setLineItemShippingDetails(
 		context: RepositoryContext,
 		resource: Writable<Cart>,

package/src/repositories/cart/helpers.ts

@@ -1,15 +1,14 @@
 import type {
 	Cart,
-	CentPrecisionMoney,
 	CustomLineItem,
 	CustomLineItemDraft,
 	LineItem,
 	Price,
 	TaxCategory,
 	TaxCategoryReference,
-	TaxedPrice,
 } from "@commercetools/platform-sdk";
 import { v4 as uuidv4 } from "uuid";
+import { calculateTaxedPrice } from "~src/lib/tax";
 import type { AbstractStorage } from "~src/storage/abstract";
 import {
 	createCentPrecisionMoney,
@@ -56,84 +55,6 @@ export const calculateCartTotalPrice = (cart: Cart): number => {
 	return lineItemsTotal + customLineItemsTotal;
 };
 
-export const calculateTaxedPrice = (
-	amount: number,
-	taxCategory: TaxCategory | undefined,
-	currency: string,
-	country: string | undefined,
-): TaxedPrice | undefined => {
-	if (!taxCategory || !taxCategory.rates.length) {
-		return undefined;
-	}
-
-	// Find the appropriate tax rate for the country
-	const taxRate =
-		taxCategory.rates.find(
-			(rate) => !rate.country || rate.country === country,
-		) || taxCategory.rates[0]; // Fallback to first rate if no country-specific rate found
-
-	if (!taxRate) {
-		return undefined;
-	}
-
-	let netAmount: number;
-	let grossAmount: number;
-	let taxAmount: number;
-
-	if (taxRate.includedInPrice) {
-		// Amount is gross, calculate net
-		grossAmount = amount;
-		taxAmount = Math.round(
-			(grossAmount * taxRate.amount) / (1 + taxRate.amount),
-		);
-		netAmount = grossAmount - taxAmount;
-	} else {
-		// Amount is net, calculate gross
-		netAmount = amount;
-		taxAmount = Math.round(netAmount * taxRate.amount);
-		grossAmount = netAmount + taxAmount;
-	}
-
-	return {
-		totalNet: {
-			type: "centPrecision",
-			currencyCode: currency,
-			centAmount: netAmount,
-			fractionDigits: 2,
-		},
-		totalGross: {
-			type: "centPrecision",
-			currencyCode: currency,
-			centAmount: grossAmount,
-			fractionDigits: 2,
-		},
-		taxPortions:
-			taxAmount > 0
-				? [
-						{
-							rate: taxRate.amount,
-							amount: {
-								type: "centPrecision",
-								currencyCode: currency,
-								centAmount: taxAmount,
-								fractionDigits: 2,
-							},
-							name: taxRate.name,
-						},
-					]
-				: [],
-		totalTax:
-			taxAmount > 0
-				? {
-						type: "centPrecision",
-						currencyCode: currency,
-						centAmount: taxAmount,
-						fractionDigits: 2,
-					}
-				: undefined,
-	};
-};
-
 export const createCustomLineItemFromDraft = (
 	projectKey: string,
 	draft: CustomLineItemDraft,

package/src/repositories/cart/index.test.ts

@@ -389,6 +389,54 @@ describe("Cart repository", () => {
 		expect(customLineItem.taxRate?.includedInPrice).toBe(false);
 		expect(customLineItem.taxRate?.country).toBe("NL");
 	});
+
+	test("should calculate taxed price for the cart", () => {
+		storage.add("dummy", "tax-category", {
+			...getBaseResourceProperties(),
+			id: "cart-tax-category",
+			key: "cart-vat-tax",
+			name: "Cart VAT Tax",
+			rates: [
+				{
+					id: "cart-rate-1",
+					name: "Standard VAT",
+					amount: 0.21,
+					includedInPrice: false,
+					country: "NL",
+				},
+			],
+		});
+
+		const cart: CartDraft = {
+			currency: "EUR",
+			country: "NL",
+			customLineItems: [
+				{
+					name: { en: "Gift Wrap" },
+					slug: "gift-wrap",
+					money: {
+						currencyCode: "EUR",
+						centAmount: 1000,
+					},
+					quantity: 1,
+					taxCategory: {
+						typeId: "tax-category" as const,
+						id: "cart-tax-category",
+					},
+				},
+			],
+		};
+
+		const ctx = { projectKey: "dummy", storeKey: "dummyStore" };
+		const result = repository.create(ctx, cart);
+
+		expect(result.taxedPrice).toBeDefined();
+		expect(result.taxedPrice?.totalNet.centAmount).toBe(1000);
+		expect(result.taxedPrice?.totalGross.centAmount).toBe(1210);
+		expect(result.taxedPrice?.totalTax?.centAmount).toBe(210);
+		expect(result.taxedPrice?.taxPortions).toHaveLength(1);
+		expect(result.taxedPrice?.taxPortions?.[0].rate).toBe(0.21);
+	});
 });
 
 describe("createShippingInfo", () => {