@labdigital/commercetools-mock 2.17.0 → 2.18.0

package/package.json

@@ -1,16 +1,9 @@
 {
   "name": "@labdigital/commercetools-mock",
-  "author": "Michael van Tellingen",
-  "version": "2.17.0",
+  "version": "2.18.0",
   "license": "MIT",
-  "main": "dist/index.cjs",
-  "module": "dist/index.js",
+  "author": "Michael van Tellingen",
   "type": "module",
-  "typings": "dist/index.d.ts",
-  "files": [
-    "dist",
-    "src"
-  ],
   "exports": {
     ".": {
       "require": "./dist/index.cjs",
@@ -18,72 +11,77 @@
       "types": "./dist/index.d.ts"
     }
   },
-  "engines": {
-    "node": ">=18",
-    "pnpm": ">=8.6.5"
-  },
-  "packageManager": "pnpm@8.6.5",
-  "publishConfig": {
-    "access": "public"
-  },
-  "prettier": {
-    "printWidth": 80,
-    "semi": false,
-    "singleQuote": true,
-    "trailingComma": "es5"
-  },
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "typings": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
   "dependencies": {
     "basic-auth": "^2.0.1",
     "body-parser": "^1.20.2",
     "deep-equal": "^2.2.3",
     "express": "^4.18.2",
-    "light-my-request": "^5.11.0",
+    "light-my-request": "^5.11.1",
     "lodash.isequal": "^4.5.0",
     "morgan": "^1.10.0",
-    "msw": "^2.1.2",
+    "msw": "^2.2.1",
     "uuid": "^9.0.1"
   },
   "devDependencies": {
     "@changesets/changelog-github": "^0.5.0",
     "@changesets/cli": "^2.27.1",
-    "@commercetools/platform-sdk": "7.2.0-alpha.2",
-    "@types/basic-auth": "^1.1.7",
+    "@commercetools/platform-sdk": "7.3.0",
+    "@stylistic/eslint-plugin": "^1.6.2",
+    "@types/basic-auth": "^1.1.8",
     "@types/body-parser": "^1.19.5",
     "@types/deep-equal": "^1.0.4",
     "@types/express": "^4.17.21",
-    "@types/express-serve-static-core": "^4.17.41",
+    "@types/express-serve-static-core": "^4.17.43",
     "@types/lodash.isequal": "^4.5.8",
     "@types/morgan": "^1.9.9",
-    "@types/node": "^20.11.5",
+    "@types/node": "^20.11.20",
     "@types/qs": "^6.9.11",
     "@types/supertest": "^6.0.2",
-    "@types/uuid": "^9.0.7",
-    "@typescript-eslint/eslint-plugin": "^6.19.0",
-    "@typescript-eslint/parser": "^6.19.0",
-    "@vitest/coverage-v8": "^1.2.1",
-    "esbuild": "^0.19.11",
-    "eslint": "^8.56.0",
-    "eslint-plugin-unused-imports": "^3.0.0",
-    "got": "^14.0.0",
-    "husky": "^8.0.3",
-    "prettier": "^3.2.4",
+    "@types/uuid": "^9.0.8",
+    "@typescript-eslint/eslint-plugin": "^7.0.2",
+    "@typescript-eslint/parser": "^7.0.2",
+    "@vitest/coverage-v8": "^1.3.1",
+    "esbuild": "^0.20.1",
+    "eslint": "^8.57.0",
+    "eslint-plugin-sort-class-members": "^1.20.0",
+    "eslint-plugin-unused-imports": "^3.1.0",
+    "got": "^14.2.0",
+    "husky": "^9.0.11",
+    "prettier": "^3.2.5",
+    "prettier-plugin-organize-imports": "^3.2.4",
+    "prettier-plugin-packagejson": "^2.4.12",
     "supertest": "^6.3.4",
     "timekeeper": "^2.3.1",
     "ts-node": "^10.9.2",
     "tslib": "^2.6.2",
-    "tsup": "^8.0.1",
+    "tsup": "^8.0.2",
     "typescript": "^5.3.3",
-    "vitest": "^1.2.1"
+    "vitest": "^1.3.1"
+  },
+  "packageManager": "pnpm@8.6.5",
+  "engines": {
+    "node": ">=18",
+    "pnpm": ">=8.6.5"
+  },
+  "publishConfig": {
+    "access": "public"
   },
   "scripts": {
-    "start": "tsup src/server.ts --watch --onSuccess 'node dist/server.js'",
     "build": "tsup",
     "build:server": "esbuild src/server.ts --bundle --outfile=dist/server.js --platform=node",
-    "publish:ci": "pnpm build && pnpm changeset publish",
-    "test": "vitest run",
-    "test:ci": "vitest run --coverage",
     "check": "pnpm lint && tsc",
     "format": "eslint src --fix ; prettier --write .",
-    "lint": "eslint src && prettier --check ."
+    "lint": "eslint src && prettier --check .",
+    "publish:ci": "pnpm build && pnpm changeset publish",
+    "start": "tsup src/server.ts --watch --onSuccess 'node dist/server'",
+    "test": "vitest run",
+    "test:ci": "vitest run --coverage"
   }
 }

