@labdigital/commercetools-mock 2.17.1 → 2.18.1

package/src/oauth/server.ts

@@ -1,66 +1,67 @@
-import auth from 'basic-auth'
-import bodyParser from 'body-parser'
+import { InvalidTokenError } from "@commercetools/platform-sdk";
+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'
+} from "express";
 import {
 	AuthError,
 	CommercetoolsError,
 	InvalidRequestError,
-} from '../exceptions.js'
-import { InvalidClientError, UnsupportedGrantType } from './errors.js'
-import { OAuth2Store } from './store.js'
-import { getBearerToken } from './helpers.js'
-import { CustomerRepository } from '../repositories/customer.js'
-import { hashPassword } from '../lib/password.js'
+} from "~src/exceptions";
+import { hashPassword } from "../lib/password";
+import { CustomerRepository } from "../repositories/customer";
+import { InvalidClientError, UnsupportedGrantType } from "./errors";
+import { getBearerToken } from "./helpers";
+import { OAuth2Store } from "./store";
 
 type AuthRequest = Request & {
-	credentials: {
-		clientId: string
-		clientSecret: string
-	}
-}
+	credentials?: {
+		clientId: string;
+		clientSecret: string;
+	};
+};
 export 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 OAuth2Server {
-	store: OAuth2Store
-	private customerRepository: CustomerRepository
+	store: OAuth2Store;
+
+	private customerRepository: CustomerRepository;
 
 	constructor(private options: { enabled: boolean; validate: boolean }) {
-		this.store = new OAuth2Store(options.validate)
+		this.store = new OAuth2Store(options.validate);
 	}
 
 	setCustomerRepository(repository: CustomerRepository) {
-		this.customerRepository = repository
+		this.customerRepository = repository;
 	}
 
 	createRouter() {
-		const router = express.Router()
-		router.use(bodyParser.urlencoded({ extended: true }))
-		router.use(this.validateClientCredentials.bind(this))
-		router.post('/token', this.tokenHandler.bind(this))
+		const router = express.Router();
+		router.use(bodyParser.urlencoded({ extended: true }));
+		router.use(this.validateClientCredentials.bind(this));
+		router.post("/token", this.tokenHandler.bind(this));
 		router.post(
-			'/:projectKey/customers/token',
-			this.customerTokenHandler.bind(this)
-		)
+			"/:projectKey/customers/token",
+			this.customerTokenHandler.bind(this),
+		);
 		router.post(
-			'/:projectKey/in-store/key=:storeKey/customers/token',
-			this.inStoreCustomerTokenHandler.bind(this)
-		)
+			"/:projectKey/in-store/key=:storeKey/customers/token",
+			this.inStoreCustomerTokenHandler.bind(this),
+		);
 		router.post(
-			'/:projectKey/anonymous/token',
-			this.anonymousTokenHandler.bind(this)
-		)
-		return router
+			"/:projectKey/anonymous/token",
+			this.anonymousTokenHandler.bind(this),
+		);
+		return router;
 	}
 
 	createMiddleware() {
@@ -68,253 +69,266 @@ export class OAuth2Server {
 			return async (
 				request: Request,
 				response: Response,
-				next: NextFunction
+				next: NextFunction,
 			) => {
-				next()
-			}
+				next();
+			};
 		}
 
 		return async (request: Request, response: Response, next: NextFunction) => {
-			const token = getBearerToken(request)
+			const token = getBearerToken(request);
 			if (!token) {
 				next(
 					new CommercetoolsError<InvalidTokenError>(
 						{
-							code: 'invalid_token',
+							code: "invalid_token",
 							message:
-								'This endpoint requires an access token. You can get one from the authorization server.',
+								"This endpoint requires an access token. You can get one from the authorization server.",
 						},
-						401
-					)
-				)
+						401,
+					),
+				);
 			}
 
 			if (!token || !this.store.validateToken(token)) {
 				next(
 					new CommercetoolsError<InvalidTokenError>(
 						{
-							code: 'invalid_token',
-							message: 'invalid_token',
+							code: "invalid_token",
+							message: "invalid_token",
 						},
-						401
-					)
-				)
+						401,
+					),
+				);
 			}
 
