@labdigital/commercetools-mock 1.5.0 → 1.6.0

package/src/oauth/server.ts

@@ -1,117 +1,119 @@
 import auth from 'basic-auth'
 import bodyParser from 'body-parser'
-import express, { type NextFunction, type Request, type Response } from 'express'
-import {
-  InvalidTokenError,
-} from '@commercetools/platform-sdk'
+import express, {
+	type NextFunction,
+	type Request,
+	type Response,
+} from 'express'
+import { InvalidTokenError } from '@commercetools/platform-sdk'
 import { CommercetoolsError, InvalidRequestError } from '../exceptions.js'
 import { InvalidClientError, UnsupportedGrantType } from './errors.js'
 import { OAuth2Store } from './store.js'
 import { getBearerToken } from './helpers.js'
 
 export class OAuth2Server {
-  store: OAuth2Store
+	store: OAuth2Store
 
-  constructor(options: { enabled: boolean; validate: boolean }) {
-    this.store = new OAuth2Store(options.validate)
-  }
+	constructor(options: { enabled: boolean; validate: boolean }) {
+		this.store = new OAuth2Store(options.validate)
+	}
 
-  createRouter() {
-    const router = express.Router()
-    router.use(bodyParser.urlencoded({ extended: true }))
-    router.post('/token', this.tokenHandler.bind(this))
-    return router
-  }
+	createRouter() {
+		const router = express.Router()
+		router.use(bodyParser.urlencoded({ extended: true }))
+		router.post('/token', this.tokenHandler.bind(this))
+		return router
+	}
 
-  createMiddleware() {
-    return async (request: Request, response: Response, next: NextFunction) => {
-      const token = getBearerToken(request)
-      if (!token) {
-        next(
-          new CommercetoolsError<InvalidTokenError>(
-            {
-              code: 'invalid_token',
-              message:
-                'This endpoint requires an access token. You can get one from the authorization server.',
-            },
-            401
-          )
-        )
-      }
+	createMiddleware() {
+		return async (request: Request, response: Response, next: NextFunction) => {
+			const token = getBearerToken(request)
+			if (!token) {
+				next(
+					new CommercetoolsError<InvalidTokenError>(
+						{
+							code: 'invalid_token',
+							message:
+								'This endpoint requires an access token. You can get one from the authorization server.',
+						},
+						401
+					)
+				)
+			}
 
-      if (!token || !this.store.validateToken(token)) {
-        next(
-          new CommercetoolsError<InvalidTokenError>(
-            {
-              code: 'invalid_token',
-              message: 'invalid_token',
-            },
-            401
-          )
-        )
-      }
+			if (!token || !this.store.validateToken(token)) {
+				next(
+					new CommercetoolsError<InvalidTokenError>(
+						{
+							code: 'invalid_token',
+							message: 'invalid_token',
+						},
+						401
+					)
+				)
+			}
 
-      next()
-    }
-  }
-  async tokenHandler(request: Request, response: Response, next: NextFunction) {
-    const authHeader = request.header('Authorization')
-    if (!authHeader) {
-      return next(
-        new CommercetoolsError<InvalidClientError>(
-          {
-            code: 'invalid_client',
-            message:
-              'Please provide valid client credentials using HTTP Basic Authentication.',
-          },
-          401
-        )
-      )
-    }
-    const credentials = auth.parse(authHeader)
-    if (!credentials) {
-      return next(
-        new CommercetoolsError<InvalidClientError>(
-          {
-            code: 'invalid_client',
-            message:
-              'Please provide valid client credentials using HTTP Basic Authentication.',
-          },
-          400
-        )
-      )
-    }
+			next()
+		}
+	}
+	async tokenHandler(request: Request, response: Response, next: NextFunction) {
+		const authHeader = request.header('Authorization')
+		if (!authHeader) {
+			return next(
+				new CommercetoolsError<InvalidClientError>(
+					{
+						code: 'invalid_client',
+						message:
+							'Please provide valid client credentials using HTTP Basic Authentication.',
+					},
+					401
+				)
+			)
+		}
+		const credentials = auth.parse(authHeader)
+		if (!credentials) {
+			return next(
+				new CommercetoolsError<InvalidClientError>(
+					{
+						code: 'invalid_client',
+						message:
+							'Please provide valid client credentials using HTTP Basic Authentication.',
+					},
+					400
+				)
+			)
+		}
 
-    const grantType = request.query.grant_type || request.body.grant_type
-    if (!grantType) {
-      return next(
-        new CommercetoolsError<InvalidRequestError>(
-          {
-            code: 'invalid_request',
-            message: 'Missing required parameter: grant_type.',
-          },
-          400
-        )
-      )
-    }
+		const grantType = request.query.grant_type || request.body.grant_type
+		if (!grantType) {
+			return next(
+				new CommercetoolsError<InvalidRequestError>(
+					{
+						code: 'invalid_request',
+						message: 'Missing required parameter: grant_type.',
+					},
+					400
+				)
+			)
+		}
 
-    if (grantType === 'client_credentials') {
-      const token = this.store.getClientToken(
-        credentials.name,
-        credentials.pass,
-        request.query.scope?.toString()
-      )
-      return response.status(200).send(token)
-    } else {
-      return next(
-        new CommercetoolsError<UnsupportedGrantType>(
-          {
-            code: 'unsupported_grant_type',
-            message: `Invalid parameter: grant_type: Invalid grant type: ${grantType}`,
-          },
-          400
-        )
-      )
-    }
-  }
+		if (grantType === 'client_credentials') {
+			const token = this.store.getClientToken(
+				credentials.name,
+				credentials.pass,
+				request.query.scope?.toString()
+			)
+			return response.status(200).send(token)
+		} else {
+			return next(
+				new CommercetoolsError<UnsupportedGrantType>(
+					{
+						code: 'unsupported_grant_type',
+						message: `Invalid parameter: grant_type: Invalid grant type: ${grantType}`,
+					},
+					400
+				)
+			)
+		}
+	}
 }