package/src/constants.ts

@@ -1,2 +1,2 @@
-export const DEFAULT_API_HOSTNAME = 'https://api.*.commercetools.com'
-export const DEFAULT_AUTH_HOSTNAME = 'https://auth.*.commercetools.com'
+export const DEFAULT_API_HOSTNAME = "https://api.*.commercetools.com";
+export const DEFAULT_AUTH_HOSTNAME = "https://auth.*.commercetools.com";

package/src/ctMock.test.ts

@@ -1,18 +1,18 @@
-import { CommercetoolsMock } from './index.js'
-import { test } from 'vitest'
+import { test } from "vitest";
+import { CommercetoolsMock } from "./index";
 
-test('ctMock.authServer', async () => {
+test("ctMock.authServer", async () => {
 	const ctMock = new CommercetoolsMock({
 		enableAuthentication: false,
 		validateCredentials: false,
-		apiHost: 'http://api.localhost',
-	})
+		apiHost: "http://api.localhost",
+	});
 
 	ctMock.authStore().addToken({
-		token_type: 'Bearer',
-		access_token: 'foobar',
+		token_type: "Bearer",
+		access_token: "foobar",
 		expires_in: 172800,
-		scope: 'my-project',
-		refresh_token: 'foobar',
-	})
-})
+		scope: "my-project",
+		refresh_token: "foobar",
+	});
+});

package/src/ctMock.ts

@@ -1,33 +1,34 @@
-import express, { NextFunction, Request, Response } from 'express'
-import morgan from 'morgan'
-import inject from 'light-my-request'
-import { setupServer, SetupServer } from 'msw/node'
-import { http, HttpResponse } from 'msw'
-import { AbstractStorage, InMemoryStorage } from './storage/index.js'
-import { Services } from './types.js'
-import { CommercetoolsError } from './exceptions.js'
-import { OAuth2Server } from './oauth/server.js'
-import { ProjectAPI } from './projectAPI.js'
-import { copyHeaders } from './lib/proxy.js'
-import { DEFAULT_API_HOSTNAME, DEFAULT_AUTH_HOSTNAME } from './constants.js'
+import express, { NextFunction, Request, Response } from "express";
+import inject from "light-my-request";
+import morgan from "morgan";
+import { http, HttpResponse } from "msw";
+import { setupServer, SetupServer } from "msw/node";
+import { DEFAULT_API_HOSTNAME, DEFAULT_AUTH_HOSTNAME } from "./constants";
+import { CommercetoolsError } from "./exceptions";
+import { copyHeaders } from "./lib/proxy";
+import { OAuth2Server } from "./oauth/server";
+import { ProjectAPI } from "./projectAPI";
+import { AbstractStorage, InMemoryStorage } from "./storage";
+import { Services } from "./types";
 
 // Services
-import { ProjectService } from './services/project.js'
-import { createRepositories, RepositoryMap } from './repositories/index.js'
-import { createServices } from './services/index.js'
-import { ProjectRepository } from './repositories/project.js'
-import { mapHeaderType } from './helpers.js'
+import { warnDeprecation } from "./deprecation";
+import { mapHeaderType } from "./helpers";
+import { createRepositories, RepositoryMap } from "./repositories";
+import { ProjectRepository } from "./repositories/project";
+import { createServices } from "./services";
+import { ProjectService } from "./services/project";
 
 export type CommercetoolsMockOptions = {
-	validateCredentials: boolean
-	enableAuthentication: boolean
-	defaultProjectKey: string | undefined
-	apiHost: RegExp | string
-	authHost: RegExp | string
-	silent: boolean
-}
+	validateCredentials: boolean;
+	enableAuthentication: boolean;
+	defaultProjectKey: string | undefined;
+	apiHost: RegExp | string;
+	authHost: RegExp | string;
+	silent: boolean;
+};
 
