@labdigital/commercetools-mock 2.17.1 → 2.18.1

package/src/helpers.ts

@@ -1,79 +1,79 @@
-import { OutgoingHttpHeaders } from 'node:http'
-import { ParsedQs } from 'qs'
-import { v4 as uuidv4 } from 'uuid'
+import { OutgoingHttpHeaders } from "node:http";
+import { ParsedQs } from "qs";
+import { v4 as uuidv4 } from "uuid";
 
 export const getBaseResourceProperties = () => ({
 	id: uuidv4(),
 	createdAt: new Date().toISOString(),
 	lastModifiedAt: new Date().toISOString(),
 	version: 0,
-})
+});
 
 /**
  * Do a nested lookup by using a path. For example `foo.bar.value` will
  * return obj['foo']['bar']['value']
  */
 export const nestedLookup = (obj: any, path: string): any => {
-	if (!path || path === '') {
-		return obj
+	if (!path || path === "") {
+		return obj;
 	}
 
-	const parts = path.split('.')
-	let val = obj
+	const parts = path.split(".");
+	let val = obj;
 
 	for (let i = 0; i < parts.length; i++) {
-		const part = parts[i]
+		const part = parts[i];
 		if (val == undefined) {
-			return undefined
+			return undefined;
 		}
 
-		val = val[part]
+		val = val[part];
 	}
 
-	return val
-}
+	return val;
+};
 
 export const queryParamsArray = (
-	input: string | ParsedQs | string[] | ParsedQs[] | undefined
+	input: string | ParsedQs | string[] | ParsedQs[] | undefined,
 ): string[] | undefined => {
 	if (input == undefined) {
-		return undefined
+		return undefined;
 	}
 
 	const values: string[] = Array.isArray(input)
 		? (input as string[])
-		: ([input] as string[])
+		: ([input] as string[]);
 	if (values.length < 1) {
-		return undefined
+		return undefined;
 	}
-	return values
-}
+	return values;
+};
 
 export const queryParamsValue = (
-	value: string | ParsedQs | string[] | ParsedQs[] | undefined
+	value: string | ParsedQs | string[] | ParsedQs[] | undefined,
 ): string | undefined => {
-	const values = queryParamsArray(value)
+	const values = queryParamsArray(value);
 	if (values && values.length > 0) {
-		return values[0]
+		return values[0];
 	}
-	return undefined
-}
+	return undefined;
+};
 
-export const cloneObject = <T>(o: T): T => JSON.parse(JSON.stringify(o))
+export const cloneObject = <T>(o: T): T => JSON.parse(JSON.stringify(o));
 
 export const mapHeaderType = (
-	outgoingHttpHeaders: OutgoingHttpHeaders
+	outgoingHttpHeaders: OutgoingHttpHeaders,
 ): HeadersInit => {
-	const headersInit: HeadersInit = {}
+	const headersInit: HeadersInit = {};
 	for (const key in outgoingHttpHeaders) {
-		const value = outgoingHttpHeaders[key]
+		const value = outgoingHttpHeaders[key];
 		if (Array.isArray(value)) {
 			// Join multiple values for the same header with a comma
-			headersInit[key] = value.join(', ')
+			headersInit[key] = value.join(", ");
 		} else if (value !== undefined) {
 			// Single value or undefined
-			headersInit[key] = value.toString()
+			headersInit[key] = value.toString();
 		}
 	}
-	return headersInit
-}
+	return headersInit;
+};

package/src/index.test.ts

@@ -1,238 +1,238 @@
-import { type InvalidTokenError } from '@commercetools/platform-sdk'
-import { CommercetoolsMock } from './index.js'
-import { expect, test } from 'vitest'
-import got from 'got'
+import { type InvalidTokenError } from "@commercetools/platform-sdk";
+import got from "got";
+import { expect, test } from "vitest";
+import { CommercetoolsMock } from "./index";
 
