@labdigital/commercetools-mock 2.17.0 → 2.18.0

package/src/oauth/store.ts

@@ -1,79 +1,84 @@
-import { randomBytes } from 'crypto'
-import { v4 as uuidv4 } from 'uuid'
+import { randomBytes } from "crypto";
+import { v4 as uuidv4 } from "uuid";
 
 type Token = {
-	access_token: string
-	token_type: 'Bearer'
-	expires_in: number
-	scope: string
-	refresh_token?: string
-}
+	access_token: string;
+	token_type: "Bearer";
+	expires_in: number;
+	scope: string;
+	refresh_token?: string;
+};
 
 export class OAuth2Store {
-	tokens: Token[] = []
-	validate = true
+	tokens: Token[] = [];
+
+	validate = true;
 
 	constructor(validate = true) {
-		this.validate = validate
+		this.validate = validate;
 	}
 
 	addToken(token: Token) {
-		this.tokens.push(token)
+		this.tokens.push(token);
 	}
 
 	getClientToken(clientId: string, clientSecret: string, scope?: string) {
 		const token: Token = {
-			access_token: randomBytes(16).toString('base64'),
-			token_type: 'Bearer',
+			access_token: randomBytes(16).toString("base64"),
+			token_type: "Bearer",
 			expires_in: 172800,
-			scope: scope || 'todo',
-			refresh_token: `my-project-${randomBytes(16).toString('base64')}`,
-		}
-		this.addToken(token)
-		return token
+			scope: scope || "todo",
+			refresh_token: `my-project-${randomBytes(16).toString("base64")}`,
+		};
+		this.addToken(token);
+		return token;
 	}
 
-	getAnonymousToken(scope: string, anonymousId: string | undefined) {
+	getAnonymousToken(
+		projectKey: string,
+		anonymousId: string | undefined,
+		scope: string,
+	) {
 		if (!anonymousId) {
-			anonymousId = uuidv4()
+			anonymousId = uuidv4();
 		}
 		const token: Token = {
-			access_token: randomBytes(16).toString('base64'),
-			token_type: 'Bearer',
+			access_token: randomBytes(16).toString("base64"),
+			token_type: "Bearer",
 			expires_in: 172800,
 			scope: scope
 				? `${scope} anonymous_id:${anonymousId}`
 				: `anonymous_id:${anonymousId}`,
-			refresh_token: `my-project-${randomBytes(16).toString('base64')}`,
-		}
-		this.addToken(token)
-		return token
+			refresh_token: `${projectKey}:${randomBytes(16).toString("base64")}`,
+		};
+		this.addToken(token);
+		return token;
 	}
 
-	getCustomerToken(scope: string, customerId: string) {
+	getCustomerToken(projectKey: string, customerId: string, scope: string) {
 		const token: Token = {
-			access_token: randomBytes(16).toString('base64'),
-			token_type: 'Bearer',
+			access_token: randomBytes(16).toString("base64"),
+			token_type: "Bearer",
 			expires_in: 172800,
 			scope: scope
 				? `${scope} customer_id:${customerId}`
 				: `customer_id:${customerId}`,
-			refresh_token: `my-project-${randomBytes(16).toString('base64')}`,
-		}
-		this.addToken(token)
-		return token
+			refresh_token: `${projectKey}:${randomBytes(16).toString("base64")}`,
+		};
+		this.addToken(token);
+		return token;
 	}
 
 	refreshToken(clientId: string, clientSecret: string, refreshToken: string) {
-		const existing = this.tokens.find((t) => t.refresh_token === refreshToken)
+		const existing = this.tokens.find((t) => t.refresh_token === refreshToken);
 		if (!existing) {
-			return undefined
+			return undefined;
 		}
 		const token: Token = {
 			...existing,
-			access_token: randomBytes(16).toString('base64'),
-		}
-		this.addToken(token)
+			access_token: randomBytes(16).toString("base64"),
+		};
+		this.addToken(token);
 
 		// We don't want to return the refresh_token again
 		return {
@@ -81,16 +86,16 @@ export class OAuth2Store {
 			token_type: token.token_type,
 			expires_in: token.expires_in,
 			scope: token.scope,
-		}
+		};
 	}
 
 	validateToken(token: string) {
-		if (!this.validate) return true
+		if (!this.validate) return true;
 
-		const foundToken = this.tokens.find((t) => t.access_token === token)
+		const foundToken = this.tokens.find((t) => t.access_token === token);
 		if (foundToken) {
-			return true
+			return true;
 		}
-		return false
+		return false;
 	}
 }