package/src/oauth/store.ts

@@ -1,38 +1,38 @@
 import { randomBytes } from 'crypto'
 
 type Token = {
-  access_token: string
-  token_type: 'Bearer'
-  expires_in: number
-  scope: string
+	access_token: string
+	token_type: 'Bearer'
+	expires_in: number
+	scope: string
 }
 
 export class OAuth2Store {
-  tokens: Token[] = []
-  validate = true
+	tokens: Token[] = []
+	validate = true
 
-  constructor(validate = true) {
-    this.validate = validate
-  }
+	constructor(validate = true) {
+		this.validate = validate
+	}
 
-  getClientToken(clientId: string, clientSecret: string, scope?: string) {
-    const token: Token = {
-      access_token: randomBytes(16).toString('base64'),
-      token_type: 'Bearer',
-      expires_in: 172800,
-      scope: scope || 'todo',
-    }
-    this.tokens.push(token)
-    return token
-  }
+	getClientToken(clientId: string, clientSecret: string, scope?: string) {
+		const token: Token = {
+			access_token: randomBytes(16).toString('base64'),
+			token_type: 'Bearer',
+			expires_in: 172800,
+			scope: scope || 'todo',
+		}
+		this.tokens.push(token)
+		return token
+	}
 
-  validateToken(token: string) {
-    if (!this.validate) return true
+	validateToken(token: string) {
+		if (!this.validate) return true
 
-    const foundToken = this.tokens.find((t) => t.access_token === token)
-    if (foundToken) {
-      return true
-    }
-    return false
-  }
+		const foundToken = this.tokens.find((t) => t.access_token === token)
+		if (foundToken) {
+			return true
+		}
+		return false
+	}
 }

package/src/priceSelector.test.ts

@@ -3,76 +3,76 @@ import { beforeEach, describe, expect, test } from 'vitest'
 import { applyPriceSelector } from './priceSelector.js'
 
 describe('priceSelector', () => {
-  let product: ProductProjection
+	let product: ProductProjection
 
-  beforeEach(() => {
-    product = {
-      id: '7401d82f-1378-47ba-996a-85beeb87ac87',
-      version: 2,
-      createdAt: '2022-07-22T10:02:40.851Z',
-      lastModifiedAt: '2022-07-22T10:02:44.427Z',
-      productType: {
-        typeId: 'product-type',
-        id: 'b9b4b426-938b-4ccb-9f36-c6f933e8446e',
-      },
-      name: {
-        'nl-NL': 'test',
-      },
-      slug: {
-        'nl-NL': '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,
-            },
-          },
-        ],
-      },
-    }
-  })
+	beforeEach(() => {
+		product = {
+			id: '7401d82f-1378-47ba-996a-85beeb87ac87',
+			version: 2,
+			createdAt: '2022-07-22T10:02:40.851Z',
+			lastModifiedAt: '2022-07-22T10:02:44.427Z',
+			productType: {
+				typeId: 'product-type',
+				id: 'b9b4b426-938b-4ccb-9f36-c6f933e8446e',
+			},
+			name: {
+				'nl-NL': 'test',
+			},
+			slug: {
+				'nl-NL': '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,
+						},
+					},
+				],
+			},
+		}
+	})
 