-type AppOptions = { silent?: boolean }
+type AppOptions = { silent?: boolean };
 
 const DEFAULT_OPTIONS: CommercetoolsMockOptions = {
 	enableAuthentication: false,
@@ -36,111 +37,124 @@ const DEFAULT_OPTIONS: CommercetoolsMockOptions = {
 	apiHost: DEFAULT_API_HOSTNAME,
 	authHost: DEFAULT_AUTH_HOSTNAME,
 	silent: false,
-}
+};
 
-const _globalListeners: SetupServer[] = []
+const _globalListeners: SetupServer[] = [];
 
 export class CommercetoolsMock {
-	public app: express.Express
-	public options: CommercetoolsMockOptions
+	public app: express.Express;
+
+	public options: CommercetoolsMockOptions;
+
+	private _storage: AbstractStorage;
+
+	private _oauth2: OAuth2Server;
 
-	private _storage: AbstractStorage
-	private _oauth2: OAuth2Server
-	private _mswServer: SetupServer | undefined = undefined
-	private _services: Services | null
-	private _repositories: RepositoryMap | null
-	private _projectService?: ProjectService
+	private _mswServer: SetupServer | undefined = undefined;
+
+	private _services: Services | null;
+
+	private _repositories: RepositoryMap | null;
+
+	private _projectService?: ProjectService;
 
 	constructor(options: Partial<CommercetoolsMockOptions> = {}) {
-		this.options = { ...DEFAULT_OPTIONS, ...options }
-		this._services = null
-		this._repositories = null
-		this._projectService = undefined
+		this.options = { ...DEFAULT_OPTIONS, ...options };
+		this._services = null;
+		this._repositories = null;
+		this._projectService = undefined;
 
-		this._storage = new InMemoryStorage()
+		this._storage = new InMemoryStorage();
 		this._oauth2 = new OAuth2Server({
 			enabled: this.options.enableAuthentication,
 			validate: this.options.validateCredentials,
-		})
+		});
 
-		this.app = this.createApp({ silent: this.options.silent })
+		this.app = this.createApp({ silent: this.options.silent });
 	}
 
 	start() {
+		warnDeprecation(
+			"The start method is deprecated, use .registerHandlers() to bind to an msw server instead",
+		);
+
 		// Order is important here when the hostnames match
-		this.clear()
-		this.startServer()
+		this.clear();
+		this.startServer();
 	}
 
 	stop() {
-		this._mswServer?.close()
-		this._mswServer = undefined
+		warnDeprecation(
+			"The stop method is deprecated, use .registerHandlers() to bind to an msw server instead",
+		);
+		this._mswServer?.close();
+		this._mswServer = undefined;
 	}
 
 	clear() {
-		this._storage.clear()
+		this._storage.clear();
 	}
 
 	project(projectKey?: string) {
 		if (!projectKey && !this.options.defaultProjectKey) {
-			throw new Error('No projectKey passed and no default set')
+			throw new Error("No projectKey passed and no default set");
 		}
 
 		if (this._repositories === null) {
-			throw new Error('repositories not initialized yet')
+			throw new Error("repositories not initialized yet");
 		}
 
 		return new ProjectAPI(
 			projectKey || this.options.defaultProjectKey!,
 			this._repositories,
-			this._storage
-		)
+			this._storage,
+		);
 	}
 
 	authStore() {
-		return this._oauth2.store
+		return this._oauth2.store;
 	}
 
 	runServer(port = 3000, options?: AppOptions) {
 		const server = this.app.listen(port, () => {
-			console.info(`Mock server listening at http://localhost:${port}`)
-		})
-		server.keepAliveTimeout = 60 * 1000
+			console.info(`Mock server listening at http://localhost:${port}`);
+		});
+		server.keepAliveTimeout = 60 * 1000;
 	}
 
 	private createApp(options?: AppOptions): express.Express {
-		this._repositories = createRepositories(this._storage)
-		this._oauth2.setCustomerRepository(this._repositories.customer)
+		this._repositories = createRepositories(this._storage);
+		this._oauth2.setCustomerRepository(this._repositories.customer);
 
-		const app = express()
+		const app = express();
 
-		const projectRouter = express.Router({ mergeParams: true })
-		projectRouter.use(express.json())
+		const projectRouter = express.Router({ mergeParams: true });
+		projectRouter.use(express.json());
 
 		if (!options?.silent) {
-			app.use(morgan('tiny'))
+			app.use(morgan("tiny"));
 		}
-		app.use('/oauth', this._oauth2.createRouter())
+		app.use("/oauth", this._oauth2.createRouter());
 
 		// Only enable auth middleware if we have enabled this
 		if (this.options.enableAuthentication) {
-			app.use('/:projectKey', this._oauth2.createMiddleware(), projectRouter)
+			app.use("/:projectKey", this._oauth2.createMiddleware(), projectRouter);
 			app.use(
-				'/:projectKey/in-store/key=:storeKey',
+				"/:projectKey/in-store/key=:storeKey",
 				this._oauth2.createMiddleware(),
-				projectRouter
-			)
+				projectRouter,
+			);
 		} else {
-			app.use('/:projectKey', projectRouter)
-			app.use('/:projectKey/in-store/key=:storeKey', projectRouter)
+			app.use("/:projectKey", projectRouter);
+			app.use("/:projectKey/in-store/key=:storeKey", projectRouter);
 		}
 
 		// Register the rest api services in the router