package/src/priceSelector.test.ts

@@ -1,78 +1,78 @@
-import type { ProductProjection } from '@commercetools/platform-sdk'
-import { beforeEach, describe, expect, test } from 'vitest'
-import { applyPriceSelector } from './priceSelector.js'
+import type { ProductProjection } from "@commercetools/platform-sdk";
+import { beforeEach, describe, expect, test } from "vitest";
+import { applyPriceSelector } from "./priceSelector";
 
-describe('priceSelector', () => {
-	let product: ProductProjection
+describe("priceSelector", () => {
+	let product: ProductProjection;
 
 	beforeEach(() => {
 		product = {
-			id: '7401d82f-1378-47ba-996a-85beeb87ac87',
+			id: "7401d82f-1378-47ba-996a-85beeb87ac87",
 			version: 2,
-			createdAt: '2022-07-22T10:02:40.851Z',
-			lastModifiedAt: '2022-07-22T10:02:44.427Z',
+			createdAt: "2022-07-22T10:02:40.851Z",
+			lastModifiedAt: "2022-07-22T10:02:44.427Z",
 			productType: {
-				typeId: 'product-type',
-				id: 'b9b4b426-938b-4ccb-9f36-c6f933e8446e',
+				typeId: "product-type",
+				id: "b9b4b426-938b-4ccb-9f36-c6f933e8446e",
 			},
 			name: {
-				'nl-NL': 'test',
+				"nl-NL": "test",
 			},
 			slug: {
-				'nl-NL': 'test',
+				"nl-NL": "test",
 			},
 			variants: [],
 			searchKeywords: {},
 			categories: [],
 			masterVariant: {
 				id: 1,
-				sku: 'MYSKU',
+				sku: "MYSKU",
 				attributes: [
 					{
-						name: 'Country',
+						name: "Country",
 						value: {
-							key: 'NL',
+							key: "NL",
 							label: {
-								de: 'niederlande',
-								en: 'netherlands',
-								nl: 'nederland',
+								de: "niederlande",
+								en: "netherlands",
+								nl: "nederland",
 							},
 						},
 					},
 					{
-						name: 'number',
+						name: "number",
 						value: 4,
 					},
 				],
 				prices: [
 					{
-						id: 'dummy-uuid',
+						id: "dummy-uuid",
 						value: {
-							type: 'centPrecision',
-							currencyCode: 'EUR',
+							type: "centPrecision",
+							currencyCode: "EUR",
 							centAmount: 1789,
 							fractionDigits: 2,
 						},
 					},
 				],
 			},
-		}
-	})
+		};
+	});
 
-	test('currency (match)', async () => {
-		applyPriceSelector([product], { currency: 'EUR' })
+	test("currency (match)", async () => {
+		applyPriceSelector([product], { currency: "EUR" });
 
 		expect(product).toMatchObject({
 			masterVariant: {
-				sku: 'MYSKU',
+				sku: "MYSKU",
 				scopedPrice: { value: { centAmount: 1789 } },
 			},
-		})
-	})
+		});
+	});
 
-	test('currency, country (no match)', async () => {
-		applyPriceSelector([product], { currency: 'EUR', country: 'US' })
-		expect(product.masterVariant.scopedPrice).toBeUndefined()
-		expect(product.masterVariant.scopedPrice).toBeUndefined()
-	})
-})
+	test("currency, country (no match)", async () => {
+		applyPriceSelector([product], { currency: "EUR", country: "US" });
+		expect(product.masterVariant.scopedPrice).toBeUndefined();
+		expect(product.masterVariant.scopedPrice).toBeUndefined();
+	});
+});