-test('node:fetch client', async () => {
+test("node:fetch client", async () => {
 	const ctMock = new CommercetoolsMock({
 		enableAuthentication: true,
 		validateCredentials: true,
-		apiHost: 'https://localhost',
-		authHost: 'https://localhost:8080',
-	})
-	ctMock.start()
-
-	const authHeader = 'Basic ' + Buffer.from('foo:bar').toString('base64')
-	let response = await fetch('https://localhost:8080/oauth/token', {
-		method: 'POST',
+		apiHost: "https://localhost",
+		authHost: "https://localhost:8080",
+	});
+	ctMock.start();
+
+	const authHeader = "Basic " + Buffer.from("foo:bar").toString("base64");
+	let response = await fetch("https://localhost:8080/oauth/token", {
+		method: "POST",
 		headers: {
-			'Content-Type': 'application/x-www-form-urlencoded',
-			Authorization: authHeader,
+			"Content-Type": "application/x-www-form-urlencoded",
+			"Authorization": authHeader,
 		},
 		body: new URLSearchParams({
-			grant_type: 'client_credentials',
-			scope: 'manage_project:commercetools-node-mock',
+			grant_type: "client_credentials",
+			scope: "manage_project:commercetools-node-mock",
 		}),
-	})
+	});
 
-	const authBody = await response.json()
-	expect(response.status).toBe(200)
+	const authBody = await response.json();
+	expect(response.status).toBe(200);
 
-	const token = authBody.access_token
-	response = await fetch('https://localhost/my-project/orders', {
+	const token = authBody.access_token;
+	response = await fetch("https://localhost/my-project/orders", {
 		headers: {
 			Authorization: `Bearer ${token}`,
 		},
-	})
+	});
 
-	const body = await response.json()
-	expect(response.status).toBe(200)
+	const body = await response.json();
+	expect(response.status).toBe(200);
 	expect(body).toStrictEqual({
 		count: 0,
 		total: 0,
 		offset: 0,
 		limit: 20,
 		results: [],
-	})
-	ctMock.stop()
-})
+	});
+	ctMock.stop();
+});
 
-test('got client', async () => {
+test("got client", async () => {
 	const ctMock = new CommercetoolsMock({
 		enableAuthentication: true,
 		validateCredentials: true,
-		apiHost: 'https://localhost',
-		authHost: 'https://localhost:8080',
-	})
-	ctMock.start()
+		apiHost: "https://localhost",
+		authHost: "https://localhost:8080",
+	});
+	ctMock.start();
 
 	let response = await got.post<{ access_token: string }>(
-		'https://localhost:8080/oauth/token',
+		"https://localhost:8080/oauth/token",
 		{
 			searchParams: {
-				grant_type: 'client_credentials',
-				scope: 'manage_project:commercetools-node-mock',
+				grant_type: "client_credentials",
+				scope: "manage_project:commercetools-node-mock",
 			},
-			username: 'foo',
-			password: 'bar',
-			responseType: 'json',
-		}
-	)
-	expect(response.statusCode).toBe(200)
-
-	const token = response.body.access_token
-	expect(response.body.access_token).toBeDefined()
-	response = await got.get('https://localhost/my-project/orders', {
+			username: "foo",
+			password: "bar",
+			responseType: "json",
+		},
+	);
+	expect(response.statusCode).toBe(200);
+
+	const token = response.body.access_token;
+	expect(response.body.access_token).toBeDefined();
+	response = await got.get("https://localhost/my-project/orders", {
 		headers: {
 			Authorization: `Bearer ${token}`,
 		},
-		responseType: 'json',
-	})
-	expect(response.statusCode).toBe(200)
+		responseType: "json",
+	});
+	expect(response.statusCode).toBe(200);
 	expect(response.body).toStrictEqual({
 		count: 0,
 		total: 0,
 		offset: 0,
 		limit: 20,
 		results: [],
-	})
-	ctMock.stop()
-})
+	});
+	ctMock.stop();
+});
 