-		this._services = createServices(projectRouter, this._repositories)
+		this._services = createServices(projectRouter, this._repositories);
 		this._projectService = new ProjectService(
 			projectRouter,
-			this._repositories.project as ProjectRepository
-		)
+			this._repositories.project as ProjectRepository,
+		);
 
 		app.use((err: Error, req: Request, resp: Response, next: NextFunction) => {
 			if (err instanceof CommercetoolsError) {
@@ -149,153 +163,153 @@ export class CommercetoolsMock {
 						statusCode: err.statusCode,
 						message: err.message,
 						errors: err.errors,
-					})
+					});
 				}
 
 				return resp.status(err.statusCode).send({
 					statusCode: err.statusCode,
 					message: err.message,
 					errors: [err.info],
-				})
+				});
 			} else {
-				console.error(err)
+				console.error(err);
 				return resp.status(500).send({
 					error: err.message,
-				})
+				});
 			}
-		})
+		});
 
-		return app
+		return app;
 	}
 
 	// registerHandlers is an alternative way to work with commercetools-mock, it
 	// allows you to manage msw server yourself and register the handlers needed
 	// for commercetools-mock to work.
 	public registerHandlers(server: SetupServer) {
-		const app = this.app
+		const app = this.app;
 		server.use(
 			http.post(`${this.options.authHost}/oauth/*`, async ({ request }) => {
-				const body = await request.text()
-				const url = new URL(request.url)
-				const headers = copyHeaders(request.headers)
+				const body = await request.text();
+				const url = new URL(request.url);
+				const headers = copyHeaders(request.headers);
 
 				const res = await inject(app)
-					.post(url.pathname + '?' + url.searchParams.toString())
+					.post(url.pathname + "?" + url.searchParams.toString())
 					.body(body)
 					.headers(headers)
-					.end()
+					.end();
 				return new HttpResponse(res.body, {
 					status: res.statusCode,
 					headers: mapHeaderType(res.headers),
-				})
+				});
 			}),
 			http.head(`${this.options.apiHost}/*`, async ({ request }) => {
-				const body = await request.text()
-				const url = new URL(request.url)
-				const headers = copyHeaders(request.headers)
+				const body = await request.text();
+				const url = new URL(request.url);
+				const headers = copyHeaders(request.headers);
 
 				const res = await inject(app)
-					.get(url.pathname + '?' + url.searchParams.toString())
+					.get(url.pathname + "?" + url.searchParams.toString())
 					.body(body)
 					.headers(headers)
-					.end()
+					.end();
 
 				if (res.statusCode === 200) {
-					const parsedBody = JSON.parse(res.body)
+					const parsedBody = JSON.parse(res.body);
 					// Check if we have a count property (e.g. for query-lookups)
 					// or if we have a result object (e.g. for single lookups)
 					const resultCount =
-						'count' in parsedBody
+						"count" in parsedBody
 							? parsedBody.count
-							: Object.keys(parsedBody).length
+							: Object.keys(parsedBody).length;
 
 					return new HttpResponse(null, {
 						status: resultCount > 0 ? 200 : 404,
 						headers: mapHeaderType(res.headers),
-					})
+					});
 				}
 
 				return new HttpResponse(null, {
 					status: res.statusCode,
 					headers: mapHeaderType(res.headers),
-				})
+				});
 			}),
 			http.get(`${this.options.apiHost}/*`, async ({ request }) => {
-				const body = await request.text()
-				const url = new URL(request.url)
-				const headers = copyHeaders(request.headers)
+				const body = await request.text();
+				const url = new URL(request.url);
+				const headers = copyHeaders(request.headers);
 
 				const res = await inject(app)
-					.get(url.pathname + '?' + url.searchParams.toString())
+					.get(url.pathname + "?" + url.searchParams.toString())
 					.body(body)
 					.headers(headers)
-					.end()
+					.end();
 				return new HttpResponse(res.body, {
 					status: res.statusCode,
 					headers: mapHeaderType(res.headers),
-				})
+				});
 			}),
 			http.post(`${this.options.apiHost}/*`, async ({ request }) => {
-				const body = await request.text()
-				const url = new URL(request.url)
-				const headers = copyHeaders(request.headers)
+				const body = await request.text();
+				const url = new URL(request.url);
+				const headers = copyHeaders(request.headers);
 
 				const res = await inject(app)
-					.post(url.pathname + '?' + url.searchParams.toString())
+					.post(url.pathname + "?" + url.searchParams.toString())
 					.body(body)
 					.headers(headers)
-					.end()
+					.end();
 				return new HttpResponse(res.body, {
 					status: res.statusCode,
 					headers: mapHeaderType(res.headers),
-				})
+				});
 			}),
 			http.delete(`${this.options.apiHost}/*`, async ({ request }) => {
-				const body = await request.text()
-				const url = new URL(request.url)
-				const headers = copyHeaders(request.headers)
+				const body = await request.text();
+				const url = new URL(request.url);
+				const headers = copyHeaders(request.headers);
 
 				const res = await inject(app)
-					.delete(url.pathname + '?' + url.searchParams.toString())
+					.delete(url.pathname + "?" + url.searchParams.toString())
 					.body(body)
 					.headers(headers)
-					.end()
+					.end();
 				return new HttpResponse(res.body, {
 					status: res.statusCode,
 					headers: mapHeaderType(res.headers),
-				})
-			})
-		)
+				});
+			}),
+		);
 	}
 
 	public mswServer() {
-		return this._mswServer
+		return this._mswServer;
 	}
 
 	private startServer() {
 		// Check if there are any other servers running
 		if (_globalListeners.length > 0) {
 			if (this._mswServer !== undefined) {
-				throw new Error('Server already started')
+				throw new Error("Server already started");
 			} else {
-				console.warn("Server wasn't stopped properly, clearing")
-				_globalListeners.forEach((listener) => listener.close())
+				console.warn("Server wasn't stopped properly, clearing");
+				_globalListeners.forEach((listener) => listener.close());
 			}
 		}
 
-		const server = setupServer()
-		this.registerHandlers(server)
+		const server = setupServer();
+		this.registerHandlers(server);
 		server.listen({
 			// We need to allow requests done by supertest
 			onUnhandledRequest: (request, print) => {
-				const url = new URL(request.url)
-				if (url.hostname === '127.0.0.1') {
-					return
+				const url = new URL(request.url);
+				if (url.hostname === "127.0.0.1") {
+					return;
 				}
-				print.error()
+				print.error();
 			},
-		})
-		_globalListeners.push(server)
-		this._mswServer = server
+		});
+		_globalListeners.push(server);
+		this._mswServer = server;
 	}
 }

