@labdigital/commercetools-mock 2.17.1 → 2.18.1

package/src/lib/projectionSearchFilter.ts

@@ -5,282 +5,282 @@
 import type {
 	ProductProjection,
 	ProductVariant,
-} from '@commercetools/platform-sdk'
-import { nestedLookup } from '../helpers.js'
-import type { Writable } from '../types.js'
-import { Lexer, Parser } from './parser.js'
+} from "@commercetools/platform-sdk";
+import { nestedLookup } from "../helpers";
+import type { Writable } from "../types";
+import { Lexer, Parser } from "./parser";
 
-type MatchFunc = (target: any) => boolean
+type MatchFunc = (target: any) => boolean;
 
 type ProductProjectionFilter = (
 	p: Writable<ProductProjection>,
-	markMatchingVariants: boolean
-) => boolean
+	markMatchingVariants: boolean,
+) => boolean;
 
 type TypeSymbol = {
-	type: 'Symbol'
-	kind: 'int' | 'string' | 'any'
-	value: any
-}
+	type: "Symbol";
+	kind: "int" | "string" | "any";
+	value: any;
+};
 
 type RangeExpressionSet = {
-	source: string
-	type: 'RangeExpression'
-	children?: RangeExpression[]
-}
+	source: string;
+	type: "RangeExpression";
+	children?: RangeExpression[];
+};
 
 type FilterExpressionSet = {
-	source: string
-	type: 'FilterExpression'
-	children?: FilterExpression[]
-}
+	source: string;
+	type: "FilterExpression";
+	children?: FilterExpression[];
+};
 
 type TermExpressionSet = {
-	source: string
-	type: 'TermExpression'
-}
+	source: string;
+	type: "TermExpression";
+};
 
 type ExpressionSet =
 	| RangeExpressionSet
 	| FilterExpressionSet
-	| TermExpressionSet
+	| TermExpressionSet;
 
 export type RangeExpression = {
-	type: 'RangeExpression'
-	start?: number
-	stop?: number
-	match: (obj: any) => boolean
-}
+	type: "RangeExpression";
+	start?: number;
+	stop?: number;
+	match: (obj: any) => boolean;
+};
 
 export type FilterExpression = {
-	type: 'FilterExpression'
-	match: (obj: any) => boolean
-}
+	type: "FilterExpression";
+	match: (obj: any) => boolean;
+};
 
 /**
  * Returns a function (ProductProjectionFilter).
  * NOTE: The filter can alter the resources in-place (FIXME)
  */
 export const parseFilterExpression = (
-	filter: string
+	filter: string,
 ): ProductProjectionFilter => {
-	const exprFunc = generateMatchFunc(filter)
-	const [source] = filter.split(':', 1)
+	const exprFunc = generateMatchFunc(filter);
+	const [source] = filter.split(":", 1);
 
-	if (source.startsWith('variants.')) {
-		return filterVariants(source, exprFunc)
+	if (source.startsWith("variants.")) {
+		return filterVariants(source, exprFunc);
 	}
-	return filterProduct(source, exprFunc)
-}
+	return filterProduct(source, exprFunc);
+};
 
 const getLexer = (value: string) =>
 	new Lexer(value)
-		.token('MISSING', /missing(?![-_a-z0-9]+)/i)
-		.token('EXISTS', /exists(?![-_a-z0-9]+)/i)
-		.token('RANGE', /range(?![-_a-z0-9]+)/i)
-		.token('TO', /to(?![-_a-z0-9]+)/i)
-		.token('IDENTIFIER', /[-_.a-z]+/i)
-
-		.token('FLOAT', /\d+\.\d+/)
-		.token('INT', /\d+/)
-		.token('STRING', /"((?:\\.|[^"\\])*)"/)
-		.token('STRING', /'((?:\\.|[^'\\])*)'/)
-
-		.token('COMMA', ',')
-		.token('STAR', '*')
-		.token('(', '(')
-		.token(':', ':')
-		.token(')', ')')
+		.token("MISSING", /missing(?![-_a-z0-9]+)/i)
+		.token("EXISTS", /exists(?![-_a-z0-9]+)/i)
+		.token("RANGE", /range(?![-_a-z0-9]+)/i)
+		.token("TO", /to(?![-_a-z0-9]+)/i)
+		.token("IDENTIFIER", /[-_.a-z]+/i)
+
+		.token("FLOAT", /\d+\.\d+/)
+		.token("INT", /\d+/)
+		.token("STRING", /"((?:\\.|[^"\\])*)"/)
+		.token("STRING", /'((?:\\.|[^'\\])*)'/)
+
+		.token("COMMA", ",")
+		.token("STAR", "*")
+		.token("(", "(")
+		.token(":", ":")
+		.token(")", ")")
 		.token('"', '"')
