@labdigital/commercetools-mock 2.30.0 → 2.31.0

package/package.json

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

package/src/lib/productSearchFilter.test.ts

@@ -0,0 +1,328 @@
+import { ProductProjection, _SearchQuery } from "@commercetools/platform-sdk";
+import { describe, expect, test } from "vitest";
+import { cloneObject } from "~src/helpers";
+import { parseSearchQuery } from "./productSearchFilter";
+
+describe("Product search filter", () => {
+	const exampleProduct: ProductProjection = {
+		id: "7401d82f-1378-47ba-996a-85beeb87ac87",
+		version: 2,
+		createdAt: "2022-07-22T10:02:40.851Z",
+		lastModifiedAt: "2022-07-22T10:02:44.427Z",
+		key: "test-product",
+		productType: {
+			typeId: "product-type",
+			id: "b9b4b426-938b-4ccb-9f36-c6f933e8446e",
+		},
+		name: {
+			"nl-NL": "test",
+			"en-US": "my english test",
+		},
+		slug: {
+			"nl-NL": "test",
+			"en-US": "test",
+		},
+		variants: [],
+		searchKeywords: {},
+		categories: [],
+		masterVariant: {
+			id: 1,
+			sku: "MYSKU",
+			attributes: [
+				{
+					name: "Country",
+					value: {
+						key: "NL",
+						label: {
+							de: "niederlande",
+							en: "netherlands",
+							nl: "nederland",
+						},
+					},
+				},
+				{
+					name: "number",
+					value: 4,
+				},
+			],
+			prices: [
+				{
+					id: "dummy-uuid",
+					value: {
+						type: "centPrecision",
+						currencyCode: "EUR",
+						centAmount: 1789,
+						fractionDigits: 2,
+					},
+				},
+			],
+		},
+	};
+
+	const match = (filterObject: _SearchQuery, product?: ProductProjection) => {
+		const matchFunc = parseSearchQuery(filterObject);
+		const clone = cloneObject(product ?? exampleProduct);
+		return {
+			isMatch: matchFunc(clone, false),
+			product: clone,
+		};
+	};
+
+	test("by product key", async () => {
+		expect(
+			match({
+				exists: {
+					field: "key",
+				},
+			}).isMatch,
+		).toBeTruthy();
+
+		expect(
+			match({
+				not: {
+					exists: {
+						field: "key",
+					},
+				},
+			}).isMatch,
+		).toBeFalsy();
+
+		expect(
+			match({
+				exact: {
+					field: "key",
+					value: "test-product",
+				},
+			}).isMatch,
+		).toBeTruthy();
+	});
+
+	test("by product type id", async () => {
+		expect(
+			match({
+				exact: {
+					field: "productType.id",
+					value: "b9b4b426-938b-4ccb-9f36-c6f933e8446e",
+				},
+			}).isMatch,
+		).toBeTruthy();
+	});
+
+	test("by variant SKU", async () => {
+		expect(
+			match({
+				exists: {
+					field: "variants.sku",
+				},
+			}).isMatch,
+		).toBeTruthy();
+
+		expect(
+			match({
+				not: {
+					exists: {
+						field: "variants.sku",
+					},
+				},
+			}).isMatch,
+		).toBeFalsy();
+
+		expect(
+			match({
+				exact: {
+					field: "variants.sku",
+					value: "MYSKU",
+				},
+			}).isMatch,
+		).toBeTruthy();
+	});
+
+	test("by attribute value", async () => {
+		expect(
+			match({
+				exact: {
+					field: "variants.attributes.number",
+					value: 4,
+				},
+			}).isMatch,
+		).toBeTruthy();
+
+		expect(
+			match({
+				or: [
+					{
+						exact: {
+							field: "variants.attributes.number",
+							value: 3,
+						},
+					},
+					{
+						exact: {
+							field: "variants.attributes.number",
+							value: 4,
+						},
+					},
+				],
+			}).isMatch,
+		).toBeTruthy();
+
+		expect(
+			match({
+				exact: {
+					field: "variants.attributes.number",
+					value: 5,
+				},
+			}).isMatch,
+		).toBeFalsy();
+	});
+
+	test("by attribute range", async () => {
+		expect(
+			match({
+				range: {
+					field: "variants.attributes.number",
+					gt: 0,
+					lt: 5,
+				},
+			}).isMatch,
+		).toBeTruthy();
+
+		expect(
+			match({
+				range: {
+					field: "variants.attributes.number",
+					gt: 4,
+					lt: 10,
+				},
+			}).isMatch,
+		).toBeFalsy();
+
+		expect(
+			match({
+				range: {
+					field: "variants.attributes.number",
+					gte: 4,
+					lte: 10,
+				},
+			}).isMatch,
+		).toBeTruthy();
+	});
+
+	test("by attribute enum key", async () => {
+		expect(
+			match({
+				exact: {
+					field: "variants.attributes.Country.key",
+					value: "NL",
+				},
+			}).isMatch,
+		).toBeTruthy();
+
+		expect(
+			match({
+				exact: {
+					field: "variants.attributes.Country.key",
+					value: "DE",
+				},
+			}).isMatch,
+		).toBeFalsy();
+	});
+
+	test("by attribute text value", async () => {
+		expect(
+			match({
+				wildcard: {
+					field: "name",
+					value: "*test*",
+					language: "nl-NL",
+					caseInsensitive: true,
+				},
+			}).isMatch,
+		).toBeTruthy();
+
+		expect(
+			match({
+				wildcard: {
+					field: "name",
+					value: "*other*",
+					language: "nl-NL",
+					caseInsensitive: true,
+				},
+			}).isMatch,
+		).toBeFalsy();
+
+		expect(
+			match({
+				wildcard: {
+					field: "name",
+					value: "*Test*",
+					language: "nl-NL",
+					caseInsensitive: false,
+				},
+			}).isMatch,
+		).toBeFalsy();
+
+		expect(
+			match({
+				wildcard: {
+					field: "name",
+					value: "*english Test*",
+					language: "en-US",
+					caseInsensitive: true,
+				},
+			}).isMatch,
+		).toBeTruthy();
+	});
+
+	test("by price range", async () => {
+		expect(
+			match({
+				range: {
+					field: "variants.prices.currentCentAmount",
+					gte: 1500,
+					lte: 2000,
+				},
+			}).isMatch,
+		).toBeTruthy();
+
+		expect(
+			match({
+				range: {
+					field: "variants.prices.currentCentAmount",
+					gt: 1800,
+					lte: 2000,
+				},
+			}).isMatch,
+		).toBeFalsy();
+	});
+
+	test("by price range - or", async () => {
+		expect(
+			match({
+				or: [
+					{
+						range: {
+							field: "variants.prices.currentCentAmount",
+							gte: 2,
+							lte: 1500,
+						},
+					},
+					{
+						range: {
+							field: "variants.prices.currentCentAmount",
+							gte: 1500,
+							lte: 3000,
+						},
+					},
+					{
+						range: {
+							field: "variants.prices.currentCentAmount",
+							gte: 3000,
+							lte: 4000,
+						},
+					},
+				],
+			}).isMatch,
+		).toBeTruthy();
+	});
+});