-			next()
-		}
+			next();
+		};
 	}
 
 	async validateClientCredentials(
 		request: AuthRequest,
 		response: Response,
-		next: NextFunction
+		next: NextFunction,
 	) {
-		const authHeader = request.header('Authorization')
+		const authHeader = request.header("Authorization");
 		if (!authHeader) {
 			return next(
 				new CommercetoolsError<InvalidClientError>(
 					{
-						code: 'invalid_client',
+						code: "invalid_client",
 						message:
-							'Please provide valid client credentials using HTTP Basic Authentication.',
+							"Please provide valid client credentials using HTTP Basic Authentication.",
 					},
-					401
-				)
-			)
+					401,
+				),
+			);
 		}
-		const credentials = auth.parse(authHeader)
+		const credentials = auth.parse(authHeader);
 		if (!credentials) {
 			return next(
 				new CommercetoolsError<InvalidClientError>(
 					{
-						code: 'invalid_client',
+						code: "invalid_client",
 						message:
-							'Please provide valid client credentials using HTTP Basic Authentication.',
+							"Please provide valid client credentials using HTTP Basic Authentication.",
 					},
-					400
-				)
-			)
+					400,
+				),
+			);
 		}
 
 		request.credentials = {
 			clientId: credentials.name,
 			clientSecret: credentials.pass,
-		}
+		};
 
-		next()
+		next();
 	}
 
 	async tokenHandler(
 		request: AuthRequest,
 		response: Response,
-		next: NextFunction
+		next: NextFunction,
 	) {
-		const grantType = request.query.grant_type || request.body.grant_type
+		if (!request.credentials) {
+			return next(
+				new CommercetoolsError<InvalidClientError>(
+					{
+						code: "invalid_client",
+						message: "Client credentials are missing.",
+					},
+					401,
+				),
+			);
+		}
+
+		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.',
+						code: "invalid_request",
+						message: "Missing required parameter: grant_type.",
 					},
-					400
-				)
-			)
+					400,
+				),
+			);
 		}
 
-		if (grantType === 'client_credentials') {
+		if (grantType === "client_credentials") {
 			const token = this.store.getClientToken(
 				request.credentials.clientId,
 				request.credentials.clientSecret,
-				request.query.scope?.toString()
-			)
-			return response.status(200).send(token)
-		} else if (grantType === 'refresh_token') {
+				request.query.scope?.toString(),
+			);
+			return response.status(200).send(token);
+		} else if (grantType === "refresh_token") {
 			const refreshToken =
-				request.query.refresh_token?.toString() || request.body.refresh_token
+				request.query.refresh_token?.toString() || request.body.refresh_token;
 			if (!refreshToken) {
 				return next(
 					new CommercetoolsError<InvalidRequestError>(
 						{
-							code: 'invalid_request',
-							message: 'Missing required parameter: refresh_token.',
+							code: "invalid_request",
+							message: "Missing required parameter: refresh_token.",
 						},
-						400
-					)
-				)
+						400,
+					),
+				);
 			}
 			const token = this.store.refreshToken(
 				request.credentials.clientId,
 				request.credentials.clientSecret,
-				refreshToken
-			)
+				refreshToken,
+			);
 			if (!token) {
 				return next(
 					new CommercetoolsError<AuthError>(
 						{
 							statusCode: 400,
-							message: 'The refresh token was not found. It may have expired.',
-							error: 'invalid_grant',
+							message: "The refresh token was not found. It may have expired.",
+							error: "invalid_grant",
 							error_description:
-								'The refresh token was not found. It may have expired.',
+								"The refresh token was not found. It may have expired.",
 						},
-						400
-					)
-				)
+						400,
+					),
+				);
 			}
-			return response.status(200).send(token)
+			return response.status(200).send(token);
 		} else {
 			return next(
 				new CommercetoolsError<UnsupportedGrantType>(
 					{
-						code: 'unsupported_grant_type',
+						code: "unsupported_grant_type",
 						message: `Invalid parameter: grant_type: Invalid grant type: ${grantType}`,
 					},
-					400
-				)
-			)
+					400,
+				),
+			);
 		}
 	}