-		.token('WS', /\s+/, true) // skip
+		.token("WS", /\s+/, true); // skip
 
 const parseFilter = (filter: string): ExpressionSet => {
-	const lexer = getLexer(filter)
+	const lexer = getLexer(filter);
 	const parser = new Parser(lexer)
 		.builder()
-		.nud('IDENTIFIER', 100, (t) => t.token.match)
-		.led(':', 100, ({ left, bp }) => {
-			const parsed: any = parser.parse({ terminals: [bp - 1] })
+		.nud("IDENTIFIER", 100, (t) => t.token.match)
+		.led(":", 100, ({ left, bp }) => {
+			const parsed: any = parser.parse({ terminals: [bp - 1] });
 			const expressions: RangeExpression[] | FilterExpression[] | TypeSymbol[] =
-				!Array.isArray(parsed) ? [parsed] : parsed
+				!Array.isArray(parsed) ? [parsed] : parsed;
 
 			// Make sure we only have one type of expression (cannot mix)
-			const unique = new Set(expressions.map((expr) => expr.type))
+			const unique = new Set(expressions.map((expr) => expr.type));
 			if (unique.size > 1) {
-				throw new Error('Invalid expression')
+				throw new Error("Invalid expression");
 			}
 
 			// Convert plain symbols to a filter expression. For example
 			// variants.attribute.foobar:4 where 4 is a Symbol should result
 			// in a comparison
-			if (expressions.some((expr) => expr.type == 'Symbol')) {
+			if (expressions.some((expr) => expr.type == "Symbol")) {
 				return {
 					source: left as string,
-					type: 'FilterExpression',
+					type: "FilterExpression",
 					children: expressions.map((e): FilterExpression => {
-						if (e.type != 'Symbol') {
-							throw new Error('Invalid expression')
+						if (e.type != "Symbol") {
+							throw new Error("Invalid expression");
 						}
 
 						return {
-							type: 'FilterExpression',
+							type: "FilterExpression",
 							match: (obj: any): boolean => obj === e.value,
-						}
+						};
 					}),
-				}
+				};
 			}
 
 			return {
 				source: left,
 				type: expressions[0].type,
 				children: expressions,
-			}
+			};
 		})
 		.nud(
-			'STRING',
+			"STRING",
 			20,
 			(t) =>
 				({
-					type: 'Symbol',
-					kind: 'string',
+					type: "Symbol",
+					kind: "string",
 					// @ts-ignore
 					value: t.token.groups[1],
-				}) as TypeSymbol
+				}) as TypeSymbol,
 		)
 		.nud(
-			'INT',
+			"INT",
 			5,
 			(t) =>
 				({
-					type: 'Symbol',
-					kind: 'int',
+					type: "Symbol",
+					kind: "int",
 					value: parseInt(t.token.match, 10),
-				}) as TypeSymbol
+				}) as TypeSymbol,
 		)
-		.nud('STAR', 5, (_) => ({
-			type: 'Symbol',
-			kind: 'any',
+		.nud("STAR", 5, (_) => ({
+			type: "Symbol",
+			kind: "any",
 			value: null,
 		}))
 		.nud(
-			'EXISTS',
+			"EXISTS",
 			10,
 			({ bp }) =>
 				({
-					type: 'FilterExpression',
+					type: "FilterExpression",
 					match: (obj: any): boolean => obj !== undefined,
-				}) as FilterExpression
+				}) as FilterExpression,
 		)
 		.nud(
-			'MISSING',
+			"MISSING",
 			10,
 			({ bp }) =>
 				({
-					type: 'FilterExpression',
+					type: "FilterExpression",
 					match: (obj: any): boolean => obj === undefined,
-				}) as FilterExpression
+				}) as FilterExpression,
 		)