-test('Options.validateCredentials: true (error)', async () => {
+test("Options.validateCredentials: true (error)", async () => {
 	const ctMock = new CommercetoolsMock({
 		enableAuthentication: true,
 		validateCredentials: true,
-	})
-	ctMock.start()
+	});
+	ctMock.start();
 
 	const response = await got.get<InvalidTokenError>(
-		'https://api.europe-west1.gcp.commercetools.com/my-project/orders',
+		"https://api.europe-west1.gcp.commercetools.com/my-project/orders",
 		{
 			headers: {
 				Authorization: `Bearer foobar`,
 			},
-			responseType: 'json',
+			responseType: "json",
 			throwHttpErrors: false,
-		}
-	)
-	expect(response.statusCode).toBe(401)
-	expect(response.body.message).toBe('invalid_token')
-	ctMock.stop()
-})
-
-test('Options.validateCredentials: false', async () => {
+		},
+	);
+	expect(response.statusCode).toBe(401);
+	expect(response.body.message).toBe("invalid_token");
+	ctMock.stop();
+});
+
+test("Options.validateCredentials: false", async () => {
 	const ctMock = new CommercetoolsMock({
 		enableAuthentication: true,
 		validateCredentials: false,
-	})
-	ctMock.start()
+	});
+	ctMock.start();
 
 	const response = await got.get(
-		'https://api.europe-west1.gcp.commercetools.com/my-project/orders',
+		"https://api.europe-west1.gcp.commercetools.com/my-project/orders",
 		{
 			headers: {
 				Authorization: `Bearer foobar`,
 			},
-			responseType: 'json',
-		}
-	)
-	expect(response.statusCode).toBe(200)
+			responseType: "json",
+		},
+	);
+	expect(response.statusCode).toBe(200);
 	expect(response.body).toStrictEqual({
 		count: 0,
 		total: 0,
 		offset: 0,
 		limit: 20,
 		results: [],
-	})
-	ctMock.stop()
-})
+	});
+	ctMock.stop();
+});
 
-test('Options.enableAuthentication: false', async () => {
+test("Options.enableAuthentication: false", async () => {
 	const ctMock = new CommercetoolsMock({
 		enableAuthentication: false,
 		validateCredentials: false,
-	})
-	ctMock.start()
+	});
+	ctMock.start();
 
 	const response = await got.get(
-		'https://api.europe-west1.gcp.commercetools.com/my-project/orders',
+		"https://api.europe-west1.gcp.commercetools.com/my-project/orders",
 		{
-			responseType: 'json',
-		}
-	)
-	expect(response.statusCode).toBe(200)
+			responseType: "json",
+		},
+	);
+	expect(response.statusCode).toBe(200);
 	expect(response.body).toStrictEqual({
 		count: 0,
 		total: 0,
 		offset: 0,
 		limit: 20,
 		results: [],
-	})
-	ctMock.stop()
-})
+	});
+	ctMock.stop();
+});
 
-test('Options.apiHost: is overridden is set', async () => {
+test("Options.apiHost: is overridden is set", async () => {
 	const ctMock = new CommercetoolsMock({
 		enableAuthentication: false,
 		validateCredentials: false,
-		apiHost: 'http://api.localhost',
-	})
-	ctMock.start()
-
-	const response = await got.get('http://api.localhost/my-project/orders', {
-		responseType: 'json',
-	})
-	expect(response.statusCode).toBe(200)
+		apiHost: "http://api.localhost",
+	});
+	ctMock.start();
+
+	const response = await got.get("http://api.localhost/my-project/orders", {
+		responseType: "json",
+	});
+	expect(response.statusCode).toBe(200);
 	expect(response.body).toStrictEqual({
 		count: 0,
 		total: 0,
 		offset: 0,
 		limit: 20,
 		results: [],
-	})
-	ctMock.stop()
-})
+	});
+	ctMock.stop();
+});
 