package/src/priceSelector.ts

@@ -3,16 +3,16 @@ import type {
 	Price,
 	ProductProjection,
 	ProductVariant,
-} from '@commercetools/platform-sdk'
-import { CommercetoolsError } from './exceptions.js'
-import type { Writable } from './types.js'
+} from "@commercetools/platform-sdk";
+import { CommercetoolsError } from "./exceptions";
+import type { Writable } from "./types";
 
 export type PriceSelector = {
-	currency?: string
-	country?: string
-	customerGroup?: string
-	channel?: string
-}
+	currency?: string;
+	country?: string;
+	customerGroup?: string;
+	channel?: string;
+};
 
 /**
  * Apply the price selector on all the variants. The price selector is applied
@@ -22,36 +22,36 @@ export type PriceSelector = {
 export const applyPriceSelector = (
 	products: ProductProjection[],
 	selector: PriceSelector,
-	noScopedPrice: boolean = false
+	noScopedPrice: boolean = false,
 ) => {
-	validatePriceSelector(selector)
+	validatePriceSelector(selector);
 
 	for (const product of products) {
 		// Get list of all variants (master + variants)
 		const variants: Writable<ProductVariant>[] = [
 			product.masterVariant,
 			...(product.variants ?? []),
-		].filter((x) => x != undefined)
+		].filter((x) => x != undefined);
 
 		for (const variant of variants) {
 			const scopedPrices =
-				variant.prices?.filter((p) => priceSelectorFilter(p, selector)) ?? []
+				variant.prices?.filter((p) => priceSelectorFilter(p, selector)) ?? [];
 
 			if (scopedPrices.length > 0) {
-				const price = scopedPrices[0]
+				const price = scopedPrices[0];
 
-				variant.price = scopedPrices[0]
+				variant.price = scopedPrices[0];
 				if (!noScopedPrice) {
-					variant.scopedPriceDiscounted = false
+					variant.scopedPriceDiscounted = false;
 					variant.scopedPrice = {
 						...price,
 						currentValue: price.value,
-					}
+					};
 				}
 			}
 		}
 	}
-}
+};
 
 const validatePriceSelector = (selector: PriceSelector) => {
 	if (
@@ -60,15 +60,15 @@ const validatePriceSelector = (selector: PriceSelector) => {
 	) {
 		throw new CommercetoolsError<InvalidInputError>(
 			{
-				code: 'InvalidInput',
+				code: "InvalidInput",
 				message:
-					'The price selecting parameters country, channel and customerGroup ' +
-					'cannot be used without the currency.',
+					"The price selecting parameters country, channel and customerGroup " +
+					"cannot be used without the currency.",
 			},
-			400
-		)
+			400,
+		);
 	}
-}
+};
 
 /**
  * Return a boolean to indicate if the price matches the selector. Price
@@ -77,35 +77,35 @@ const validatePriceSelector = (selector: PriceSelector) => {
  */
 export const priceSelectorFilter = (
 	price: Price,
-	selector: PriceSelector
+	selector: PriceSelector,
 ): boolean => {
 	if (
 		(selector.country || price.country) &&
 		selector.country !== price.country
 	) {
-		return false
+		return false;
 	}
 
 	if (
 		(selector.currency || price.value.currencyCode) &&
 		selector.currency !== price.value.currencyCode
 	) {
-		return false
+		return false;
 	}
 
 	if (
 		(selector.channel || price.channel?.id) &&
 		selector.channel !== price.channel?.id
 	) {
-		return false
+		return false;
 	}
 
 	if (
 		(selector.customerGroup || price.customerGroup?.id) &&
 		selector.customerGroup !== price.customerGroup?.id
 	) {
-		return false
+		return false;
 	}
 
-	return true
-}
+	return true;
+};