-		.led('COMMA', 200, ({ left, token, bp }) => {
-			const expr: any = parser.parse({ terminals: [bp - 1] })
+		.led("COMMA", 200, ({ left, token, bp }) => {
+			const expr: any = parser.parse({ terminals: [bp - 1] });
 			if (Array.isArray(expr)) {
-				return [left, ...expr]
+				return [left, ...expr];
 			} else {
-				return [left, expr]
+				return [left, expr];
 			}
 		})
-		.nud('(', 100, (t) => {
-			const expr: any = parser.parse({ terminals: [')'] })
-			lexer.expect(')')
-			return expr
+		.nud("(", 100, (t) => {
+			const expr: any = parser.parse({ terminals: [")"] });
+			lexer.expect(")");
+			return expr;
 		})
-		.bp(')', 0)
-		.led('TO', 20, ({ left, bp }) => {
-			const expr: any = parser.parse({ terminals: [bp - 1] })
+		.bp(")", 0)
+		.led("TO", 20, ({ left, bp }) => {
+			const expr: any = parser.parse({ terminals: [bp - 1] });
 			return {
 				start: left.value,
 				stop: expr.value,
-			}
+			};
 		})
-		.nud('RANGE', 20, ({ bp }) => {
-			let ranges: any = parser.parse()
+		.nud("RANGE", 20, ({ bp }) => {
+			let ranges: any = parser.parse();
 
 			// If multiple ranges are defined we receive an array of ranges. So let's
 			// make sure we always have an array
 			if (!Array.isArray(ranges)) {
-				ranges = [ranges]
+				ranges = [ranges];
 			}
 
 			// Return a list of functions which matches the ranges. These functions
 			// are processed as an OR clause
 			return ranges.map((range: any) => {
-				let func: (obj: any) => boolean
+				let func: (obj: any) => boolean;
 
 				if (range.start !== null && range.stop !== null) {
-					func = (obj: any): boolean => obj >= range.start && obj <= range.stop
+					func = (obj: any): boolean => obj >= range.start && obj <= range.stop;
 				} else if (range.start === null && range.stop !== null) {
-					func = (obj: any): boolean => obj <= range.stop
+					func = (obj: any): boolean => obj <= range.stop;
 				} else if (range.start !== null && range.stop === null) {
-					func = (obj: any): boolean => obj >= range.start
+					func = (obj: any): boolean => obj >= range.start;
 				} else {
-					func = (obj: any): boolean => true
+					func = (obj: any): boolean => true;
 				}
 
 				return {
-					type: 'RangeExpression',
+					type: "RangeExpression",
 					start: range.start,
 					stop: range.stop,
 					match: func,
-				} as RangeExpression
-			})
+				} as RangeExpression;
+			});
 		})
-		.build()
+		.build();
 
-	return parser.parse()
-}
+	return parser.parse();
+};
 
 const generateMatchFunc = (filter: string) => {
-	const result = parseFilter(filter)
+	const result = parseFilter(filter);
 	if (!result) {
 		// const lines = filter.split('\n')
 		// const column = lines[lines.length - 1].length
-		throw new Error(`Syntax error while parsing '${filter}'.`)
+		throw new Error(`Syntax error while parsing '${filter}'.`);
 	}
-	if (result.type == 'TermExpression') {
-		throw new Error(`Syntax error while parsing '${filter}'.`)
+	if (result.type == "TermExpression") {
+		throw new Error(`Syntax error while parsing '${filter}'.`);
 	}
 
 	return (obj: any) => {
-		if (!result.children) return false
-		return result.children.some((c) => c.match(obj))
-	}
-}
+		if (!result.children) return false;
+		return result.children.some((c) => c.match(obj));
+	};
+};
 
 export const generateFacetFunc = (filter: string): ExpressionSet => {
-	if (!filter.includes(':')) {
+	if (!filter.includes(":")) {
 		return {
 			source: filter,
-			type: 'TermExpression',
-		}
+			type: "TermExpression",
+		};
 	}
-	return parseFilter(filter)
-}
+	return parseFilter(filter);
+};
 
 const filterProduct =
 	(source: string, exprFunc: MatchFunc): ProductProjectionFilter =>
 	(p: ProductProjection, markMatchingVariants: boolean): boolean => {
-		const value = nestedLookup(p, source)
-		return exprFunc(value)
-	}
+		const value = nestedLookup(p, source);
+		return exprFunc(value);
+	};
 
 const filterVariants =
 	(source: string, exprFunc: MatchFunc): ProductProjectionFilter =>
 	(p: ProductProjection, markMatchingVariants: boolean): boolean => {
-		const [, ...paths] = source.split('.')
-		const path = paths.join('.')
+		const [, ...paths] = source.split(".");
+		const path = paths.join(".");
 
-		const variants = getVariants(p) as Writable<ProductVariant>[]
+		const variants = getVariants(p) as Writable<ProductVariant>[];
 		for (const variant of variants) {
-			const value = resolveVariantValue(variant, path)
+			const value = resolveVariantValue(variant, path);
 
 			if (exprFunc(value)) {
 				// If markMatchingVariants parameter is true those ProductVariants that
@@ -288,47 +288,49 @@ const filterVariants =
 				// set to true. For the other variants in the same product projection
 				// this field is set to false.
 				if (markMatchingVariants) {
-					variants.forEach((v) => (v.isMatchingVariant = false))
-					variant.isMatchingVariant = true
+					for (const v of variants) {
+						v.isMatchingVariant = false;
+					}
+					variant.isMatchingVariant = true;
 				}
-				return true
+				return true;
 			}
 		}
 
-		return false
-	}
+		return false;
+	};
 
 export const resolveVariantValue = (obj: ProductVariant, path: string): any => {
 	if (path === undefined) {
-		return obj
+		return obj;
 	}
-	if (path.startsWith('variants.')) {
-		path = path.substring(path.indexOf('.') + 1)
+	if (path.startsWith("variants.")) {
+		path = path.substring(path.indexOf(".") + 1);
 	}
 
-	if (path.startsWith('attributes.')) {
-		const [, attrName, ...rest] = path.split('.')
+	if (path.startsWith("attributes.")) {
+		const [, attrName, ...rest] = path.split(".");
 		if (!obj.attributes) {
-			return undefined
+			return undefined;
 		}
 
 		for (const attr of obj.attributes) {
 			if (attr.name === attrName) {
-				return nestedLookup(attr.value, rest.join('.'))
+				return nestedLookup(attr.value, rest.join("."));
 			}
 		}
 	}
 
-	if (path === 'price.centAmount') {
+	if (path === "price.centAmount") {
 		return obj.prices && obj.prices.length > 0
 			? obj.prices[0].value.centAmount
-			: undefined
+			: undefined;
 	}
 
-	return nestedLookup(obj, path)
-}
+	return nestedLookup(obj, path);
+};
 
 export const getVariants = (p: ProductProjection): ProductVariant[] => [
 	p.masterVariant,
 	...(p.variants ?? []),
-]
+];

package/src/lib/proxy.ts

@@ -1,12 +1,12 @@
 export const copyHeaders = (headers: Headers) => {
-	const validHeaders = ['accept', 'host', 'authorization', 'content-type']
-	const result: Record<string, string> = {}
+	const validHeaders = ["accept", "host", "authorization", "content-type"];
+	const result: Record<string, string> = {};
 
 	for (const [key, value] of headers.entries()) {
 		if (validHeaders.includes(key.toLowerCase())) {
-			result[key] = value
+			result[key] = value;
 		}
 	}
 
-	return result
-}
+	return result;
+};

package/src/oauth/errors.ts

@@ -1,9 +1,9 @@
 export interface InvalidClientError {
-	readonly code: 'invalid_client'
-	readonly message: string
+	readonly code: "invalid_client";
+	readonly message: string;
 }
 
 export interface UnsupportedGrantType {
-	readonly code: 'unsupported_grant_type'
-	readonly message: string
+	readonly code: "unsupported_grant_type";
+	readonly message: string;
 }

package/src/oauth/helpers.ts

@@ -1,10 +1,10 @@
-import { Request } from 'express'
+import { Request } from "express";
 
 export const getBearerToken = (request: Request): string | undefined => {
-	const authHeader = request.header('Authorization')
-	const match = authHeader?.match(/^Bearer\s(?<token>[^\s]+)$/)
+	const authHeader = request.header("Authorization");
+	const match = authHeader?.match(/^Bearer\s(?<token>[^\s]+)$/);
 	if (match) {
-		return match.groups?.token
+		return match.groups?.token;
 	}
-	return undefined
-}
+	return undefined;
+};