package/src/lib/productSearchFilter.ts

@@ -0,0 +1,329 @@
+import type {
+	ProductProjection,
+	ProductVariant,
+	SearchAndExpression,
+	SearchDateRangeExpression,
+	SearchDateTimeRangeExpression,
+	SearchExactExpression,
+	SearchExistsExpression,
+	SearchFilterExpression,
+	SearchFullTextExpression,
+	SearchFullTextPrefixExpression,
+	SearchLongRangeExpression,
+	SearchNotExpression,
+	SearchNumberRangeExpression,
+	SearchOrExpression,
+	SearchPrefixExpression,
+	SearchTimeRangeExpression,
+	SearchWildCardExpression,
+	_SearchQuery,
+	_SearchQueryExpression,
+	_SearchQueryExpressionValue,
+} from "@commercetools/platform-sdk";
+import { nestedLookup } from "~src/helpers";
+import type { Writable } from "../types";
+import { getVariants } from "./projectionSearchFilter";
+
+type ProductSearchFilterFunc = (
+	p: Writable<ProductProjection>,
+	markMatchingVariants: boolean,
+) => boolean;
+
+// @TODO: Implement field boosting:
+// https://docs.commercetools.com/merchant-center/advanced-product-search#boost-field
+export const parseSearchQuery = (
+	searchQuery: _SearchQuery,
+): ProductSearchFilterFunc => {
+	if (isSearchAndExpression(searchQuery)) {
+		return (obj, markMatchingVariant) =>
+			searchQuery.and.every((expr) => {
+				const filterFunc = parseSearchQuery(expr);
+
+				return filterFunc(obj, markMatchingVariant);
+			});
+	}
+
+	if (isSearchOrExpression(searchQuery)) {
+		return (obj, markMatchingVariant) =>
+			searchQuery.or.some((expr) => {
+				const filterFunc = parseSearchQuery(expr);
+
+				return filterFunc(obj, markMatchingVariant);
+			});
+	}
+
+	if (isSearchNotExpression(searchQuery)) {
+		return (obj, markMatchingVariant) =>
+			!parseSearchQuery(searchQuery.not)(obj, markMatchingVariant);
+	}
+
+	if (isSearchFilterExpression(searchQuery)) {
+		// Matching resources of a query are checked for their relevancy to the search.
+		// The relevancy is expressed by an internal score.
+		// All expressions except filter expressions contribute to that score.
+		// All sub-expressions of a filter are implicitly connected with an and expression.
+		// NOTE: for now just implementing it like a AND expression
+		return (obj, markMatchingVariant) =>
+			searchQuery.filter.every((expr) => {
+				const filterFunc = parseSearchQuery(expr);
+
+				return filterFunc(obj, markMatchingVariant);
+			});
+	}
+
+	if (isSearchRangeExpression(searchQuery)) {
+		const generateRangeMatchFunc = (value: any) => {
+			const rangeFilters = [];
+
+			if (searchQuery.range.gte) {
+				rangeFilters.push(value >= searchQuery.range.gte);
+			}
+
+			if (searchQuery.range.gt) {
+				rangeFilters.push(value > searchQuery.range.gt);
+			}
+
+			if (searchQuery.range.lte) {
+				rangeFilters.push(value <= searchQuery.range.lte);
+			}
+
+			if (searchQuery.range.lt) {
+				rangeFilters.push(value < searchQuery.range.lt);
+			}
+
+			return rangeFilters.every((filter) => filter);
+		};
+
+		return generateFieldMatchFunc(generateRangeMatchFunc, searchQuery.range);
+	}
+
+	if (isSearchExactExpression(searchQuery)) {
+		return generateFieldMatchFunc(
+			(value: any) => value === searchQuery.exact.value,
+			searchQuery.exact,
+		);
+	}
+
+	if (isSearchExistsExpression(searchQuery)) {
+		return generateFieldMatchFunc((value: any) => !!value, searchQuery.exists);
+	}
+
+	if (isSearchFullTextExpression(searchQuery)) {
+		// @TODO: Implement fulltext search, to fully support functionality offered by commercetools:
+		// https://docs.commercetools.com/api/search-query-language#fulltext
+		return generateFieldMatchFunc(
+			(value: any) => value.includes(searchQuery.fullText.value),
+			searchQuery.fullText,
+		);
+	}
+
+	if (isSearchFullTextPrefixExpression(searchQuery)) {
+		// @TODO: Implement fulltext search, to fully support functionality offered by commercetools:
+		// https://docs.commercetools.com/api/search-query-language#fulltext
+		return generateFieldMatchFunc(
+			(value: any) => value.startsWith(searchQuery.fullTextPrefix.value),
+			searchQuery.fullTextPrefix,
+		);
+	}
+
+	if (isSearchPrefixExpression(searchQuery)) {
+		return generateFieldMatchFunc(
+			(value: any) => value.startsWith(searchQuery.prefix.value),
+			searchQuery.prefix,
+		);
+	}
+
+	if (isSearchWildCardExpression(searchQuery)) {
+		// @TODO: Fully implement wildcard search, as specified:
+		// https://docs.commercetools.com/api/search-query-language#fulltext
+		const generateWildcardMatchFunc = (value: any) => {
+			const wildCardValues = searchQuery.wildcard.value
+				.split("*")
+				.filter((v: string) => !!v);
+
+			if (searchQuery.wildcard.caseInsensitive) {
+				return wildCardValues.every((wildCardValue: string) =>
+					value.toLowerCase().includes(wildCardValue.toLowerCase()),
+				);
+			}
+
+			return wildCardValues.every((wildCardValue: string) =>
+				value.includes(wildCardValue),
+			);
+		};
+
+		return generateFieldMatchFunc(
+			generateWildcardMatchFunc,
+			searchQuery.wildcard,
+		);
+	}
+
+	throw new Error("Unsupported search query expression");
+};
+
+const generateFieldMatchFunc = (
+	matchFunc: (value: any) => boolean,
+	searchQuery: _SearchQueryExpressionValue,
+) => {
+	const generateMatchFunc = (
+		obj: ProductProjection,
+		markMatchingVariants: boolean,
+	) => {
+		if (searchQuery.field.startsWith("variants.")) {
+			const variantField = searchQuery.field.substring(
+				searchQuery.field.indexOf(".") + 1,
+			);
+
+			const variants = getVariants(obj) as Writable<ProductVariant>[];
+			for (const variant of variants) {
+				const value = resolveFieldValue(variant, {
+					...searchQuery,
+					field: variantField,
+				});
+
+				if (matchFunc(value)) {
+					if (markMatchingVariants) {
+						for (const v of variants) {
+							v.isMatchingVariant = false;
+						}
+						variant.isMatchingVariant = true;
+					}
+
+					return true;
+				}
+			}
+
+			return false;
+		}
+
+		return matchFunc(resolveFieldValue(obj, searchQuery));
+	};
+
+	return generateMatchFunc;
+};
+
+const resolveFieldValue = (
+	obj: any,
+	searchQuery: _SearchQueryExpressionValue,
+) => {
+	if (searchQuery.field === undefined) {
+		throw new Error("Missing field path in query expression");
+	}
+
+	let fieldPath = searchQuery.field;
+	const language = "language" in searchQuery ? searchQuery.language : undefined;
+
+	if (fieldPath.startsWith("variants.")) {
+		fieldPath = fieldPath.substring(fieldPath.indexOf(".") + 1);
+	}
+
+	if (fieldPath.startsWith("attributes.")) {
+		const [, attrName, ...rest] = fieldPath.split(".");
+		if (!obj.attributes) {
+			return undefined;
+		}
+
+		for (const attr of obj.attributes) {
+			if (attr.name === attrName) {
+				return nestedLookupByLanguage(attr.value, rest.join("."), language);
+			}
+		}
+	}
+
+	if (fieldPath === "prices.currentCentAmount") {
+		return obj.prices && obj.prices.length > 0
+			? obj.prices[0].value.centAmount
+			: undefined;
+	}
+
+	return nestedLookupByLanguage(obj, fieldPath, language);
+};
+
+const nestedLookupByLanguage = (
+	obj: any,
+	path: string,
+	language?: string,
+): any => {
+	const value = nestedLookup(obj, path);
+
+	if (language && value && typeof value === "object") {
+		// Due to Commercetools supporting "en", but also "en-US" as language, we need to find the best match
+		const matchingLanguageKey = Object.keys(value).find((key) =>
+			key.toLowerCase().startsWith(language.toLowerCase()),
+		);
+
+		return matchingLanguageKey ? value[matchingLanguageKey] : undefined;
+	}
+
+	return value;
+};
+
+// type guards
+const isSearchAndExpression = (
+	expr: _SearchQuery,
+): expr is SearchAndExpression =>
+	(expr as SearchAndExpression).and !== undefined;
+
+const isSearchOrExpression = (expr: _SearchQuery): expr is SearchOrExpression =>
+	(expr as SearchOrExpression).or !== undefined;
+
+type SearchRangeExpression =
+	| SearchDateRangeExpression
+	| SearchDateTimeRangeExpression
+	| SearchLongRangeExpression
+	| SearchNumberRangeExpression
+	| SearchTimeRangeExpression;
+
+// Type guard for SearchNotExpression
+const isSearchNotExpression = (
+	expr: _SearchQueryExpression,
+): expr is SearchNotExpression =>
+	(expr as SearchNotExpression).not !== undefined;
+
+// Type guard for SearchFilterExpression
+const isSearchFilterExpression = (
+	expr: _SearchQueryExpression,
+): expr is SearchFilterExpression =>
+	(expr as SearchFilterExpression).filter !== undefined;
+
+// Type guard for SearchDateRangeExpression
+const isSearchRangeExpression = (
+	expr: _SearchQueryExpression,
+): expr is SearchRangeExpression =>
+	(expr as SearchRangeExpression).range !== undefined;
+
+// Type guard for SearchExactExpression
+const isSearchExactExpression = (
+	expr: _SearchQueryExpression,
+): expr is SearchExactExpression =>
+	(expr as SearchExactExpression).exact !== undefined;
+
+// Type guard for SearchExistsExpression
+const isSearchExistsExpression = (
+	expr: _SearchQueryExpression,
+): expr is SearchExistsExpression =>
+	(expr as SearchExistsExpression).exists !== undefined;
+
+// Type guard for SearchFullTextExpression
+const isSearchFullTextExpression = (
+	expr: _SearchQueryExpression,
+): expr is SearchFullTextExpression =>
+	(expr as SearchFullTextExpression).fullText !== undefined;
+
+// Type guard for SearchFullTextPrefixExpression
+const isSearchFullTextPrefixExpression = (
+	expr: _SearchQueryExpression,
+): expr is SearchFullTextPrefixExpression =>
+	(expr as SearchFullTextPrefixExpression).fullTextPrefix !== undefined;
+
+// Type guard for SearchPrefixExpression
+const isSearchPrefixExpression = (
+	expr: _SearchQueryExpression,
+): expr is SearchPrefixExpression =>
+	(expr as SearchPrefixExpression).prefix !== undefined;
+
+// Type guard for SearchWildCardExpression
+const isSearchWildCardExpression = (
+	expr: _SearchQueryExpression,
+): expr is SearchWildCardExpression =>
+	(expr as SearchWildCardExpression).wildcard !== undefined;