-test('Options.authHost: is set', async () => {
+test("Options.authHost: is set", async () => {
 	const ctMock = new CommercetoolsMock({
 		enableAuthentication: true,
 		validateCredentials: true,
-		authHost: 'http://auth.localhost',
-	})
-	ctMock.start()
+		authHost: "http://auth.localhost",
+	});
+	ctMock.start();
 
 	const response = await got.post<{ access_token: string }>(
-		'http://auth.localhost/oauth/token',
+		"http://auth.localhost/oauth/token",
 		{
 			searchParams: {
-				grant_type: 'client_credentials',
-				scope: 'manage_project:commercetools-node-mock',
+				grant_type: "client_credentials",
+				scope: "manage_project:commercetools-node-mock",
 			},
-			username: 'foo',
-			password: 'bar',
-			responseType: 'json',
-		}
-	)
-	expect(response.statusCode).toBe(200)
-
-	const token = response.body.access_token
-	expect(token).toBeDefined()
-})
-
-test('apiHost mock proxy: querystring', async () => {
+			username: "foo",
+			password: "bar",
+			responseType: "json",
+		},
+	);
+	expect(response.statusCode).toBe(200);
+
+	const token = response.body.access_token;
+	expect(token).toBeDefined();
+});
+
+test("apiHost mock proxy: querystring", async () => {
 	const ctMock = new CommercetoolsMock({
 		enableAuthentication: false,
 		validateCredentials: false,
-		apiHost: 'http://api.localhost',
-	})
-	ctMock.start()
+		apiHost: "http://api.localhost",
+	});
+	ctMock.start();
 
-	const response = await got.get('http://api.localhost/my-project/orders', {
-		responseType: 'json',
+	const response = await got.get("http://api.localhost/my-project/orders", {
+		responseType: "json",
 		searchParams: {
 			where: 'orderNumber="foobar"',
-			expand: 'custom.type',
+			expand: "custom.type",
 		},
-	})
+	});
 
-	expect(response.statusCode).toBe(200)
+	expect(response.statusCode).toBe(200);
 	expect(response.body).toStrictEqual({
 		count: 0,
 		total: 0,
 		offset: 0,
 		limit: 20,
 		results: [],
-	})
-	ctMock.stop()
-})
+	});
+	ctMock.stop();
+});

package/src/index.ts

@@ -1,8 +1,8 @@
-import { CommercetoolsMock, CommercetoolsMockOptions } from './ctMock.js'
-import { getBaseResourceProperties } from './helpers.js'
+import { CommercetoolsMock, CommercetoolsMockOptions } from "./ctMock";
+import { getBaseResourceProperties } from "./helpers";
 
 export {
 	CommercetoolsMock,
 	getBaseResourceProperties,
 	type CommercetoolsMockOptions,
-}
+};

package/src/lib/expandParser.ts

@@ -7,28 +7,28 @@
  * TODO: implement support for multi-dimensional array
  */
 type ExpandResult = {
-	element: string
-	index?: string | number
-	rest?: string
-}
+	element: string;
+	index?: string | number;
+	rest?: string;
+};
 
 export const parseExpandClause = (clause: string): ExpandResult => {
 	const result: ExpandResult = {
 		element: clause,
 		index: undefined,
 		rest: undefined,
-	}
+	};
 
-	const pos = clause.indexOf('.')
+	const pos = clause.indexOf(".");
 	if (pos > 0) {
-		result.element = clause.substring(0, pos)
-		result.rest = clause.substring(pos + 1)
+		result.element = clause.substring(0, pos);
+		result.rest = clause.substring(pos + 1);
 	}
 
-	const match = result.element.match(/\[([^\]+])]/)
+	const match = result.element.match(/\[([^\]+])]/);
 	if (match) {
-		result.index = match[1] === '*' ? '*' : parseInt(match[1], 10)
-		result.element = result.element.substring(0, match.index)
+		result.index = match[1] === "*" ? "*" : parseInt(match[1], 10);
+		result.element = result.element.substring(0, match.index);
 	}
-	return result
-}
+	return result;
+};

package/src/lib/haversine.test.ts

@@ -1,20 +1,20 @@
-import { expect, test } from 'vitest'
-import { haversineDistance, Location } from './haversine.js'
+import { expect, test } from "vitest";
+import { Location, haversineDistance } from "./haversine";
 
-test('haversine', () => {
+test("haversine", () => {
 	// Lab Digital
 	const src: Location = {
 		latitude: 5.110230209615395,
 		longitude: 52.06969591642097,
-	}
+	};
 
 	// Dom Tower
 	const dst: Location = {
 		latitude: 5.121310867198959,
 		longitude: 52.09068804569714,
-	}
+	};
 
-	const dist = haversineDistance(src, dst)
-	expect(dist).toBeGreaterThan(2631)
-	expect(dist).toBeLessThan(2632)
-})
+	const dist = haversineDistance(src, dst);
+	expect(dist).toBeGreaterThan(2631);
+	expect(dist).toBeLessThan(2632);
+});