package/src/deprecation.ts

@@ -0,0 +1,8 @@
+const shownWarnings = new Set();
+
+export const warnDeprecation = (msg: string) => {
+	if (!shownWarnings.has(msg)) {
+		console.warn(msg);
+		shownWarnings.add(msg);
+	}
+};

package/src/exceptions.ts

@@ -1,30 +1,32 @@
 export abstract class BaseError {
-	abstract message: string
-	abstract errors?: BaseError[]
+	abstract message: string;
+
+	abstract errors?: BaseError[];
 }
 
 export class CommercetoolsError<T extends BaseError> extends Error {
-	info: T
-	statusCode: number
+	info: T;
+
+	statusCode: number;
 
-	errors: BaseError[]
+	errors: BaseError[];
 
 	constructor(info: T, statusCode = 400) {
-		super(info.message)
-		this.info = info
-		this.statusCode = statusCode || 500
-		this.errors = info.errors ?? []
+		super(info.message);
+		this.info = info;
+		this.statusCode = statusCode || 500;
+		this.errors = info.errors ?? [];
 	}
 }
 
 export interface InvalidRequestError {
-	readonly code: 'invalid_request'
-	readonly message: string
+	readonly code: "invalid_request";
+	readonly message: string;
 }
 
 export interface AuthError {
-	readonly statusCode: number
-	readonly message: string
-	readonly error: string
-	readonly error_description: string
+	readonly statusCode: number;
+	readonly message: string;
+	readonly error: string;
+	readonly error_description: string;
 }