@labdigital/commercetools-mock 2.54.0 → 2.56.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@labdigital/commercetools-mock",
-  "version": "2.54.0",
+  "version": "2.56.0",
   "license": "MIT",
   "author": "Michael van Tellingen",
   "type": "module",
@@ -31,7 +31,7 @@
     "@types/express": "^5.0.1",
     "@changesets/changelog-github": "0.5.1",
     "@changesets/cli": "2.28.1",
-    "@commercetools/platform-sdk": "8.8.0",
+    "@commercetools/platform-sdk": "8.14.0",
     "@types/basic-auth": "1.1.8",
     "@types/body-parser": "1.19.5",
     "@types/express-serve-static-core": "^5.0.6",
@@ -66,6 +66,7 @@
     "publish:version": "pnpm changeset version && pnpm format",
     "start": "tsdown src/server.ts --watch --onSuccess 'node dist/server'",
     "test": "vitest run",
-    "test:ci": "vitest run --coverage"
+    "test:ci": "vitest run --coverage",
+    "test:watch": "vitest --watch"
   }
 }

package/src/lib/predicateParser.test.ts

@@ -151,43 +151,11 @@ describe("Predicate filter", () => {
 		expect(match("numberProperty in (1234)")).toBeTruthy();
 	});
 
-	test("in operator with and clause", async () => {
-		expect(
-			match("numberProperty in (1234) and stringProperty=:val", {
-				val: "foobar",
-			}),
-		).toBeTruthy();
-		expect(
-			match("numberProperty in (1234) and stringProperty=:val", {
-				val: "other",
-			}),
-		).toBeFalsy();
-		expect(
-			match("numberProperty in (1235) and stringProperty=:val", {
-				val: "foobar",
-			}),
-		).toBeFalsy();
-	});
-
-	test("within operator with and clause", async () => {
-		expect(
-			match(
-				"geoLocation within circle(5.121310867198959, 52.09068804569714, 2500) and stringProperty=:val",
-				{ val: "foobar" },
-			),
-		).toBeTruthy();
-		expect(
-			match(
-				"geoLocation within circle(5.121310867198959, 52.09068804569714, 2500) and stringProperty=:val",
-				{ val: "other" },
-			),
-		).toBeFalsy();
-		expect(
-			match(
-				"geoLocation within circle(5.121310867198959, 52.09068804569714, 1000) and stringProperty=:val",
-				{ val: "foobar" },
-			),
-		).toBeFalsy();
+	test("in operator works with with and without parentheses", async () => {
+		expect(match("numberProperty in :val", { val: 1234 })).toBeTruthy();
+		expect(match("numberProperty in :val", { val: 1235 })).toBeFalsy();
+		expect(match("numberProperty in :val", { val: [1234] })).toBeTruthy();
+		expect(match("numberProperty in :val", { val: [1235] })).toBeFalsy();
 	});
 
 	test("arrayProperty contains all (...)", async () => {
@@ -401,6 +369,14 @@ describe("Predicate filter", () => {
 			),
 		).toBeFalsy();
 	});
+
+	test("in operator with array values", async () => {
+		expect(match(`arrayProperty in ("foo")`)).toBeTruthy();
+		expect(match(`arrayProperty in ("bar")`)).toBeTruthy();
+		expect(match(`arrayProperty in ("missing")`)).toBeFalsy();
+		expect(match(`arrayProperty in ("foo", "bar")`)).toBeTruthy();
+		expect(match(`arrayProperty in ("missing", "alsomissing")`)).toBeFalsy();
+	});
 });
 
 describe("Report parse errors", () => {

package/src/lib/predicateParser.ts

@@ -381,8 +381,14 @@ const generateMatchFunc = (predicate: string): MatchFunc => {
 			}
 		})
 		.led("IN", 20, ({ left, bp }) => {
+			const firstToken = lexer.peek();
 			const expr = parser.parse({ terminals: [bp - 1] });
-			lexer.expect(")");
+
+			// IN can be a single value or a list of values
+			if (firstToken.match === "(") {
+				lexer.expect(")");
+			}
+
 			return (obj: any, vars: object) => {
 				let symbols = expr;
 				if (!Array.isArray(symbols)) {
@@ -397,6 +403,11 @@ const generateMatchFunc = (predicate: string): MatchFunc => {
 					resolveSymbol(item, vars),
 				);
 				const value = resolveValue(obj, left);
+
+				if (Array.isArray(value)) {
+					return inValues.some((inValue: any) => value.includes(inValue));
+				}
+
 				return inValues.includes(value);
 			};
 		})

package/src/lib/productSearchFilter.test.ts

@@ -25,6 +25,7 @@ describe("Product search filter", () => {
 			"nl-NL": "test",
 			"en-US": "test",
 		},
+		attributes: [],
 		variants: [],
 		searchKeywords: {},
 		categories: [],

package/src/lib/projectionSearchFilter.test.ts

@@ -24,6 +24,7 @@ describe("Search filter", () => {
 		variants: [],
 		searchKeywords: {},
 		categories: [],
+		attributes: [],
 		masterVariant: {
 			id: 1,
 			sku: "MYSKU",

package/src/priceSelector.test.ts

@@ -24,6 +24,7 @@ describe("priceSelector", () => {
 			variants: [],
 			searchKeywords: {},
 			categories: [],
+			attributes: [],
 			masterVariant: {
 				id: 1,
 				sku: "MYSKU",

package/src/product-projection-search.ts

@@ -3,6 +3,7 @@ import type {
 	FilteredFacetResult,
 	InvalidInputError,
 	Product,
+	ProductData,
 	ProductProjection,
 	ProductProjectionPagedSearchResponse,
 	QueryParam,
@@ -169,6 +170,7 @@ export class ProductProjectionSearch {
 		return {
 			id: product.id,
 			createdAt: product.createdAt,
+			attributes: obj.attributes,
 			lastModifiedAt: product.lastModifiedAt,
 			version: product.version,
 			name: obj.name,

package/src/product-search.ts

@@ -176,6 +176,7 @@ export class ProductSearch {
 			metaDescription: obj.metaDescription,
 			slug: obj.slug,
 			categories: obj.categories,
+			attributes: obj.attributes,
 			masterVariant: {
 				...obj.masterVariant,
 				availability: getVariantAvailability(obj.masterVariant.sku),

package/src/repositories/cart/actions.ts

@@ -11,10 +11,14 @@ import type {
 	Address,
 	AddressDraft,
 	Cart,
+	CartAddCustomLineItemAction,
 	CartAddItemShippingAddressAction,
 	CartAddLineItemAction,
+	CartChangeCustomLineItemMoneyAction,
+	CartChangeCustomLineItemQuantityAction,
 	CartChangeLineItemQuantityAction,
 	CartChangeTaxRoundingModeAction,
+	CartRemoveCustomLineItemAction,
 	CartRemoveDiscountCodeAction,
 	CartRemoveLineItemAction,
 	CartRemoveShippingMethodAction,
@@ -39,8 +43,10 @@ import type {
 	Product,
 	ProductPagedQueryResponse,
 	ProductVariant,
+	TaxCategoryReference,
 } from "@commercetools/platform-sdk";
 import type {
+	CustomLineItem,
 	DirectDiscount,
 	TaxPortion,
 	TaxedItemPrice,
@@ -58,11 +64,14 @@ import {
 	createCentPrecisionMoney,
 	createCustomFields,
 	createTypedMoney,
+	getReferenceFromResourceIdentifier,
 	roundDecimal,
 } from "../helpers";
 import {
 	calculateCartTotalPrice,
 	calculateLineItemTotalPrice,
+	calculateTaxedPrice,
+	createCustomLineItemFromDraft,
 	selectPrice,
 } from "./helpers";
 
@@ -319,6 +328,175 @@ export class CartUpdateHandler
 		resource.totalPrice.centAmount = calculateCartTotalPrice(resource);
 	}
 
+	addCustomLineItem(
+		context: RepositoryContext,
+		resource: Writable<Cart>,
+		{
+			money,
+			name,
+			slug,
+			quantity = 1,
+			taxCategory,
+			custom,
+			priceMode = "Standard",
+			key,
+		}: CartAddCustomLineItemAction,
+	) {
+		const customLineItem = createCustomLineItemFromDraft(
+			context.projectKey,
+			{ money, name, slug, quantity, taxCategory, custom, priceMode, key },
+			this._storage,
+			resource.country,
+		);
+
+		resource.customLineItems.push(customLineItem);
+		resource.totalPrice.centAmount = calculateCartTotalPrice(resource);
+	}
+
+	removeCustomLineItem(
+		context: RepositoryContext,
+		resource: Writable<Cart>,
+		{ customLineItemId, customLineItemKey }: CartRemoveCustomLineItemAction,
+	) {
+		let customLineItem;
+
+		if (!customLineItemId && !customLineItemKey) {
+			throw new CommercetoolsError<GeneralError>({
+				code: "General",
+				message:
+					"Either customLineItemId or customLineItemKey needs to be provided.",
+			});
+		}
+
+		if (customLineItemId) {
+			customLineItem = resource.customLineItems.find(
+				(x) => x.id === customLineItemId,
+			);
+			if (!customLineItem) {
+				throw new CommercetoolsError<GeneralError>({
+					code: "General",
+					message: `A custom line item with ID '${customLineItemId}' not found.`,
+				});
+			}
+			resource.customLineItems = resource.customLineItems.filter(
+				(x) => x.id !== customLineItemId,
+			);
+		}
+
+		if (customLineItemKey) {
+			customLineItem = resource.customLineItems.find(
+				(x) => x.key === customLineItemKey,
+			);
+			if (!customLineItem) {
+				throw new CommercetoolsError<GeneralError>({
+					code: "General",
+					message: `A custom line item with key '${customLineItemKey}' not found.`,
+				});
+			}
+			resource.customLineItems = resource.customLineItems.filter(
+				(x) => x.key !== customLineItemKey,
+			);
+		}
+
+		resource.totalPrice.centAmount = calculateCartTotalPrice(resource);
+	}
+
+	changeCustomLineItemQuantity(
+		context: RepositoryContext,
+		resource: Writable<Cart>,
+		{
+			customLineItemId,
+			customLineItemKey,
+			quantity,
+		}: CartChangeCustomLineItemQuantityAction,
+	) {
+		let customLineItem;
+
+		if (!customLineItemId && !customLineItemKey) {
+			throw new CommercetoolsError<GeneralError>({
+				code: "General",
+				message:
+					"Either customLineItemId or customLineItemKey needs to be provided.",
+			});
+		}
+
+		const setQuantity = (
+			customLineItem: Writable<CustomLineItem> | undefined,
+		) => {
+			if (!customLineItem) {
+				throw new CommercetoolsError<GeneralError>({
+					code: "General",
+					message: `A custom line item with ${customLineItemId ? `ID '${customLineItemId}'` : `key '${customLineItemKey}'`} not found.`,
+				});
+			}
+			customLineItem.quantity = quantity;
+			customLineItem.totalPrice = createCentPrecisionMoney({
+				...customLineItem.money,
+				centAmount: (customLineItem.money.centAmount ?? 0) * quantity,
+			});
+		};
+
+		if (customLineItemId) {
+			customLineItem = resource.customLineItems.find(
+				(x) => x.id === customLineItemId,
+			);
+			setQuantity(customLineItem);
+		}
+
+		if (customLineItemKey) {
+			customLineItem = resource.customLineItems.find(
+				(x) => x.key === customLineItemKey,
+			);
+			setQuantity(customLineItem);
+		}
+
+		// Update cart total price
+		resource.totalPrice.centAmount = calculateCartTotalPrice(resource);
+	}
+
+	changeCustomLineItemMoney(
+		context: RepositoryContext,
+		resource: Writable<Cart>,
+		{
+			customLineItemId,
+			customLineItemKey,
+			money,
+		}: CartChangeCustomLineItemMoneyAction,
+	) {
+		let customLineItem;
+
+		const setMoney = (customLineItem: Writable<CustomLineItem> | undefined) => {
+			if (!customLineItem) {
+				throw new CommercetoolsError<GeneralError>({
+					code: "General",
+					message: `A custom line item with ${customLineItemId ? `ID '${customLineItemId}'` : `key '${customLineItemKey}'`} not found.`,
+				});
+			}
+			customLineItem.money = createTypedMoney(money);
+			customLineItem.totalPrice = createCentPrecisionMoney({
+				...money,
+				centAmount: (money.centAmount ?? 0) * customLineItem.quantity,
+			});
+		};
+
+		if (customLineItemId) {
+			customLineItem = resource.customLineItems.find(
+				(x) => x.id === customLineItemId,
+			);
+			setMoney(customLineItem);
+		}
+
+		if (customLineItemKey) {
+			customLineItem = resource.customLineItems.find(
+				(x) => x.key === customLineItemKey,
+			);
+			setMoney(customLineItem);
+		}
+
+		// Update cart total price
+		resource.totalPrice.centAmount = calculateCartTotalPrice(resource);
+	}
+
 	setAnonymousId(
 		_context: RepositoryContext,
 		resource: Writable<Cart>,

package/src/repositories/cart/helpers.ts

@@ -1,4 +1,22 @@
-import type { Cart, LineItem, Price } from "@commercetools/platform-sdk";
+import type {
+	Cart,
+	CentPrecisionMoney,
+	CustomLineItem,
+	CustomLineItemDraft,
+	LineItem,
+	Price,
+	TaxCategory,
+	TaxCategoryReference,
+	TaxedPrice,
+} from "@commercetools/platform-sdk";
+import { v4 as uuidv4 } from "uuid";
+import type { AbstractStorage } from "~src/storage/abstract";
+import {
+	createCentPrecisionMoney,
+	createCustomFields,
+	createTypedMoney,
+	getReferenceFromResourceIdentifier,
+} from "../helpers";
 
 export const selectPrice = ({
 	prices,
@@ -26,5 +44,154 @@ export const selectPrice = ({
 export const calculateLineItemTotalPrice = (lineItem: LineItem): number =>
 	lineItem.price?.value.centAmount * lineItem.quantity;
 
-export const calculateCartTotalPrice = (cart: Cart): number =>
-	cart.lineItems.reduce((cur, item) => cur + item.totalPrice.centAmount, 0);
+export const calculateCartTotalPrice = (cart: Cart): number => {
+	const lineItemsTotal = cart.lineItems.reduce(
+		(cur, item) => cur + item.totalPrice.centAmount,
+		0,
+	);
+	const customLineItemsTotal = cart.customLineItems.reduce(
+		(cur, item) => cur + item.totalPrice.centAmount,
+		0,
+	);
+	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,
+	storage: AbstractStorage,
+	country?: string,
+): CustomLineItem => {
+	const quantity = draft.quantity ?? 1;
+
+	const taxCategoryRef = draft.taxCategory
+		? getReferenceFromResourceIdentifier<TaxCategoryReference>(
+				draft.taxCategory,
+				projectKey,
+				storage,
+			)
+		: undefined;
+
+	// Get the tax category to calculate taxed price
+	let taxCategory: TaxCategory | undefined = undefined;
+	if (taxCategoryRef) {
+		try {
+			taxCategory =
+				storage.get(projectKey, "tax-category", taxCategoryRef.id, {}) ||
+				undefined;
+		} catch (error) {
+			// Tax category not found, continue without tax calculation
+		}
+	}
+
+	const totalPrice = createCentPrecisionMoney({
+		...draft.money,
+		centAmount: (draft.money.centAmount ?? 0) * quantity,
+	});
+
+	// Calculate taxed price if tax category is available
+	const taxedPrice = taxCategory
+		? calculateTaxedPrice(
+				totalPrice.centAmount,
+				taxCategory,
+				totalPrice.currencyCode,
+				country,
+			)
+		: undefined;
+
+	return {
+		id: uuidv4(),
+		key: draft.key,
+		name: draft.name,
+		money: createTypedMoney(draft.money),
+		slug: draft.slug,
+		quantity: draft.quantity ?? 1,
+		state: [],
+		taxCategory: taxCategoryRef,
+		taxedPrice,
+		custom: createCustomFields(draft.custom, projectKey, storage),
+		discountedPricePerQuantity: [],
+		perMethodTaxRate: [],
+		priceMode: draft.priceMode ?? "Standard",
+		totalPrice,
+		taxedPricePortions: [],
+	};
+};

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

@@ -1,4 +1,8 @@
-import type { CartDraft, LineItem } from "@commercetools/platform-sdk";
+import type {
+	CartDraft,
+	CustomLineItemDraft,
+	LineItem,
+} from "@commercetools/platform-sdk";
 import { describe, expect, test } from "vitest";
 import type { Config } from "~src/config";
 import { getBaseResourceProperties } from "~src/helpers";
@@ -33,6 +37,7 @@ describe("Cart repository", () => {
 				current: {
 					name: { "nl-NL": "Dummy" },
 					slug: { "nl-NL": "Dummy" },
+					attributes: [],
 					categories: [],
 					masterVariant: {
 						sku: "MYSKU",
@@ -57,6 +62,7 @@ describe("Cart repository", () => {
 				staged: {
 					name: { "nl-NL": "Dummy" },
 					slug: { "nl-NL": "Dummy" },
+					attributes: [],
 					categories: [],
 					masterVariant: {
 						sku: "MYSKU",
@@ -81,6 +87,14 @@ describe("Cart repository", () => {
 			},
 		});
 
+		storage.add("dummy", "tax-category", {
+			...getBaseResourceProperties(),
+			id: "tax-category-id",
+			key: "standard-tax",
+			name: "Standard Tax",
+			rates: [],
+		});
+
 		const cart: CartDraft = {
 			anonymousId: "1234567890",
 			billingAddress: {
@@ -95,7 +109,21 @@ describe("Cart repository", () => {
 			country: "NL",
 			currency: "EUR",
 			customerEmail: "john.doe@example.com",
-			customLineItems: [],
+			customLineItems: [
+				{
+					name: { "nl-NL": "Douane kosten" },
+					slug: "customs-fee",
+					money: {
+						currencyCode: "EUR",
+						centAmount: 2500,
+					},
+					quantity: 1,
+					taxCategory: {
+						typeId: "tax-category" as const,
+						id: "tax-category-id",
+					},
+				},
+			],
 			inventoryMode: "None",
 			itemShippingAddresses: [],
 			lineItems: [
@@ -171,6 +199,11 @@ describe("Cart repository", () => {
 		expect(result.lineItems[0].custom?.fields.description as string).toEqual(
 			cart.lineItems![0].custom?.fields?.description,
 		);
+		expect(result.customLineItems).toHaveLength(1);
+		expect(result.customLineItems[0].name).toEqual(
+			cart.customLineItems?.[0].name,
+		);
+		expect(result.totalPrice.centAmount).toBe(3500);
 	});
 
 	test("create cart with business unit", async () => {
@@ -210,4 +243,55 @@ describe("Cart repository", () => {
 			typeId: "business-unit",
 		});
 	});
+
+	test("should calculate taxed price for custom line items with tax category", () => {
+		storage.add("dummy", "tax-category", {
+			...getBaseResourceProperties(),
+			id: "tax-category-with-rate",
+			key: "vat-tax",
+			name: "VAT Tax",
+			rates: [
+				{
+					id: "rate-1",
+					name: "Standard VAT",
+					amount: 0.21,
+					includedInPrice: false,
+					country: "NL",
+				},
+			],
+		});
+
+		const cart: CartDraft = {
+			currency: "EUR",
+			country: "NL",
+			customLineItems: [
+				{
+					name: { en: "Service Fee" },
+					slug: "service-fee",
+					money: {
+						currencyCode: "EUR",
+						centAmount: 1000,
+					},
+					quantity: 1,
+					taxCategory: {
+						typeId: "tax-category" as const,
+						id: "tax-category-with-rate",
+					},
+				},
+			],
+		};
+
+		const ctx = { projectKey: "dummy", storeKey: "dummyStore" };
+		const result = repository.create(ctx, cart);
+
+		expect(result.customLineItems).toHaveLength(1);
+		const customLineItem = result.customLineItems[0];
+
+		expect(customLineItem.taxedPrice).toBeDefined();
+		expect(customLineItem.taxedPrice?.totalGross.centAmount).toBe(1210);
+		expect(customLineItem.taxedPrice?.totalNet.centAmount).toBe(1000);
+		expect(customLineItem.taxedPrice?.totalTax?.centAmount).toBe(210);
+		expect(customLineItem.taxedPrice?.taxPortions).toHaveLength(1);
+		expect(customLineItem.taxedPrice?.taxPortions[0].rate).toBe(0.21);
+	});
 });