package/src/lib/haversine.ts

@@ -1,24 +1,24 @@
 export type Location = {
-	latitude: number
-	longitude: number
-}
+	latitude: number;
+	longitude: number;
+};
 
 /**
  * Returns the distance between src and dst as meters
  */
 export const haversineDistance = (src: Location, dst: Location) => {
-	const RADIUS_OF_EARTH_IN_KM = 6371
-	const toRadian = (deg: number) => deg * (Math.PI / 180)
+	const RADIUS_OF_EARTH_IN_KM = 6371;
+	const toRadian = (deg: number) => deg * (Math.PI / 180);
 
-	const dLat = toRadian(dst.latitude - src.latitude)
-	const dLon = toRadian(dst.longitude - src.longitude)
+	const dLat = toRadian(dst.latitude - src.latitude);
+	const dLon = toRadian(dst.longitude - src.longitude);
 
 	const a =
 		Math.sin(dLat / 2) * Math.sin(dLat / 2) +
 		Math.cos(toRadian(src.latitude)) *
 			Math.cos(toRadian(dst.latitude)) *
 			Math.sin(dLon / 2) *
-			Math.sin(dLon / 2)
-	const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a))
-	return RADIUS_OF_EARTH_IN_KM * c * 1000
-}
+			Math.sin(dLon / 2);
+	const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+	return RADIUS_OF_EARTH_IN_KM * c * 1000;
+};

package/src/lib/masking.ts

@@ -1,22 +1,22 @@
-import { cloneObject } from '../helpers.js'
+import { cloneObject } from "../helpers";
 
 export const maskSecretValue = <T>(resource: T, path: string): T => {
-	const parts = path.split('.')
-	const clone = cloneObject(resource) as any
-	let val = clone
+	const parts = path.split(".");
+	const clone = cloneObject(resource) as any;
+	let val = clone;
 
-	const target = parts.pop()
+	const target = parts.pop();
 	for (let i = 0; i < parts.length; i++) {
-		const part = parts[i]
-		val = val[part]
+		const part = parts[i];
+		val = val[part];
 
 		if (val === undefined) {
-			return resource
+			return resource;
 		}
 	}
 
 	if (val && target && val[target]) {
-		val[target] = '****'
+		val[target] = "****";
 	}
-	return clone
-}
+	return clone;
+};

package/src/lib/parser.ts

@@ -1,2 +1,2 @@
-export { Lexer } from '~vendor/perplex/lexer.js'
-export { Parser, type ITokenPosition } from '~vendor/pratt/index.js'
+export { Lexer } from "~vendor/perplex/lexer";
+export { Parser, type ITokenPosition } from "~vendor/pratt";

package/src/lib/password.ts

@@ -1,7 +1,27 @@
+import { Customer } from "@commercetools/platform-sdk";
+import { v4 as uuidv4 } from "uuid";
+
+const PWRESET_SECRET = "pwreset";
+
 export const validatePassword = (
 	clearPassword: string,
-	hashedPassword: string
-) => hashPassword(clearPassword) === hashedPassword
+	hashedPassword: string,
+) => hashPassword(clearPassword) === hashedPassword;
 
 export const hashPassword = (clearPassword: string) =>
-	Buffer.from(clearPassword).toString('base64')
+	Buffer.from(clearPassword).toString("base64");
+
+export const createPasswordResetToken = (customer: Customer) =>
+	Buffer.from(`${customer.id}:${PWRESET_SECRET}:${uuidv4()}`).toString(
+		"base64",
+	);
+
+export const validatePasswordResetToken = (token: string) => {
+	const items = Buffer.from(token, "base64").toString("utf-8").split(":");
+	const [customerId, secret] = items;
+	if (secret !== PWRESET_SECRET) {
+		return undefined;
+	}
+
+	return customerId;
+};