-  test('currency (match)', async () => {
-    applyPriceSelector([product], { currency: 'EUR' })
+	test('currency (match)', async () => {
+		applyPriceSelector([product], { currency: 'EUR' })
 
-    expect(product).toMatchObject({
-      masterVariant: {
-        sku: 'MYSKU',
-        scopedPrice: { value: { centAmount: 1789 } },
-      },
-    })
-  })
+		expect(product).toMatchObject({
+			masterVariant: {
+				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

@@ -1,17 +1,17 @@
 import type {
-  InvalidInputError,
-  Price,
-  ProductProjection,
-  ProductVariant,
+	InvalidInputError,
+	Price,
+	ProductProjection,
+	ProductVariant,
 } from '@commercetools/platform-sdk'
 import { CommercetoolsError } from './exceptions.js'
 import type { Writable } from './types.js'
 
 export type PriceSelector = {
-  currency?: string
-  country?: string
-  customerGroup?: string
-  channel?: string
+	currency?: string
+	country?: string
+	customerGroup?: string
+	channel?: string
 }
 
 /**
@@ -20,49 +20,49 @@ export type PriceSelector = {
  * the scopedPrice attribute
  */
 export const applyPriceSelector = (
-  products: ProductProjection[],
-  selector: PriceSelector
+	products: ProductProjection[],
+	selector: PriceSelector
 ) => {
-  validatePriceSelector(selector)
+	validatePriceSelector(selector)
 
-  for (const product of products) {
-    const variants: Writable<ProductVariant>[] = [
-      product.masterVariant,
-      ...(product.variants ?? []),
-    ].filter((x) => x != undefined)
+	for (const product of products) {
+		const variants: Writable<ProductVariant>[] = [
+			product.masterVariant,
+			...(product.variants ?? []),
+		].filter((x) => x != undefined)
 
-    for (const variant of variants) {
-      const scopedPrices =
-        variant.prices?.filter((p) => priceSelectorFilter(p, selector)) ?? []
+		for (const variant of variants) {
+			const scopedPrices =
+				variant.prices?.filter((p) => priceSelectorFilter(p, selector)) ?? []
 
-      if (scopedPrices.length > 0) {
-        const price = scopedPrices[0]
+			if (scopedPrices.length > 0) {
+				const price = scopedPrices[0]
 
-        variant.scopedPriceDiscounted = false
-        variant.scopedPrice = {
-          ...price,
-          currentValue: price.value,
-        }
-      }
-    }
-  }
+				variant.scopedPriceDiscounted = false
+				variant.scopedPrice = {
+					...price,
+					currentValue: price.value,
+				}
+			}
+		}
+	}
 }
 
 const validatePriceSelector = (selector: PriceSelector) => {
-  if (
-    (selector.country || selector.channel || selector.customerGroup) &&
-    !selector.currency
-  ) {
-    throw new CommercetoolsError<InvalidInputError>(
-      {
-        code: 'InvalidInput',
-        message:
-          'The price selecting parameters country, channel and customerGroup ' +
-          'cannot be used without the currency.',
-      },
-      400
-    )
-  }
+	if (
+		(selector.country || selector.channel || selector.customerGroup) &&
+		!selector.currency
+	) {
+		throw new CommercetoolsError<InvalidInputError>(
+			{
+				code: 'InvalidInput',
+				message:
+					'The price selecting parameters country, channel and customerGroup ' +
+					'cannot be used without the currency.',
+			},
+			400
+		)
+	}
 }
 
 /**
@@ -71,36 +71,36 @@ const validatePriceSelector = (selector: PriceSelector) => {
  * then it should match.
  */
 export const priceSelectorFilter = (
-  price: Price,
-  selector: PriceSelector
+	price: Price,
+	selector: PriceSelector
 ): boolean => {
-  if (
-    (selector.country || price.country) &&
-    selector.country !== price.country
-  ) {
-    return false
-  }
+	if (
+		(selector.country || price.country) &&
+		selector.country !== price.country
+	) {
+		return false
+	}
 
-  if (
-    (selector.currency || price.value.currencyCode) &&
-    selector.currency !== price.value.currencyCode
-  ) {
-    return false
-  }
+	if (
+		(selector.currency || price.value.currencyCode) &&
+		selector.currency !== price.value.currencyCode
+	) {
+		return false
+	}
 
-  if (
-    (selector.channel || price.channel?.id) &&
-    selector.channel !== price.channel?.id
-  ) {
-    return false
-  }
+	if (
+		(selector.channel || price.channel?.id) &&
+		selector.channel !== price.channel?.id
+	) {
+		return false
+	}
 
-  if (
-    (selector.customerGroup || price.customerGroup?.id) &&
-    selector.customerGroup !== price.customerGroup?.id
-  ) {
-    return false
-  }
+	if (
+		(selector.customerGroup || price.customerGroup?.id) &&
+		selector.customerGroup !== price.customerGroup?.id
+	) {
+		return false
+	}
 
-  return true
+	return true
 }