package/src/product-search.ts

@@ -7,6 +7,7 @@ import {
 	ProductSearchResult,
 } from "@commercetools/platform-sdk";
 import { CommercetoolsError } from "./exceptions";
+import { parseSearchQuery } from "./lib/productSearchFilter";
 import { validateSearchQuery } from "./lib/searchQueryTypeChecker";
 import { applyPriceSelector } from "./priceSelector";
 import { AbstractStorage } from "./storage";
@@ -22,7 +23,7 @@ export class ProductSearch {
 		projectKey: string,
 		params: ProductSearchRequest,
 	): ProductPagedSearchResponse {
-		const resources = this._storage
+		let resources = this._storage
 			.all(projectKey, "product")
 			.map((r) =>
 				this.transform(r, params.productProjectionParameters?.staged ?? false),
@@ -34,10 +35,19 @@ export class ProductSearch {
 				return true;
 			});
 
-		// Validate query, if given
+		const markMatchingVariant = params.markMatchingVariants ?? false;
+
+		// Apply filters pre facetting
 		if (params.query) {
 			try {
 				validateSearchQuery(params.query);
+
+				const matchFunc = parseSearchQuery(params.query);
+
+				// Filters can modify the output. So clone the resources first.
+				resources = resources.filter((resource) =>
+					matchFunc(resource, markMatchingVariant),
+				);
 			} catch (err) {
 				console.error(err);
 				throw new CommercetoolsError<InvalidInputError>(

package/src/repositories/order/actions.ts

@@ -6,6 +6,7 @@ import type {
 	OrderAddReturnInfoAction,
 	OrderChangeOrderStateAction,
 	OrderChangePaymentStateAction,
+	OrderChangeShipmentStateAction,
 	OrderSetBillingAddressAction,
 	OrderSetCustomFieldAction,
 	OrderSetCustomTypeAction,
@@ -117,6 +118,14 @@ export class OrderUpdateHandler
 		resource.paymentState = paymentState;
 	}
 
+	changeShipmentState(
+		context: RepositoryContext,
+		resource: Writable<Order>,
+		{ shipmentState }: OrderChangeShipmentStateAction,
+	) {
+		resource.shipmentState = shipmentState;
+	}
+
 	setBillingAddress(
 		context: RepositoryContext,
 		resource: Writable<Order>,