+
 	async customerTokenHandler(
 		request: AuthRequest,
 		response: Response,
-		next: NextFunction
+		next: NextFunction,
 	) {
-		const projectKey = request.params.projectKey
-		const grantType = request.query.grant_type || request.body.grant_type
+		const projectKey = request.params.projectKey;
+		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.',
+						code: "invalid_request",
+						message: "Missing required parameter: grant_type.",
 					},
-					400
-				)
-			)
+					400,
+				),
+			);
 		}
 
-		if (grantType === 'password') {
-			const username = request.query.username || request.body.username
+		if (grantType === "password") {
+			const username = request.query.username || request.body.username;
 			const password = hashPassword(
-				request.query.password || request.body.password
-			)
+				request.query.password || request.body.password,
+			);
 			const scope =
-				request.query.scope?.toString() || request.body.scope?.toString()
+				request.query.scope?.toString() || request.body.scope?.toString();
 
 			const result = this.customerRepository.query(
 				{ projectKey: request.params.projectKey },
 				{
 					where: [`email = "${username}"`, `password = "${password}"`],
-				}
-			)
+				},
+			);
 
 			if (result.count === 0) {
 				return next(
 					new CommercetoolsError<any>(
 						{
-							code: 'invalid_customer_account_credentials',
-							message: 'Customer account with the given credentials not found.',
+							code: "invalid_customer_account_credentials",
+							message: "Customer account with the given credentials not found.",
 						},
-						400
-					)
-				)
+						400,
+					),
+				);
 			}
 
-			const customer = result.results[0]
-			const token = this.store.getCustomerToken(projectKey, customer.id, scope)
-			return response.status(200).send(token)
+			const customer = result.results[0];
+			const token = this.store.getCustomerToken(projectKey, customer.id, scope);
+			return response.status(200).send(token);
 		}
 	}
 
 	async inStoreCustomerTokenHandler(
 		request: Request,
 		response: Response,
-		next: NextFunction
+		next: NextFunction,
 	) {
 		return next(
 			new CommercetoolsError<InvalidClientError>(
 				{
-					code: 'invalid_client',
-					message: 'Not implemented yet in commercetools-mock',
+					code: "invalid_client",
+					message: "Not implemented yet in commercetools-mock",
 				},
-				401
-			)
-		)
+				401,
+			),
+		);
 	}
 
 	async anonymousTokenHandler(
 		request: Request,
 		response: Response,
-		next: NextFunction
+		next: NextFunction,
 	) {
-		const projectKey = request.params.projectKey
-		const grantType = request.query.grant_type || request.body.grant_type
+		const projectKey = request.params.projectKey;
+		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.',
+						code: "invalid_request",
+						message: "Missing required parameter: grant_type.",
 					},
-					400
-				)
-			)
+					400,
+				),
+			);
 		}
 
-		if (grantType === 'client_credentials') {
+		if (grantType === "client_credentials") {
 			const scope =
-				request.query.scope?.toString() || request.body.scope?.toString()
+				request.query.scope?.toString() || request.body.scope?.toString();
 
-			const anonymous_id = undefined
+			const anonymous_id = undefined;
 
 			const token = this.store.getAnonymousToken(
 				projectKey,
 				anonymous_id,
-				scope
-			)
-			return response.status(200).send(token)
+				scope,
+			);
+			return response.status(200).send(token);
 		}
 	}
 }

package/src/oauth/store.ts

@@ -1,83 +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(
 		projectKey: string,
 		anonymousId: string | undefined,
-		scope: string
+		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: `${projectKey}:${randomBytes(16).toString('base64')}`,
-		}
-		this.addToken(token)
-		return token
+			refresh_token: `${projectKey}:${randomBytes(16).toString("base64")}`,
+		};
+		this.addToken(token);
+		return token;
 	}
 
 	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: `${projectKey}:${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 {
@@ -85,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;
 	}
 }