@labdigital/commercetools-mock 2.17.0 → 2.18.0

package/src/services/custom-object.test.ts

@@ -1,211 +1,211 @@
-import type { CustomObject } from '@commercetools/platform-sdk'
-import supertest from 'supertest'
-import { getBaseResourceProperties } from '../helpers.js'
-import { afterEach, beforeEach, describe, expect, test } from 'vitest'
-import { CommercetoolsMock } from '../index.js'
+import type { CustomObject } from "@commercetools/platform-sdk";
+import supertest from "supertest";
+import { afterEach, beforeEach, describe, expect, test } from "vitest";
+import { getBaseResourceProperties } from "../helpers";
+import { CommercetoolsMock } from "../index";
 
-describe('CustomObject create', () => {
-	const ctMock = new CommercetoolsMock()
+describe("CustomObject create", () => {
+	const ctMock = new CommercetoolsMock();
 
-	test('Create new object', async () => {
+	test("Create new object", async () => {
 		const response = await supertest(ctMock.app)
-			.post('/dummy/custom-objects')
+			.post("/dummy/custom-objects")
 			.send({
-				container: 'my-container',
-				key: 'my-key',
-				value: 'my-value',
-			})
-
-		expect(response.status).toBe(201)
-		const customObject = response.body
-		expect(customObject.container).toBe('my-container')
-		expect(customObject.key).toBe('my-key')
-		expect(customObject.value).toBe('my-value')
-	})
-})
-
-describe('CustomObject retrieve', () => {
-	const ctMock = new CommercetoolsMock()
-	let customObject: CustomObject
+				container: "my-container",
+				key: "my-key",
+				value: "my-value",
+			});
+
+		expect(response.status).toBe(201);
+		const customObject = response.body;
+		expect(customObject.container).toBe("my-container");
+		expect(customObject.key).toBe("my-key");
+		expect(customObject.value).toBe("my-value");
+	});
+});
+
+describe("CustomObject retrieve", () => {
+	const ctMock = new CommercetoolsMock();
+	let customObject: CustomObject;
 
 	beforeEach(async () => {
 		const response = await supertest(ctMock.app)
-			.post('/dummy/custom-objects')
+			.post("/dummy/custom-objects")
 			.send({
-				container: 'my-container',
-				key: 'my-key',
-				value: 'my-value',
-			})
-
-		expect(response.status).toBe(201)
-		customObject = response.body
-		expect(customObject.container).toBe('my-container')
-		expect(customObject.key).toBe('my-key')
-		expect(customObject.value).toBe('my-value')
-	})
+				container: "my-container",
+				key: "my-key",
+				value: "my-value",
+			});
+
+		expect(response.status).toBe(201);
+		customObject = response.body;
+		expect(customObject.container).toBe("my-container");
+		expect(customObject.key).toBe("my-key");
+		expect(customObject.value).toBe("my-value");
+	});
 	afterEach(async () => {
-		ctMock.clear()
-	})
+		ctMock.clear();
+	});
 
-	test('exists', async () => {
+	test("exists", async () => {
 		const response = await supertest(ctMock.app)
-			.head('/dummy/custom-objects/my-container/my-key')
-			.send()
+			.head("/dummy/custom-objects/my-container/my-key")
+			.send();
 
-		expect(response.status).toBe(200)
-	})
+		expect(response.status).toBe(200);
+	});
 
-	test('non-existent', async () => {
+	test("non-existent", async () => {
 		const response = await supertest(ctMock.app)
-			.head('/dummy/custom-objects/invalid-container/invalid')
-			.send()
+			.head("/dummy/custom-objects/invalid-container/invalid")
+			.send();
 
-		expect(response.status).toBe(404)
-	})
+		expect(response.status).toBe(404);
+	});
 
-	test('get', async () => {
+	test("get", async () => {
 		const response = await supertest(ctMock.app)
-			.get('/dummy/custom-objects/my-container/my-key')
-			.send()
+			.get("/dummy/custom-objects/my-container/my-key")
+			.send();
 
-		expect(response.status).toBe(200)
-		const customObject = response.body
-		expect(customObject.container).toBe('my-container')
-		expect(customObject.key).toBe('my-key')
-		expect(customObject.value).toBe('my-value')
-	})
+		expect(response.status).toBe(200);
+		const customObject = response.body;
+		expect(customObject.container).toBe("my-container");
+		expect(customObject.key).toBe("my-key");
+		expect(customObject.value).toBe("my-value");
+	});
 
-	test('Update match current (no conflict)', async () => {
+	test("Update match current (no conflict)", async () => {
 		const response = await supertest(ctMock.app)
-			.post('/dummy/custom-objects')
+			.post("/dummy/custom-objects")
 			.send({
-				container: 'my-container',
-				key: 'my-key',
-				value: 'my-value',
-			})
+				container: "my-container",
+				key: "my-key",
+				value: "my-value",
+			});
 
-		expect(response.status).toBe(201)
-	})
+		expect(response.status).toBe(201);
+	});
 
-	test('New with version (errors)', async () => {
+	test("New with version (errors)", async () => {
 		const response = await supertest(ctMock.app)
-			.post('/dummy/custom-objects')
+			.post("/dummy/custom-objects")
 			.send({
-				container: 'my-new-container',
-				key: 'my-new-key',
-				value: 'my-value',
+				container: "my-new-container",
+				key: "my-new-key",
+				value: "my-value",
 				version: 2,
-			})
+			});
 
-		expect(response.status).toBe(400)
+		expect(response.status).toBe(400);
 		expect(response.body).toStrictEqual({
 			statusCode: 400,
-			message: 'version on create must be 0',
+			message: "version on create must be 0",
 			errors: [
 				{
-					code: 'InvalidOperation',
-					message: 'version on create must be 0',
+					code: "InvalidOperation",
+					message: "version on create must be 0",
 				},
 			],
-		})
-	})
+		});
+	});
 
-	test('Update match current with version (conflict)', async () => {
+	test("Update match current with version (conflict)", async () => {
 		const response = await supertest(ctMock.app)
-			.post('/dummy/custom-objects')
+			.post("/dummy/custom-objects")
 			.send({
-				container: 'my-container',
-				key: 'my-key',
-				value: 'my-value',
+				container: "my-container",
+				key: "my-key",
+				value: "my-value",
 				version: 2,
-			})
+			});
 
-		expect(response.status).toBe(409)
+		expect(response.status).toBe(409);
 		expect(response.body).toStrictEqual({
 			statusCode: 409,
 			message: `Object ${customObject.id} has a different version than expected. Expected: 2 - Actual: 1.`,
 			errors: [
 				{
-					code: 'ConcurrentModification',
+					code: "ConcurrentModification",
 					currentVersion: 1,
 					message: `Object ${customObject.id} has a different version than expected. Expected: 2 - Actual: 1.`,
 				},
 			],
-		})
-	})
+		});
+	});
 
-	test('can use the add function with the custom object name', async () => {
-		ctMock.project('dummy').add('key-value-document', {
+	test("can use the add function with the custom object name", async () => {
+		ctMock.project("dummy").add("key-value-document", {
 			...getBaseResourceProperties(),
-			container: 'my-container',
-			key: 'my-key',
-			value: 'my-value',
+			container: "my-container",
+			key: "my-key",
+			value: "my-value",
 			version: 2,
-		})
+		});
 
 		const response = await supertest(ctMock.app)
-			.get('/dummy/custom-objects/my-container/my-key')
-			.send()
+			.get("/dummy/custom-objects/my-container/my-key")
+			.send();
 
-		expect(response.status).toEqual(200)
+		expect(response.status).toEqual(200);
 		expect(response.body).toEqual({
-			container: 'my-container',
+			container: "my-container",
 			createdAt: expect.anything(),
 			id: expect.anything(),
-			key: 'my-key',
+			key: "my-key",
 			lastModifiedAt: expect.anything(),
-			value: 'my-value',
+			value: "my-value",
 			version: 1,
-		})
-	})
+		});
+	});
 
-	test('update with container and key', async () => {
-		ctMock.project('dummy').add('key-value-document', {
+	test("update with container and key", async () => {
+		ctMock.project("dummy").add("key-value-document", {
 			...getBaseResourceProperties(),
-			container: 'my-other-container',
-			key: 'my-key',
-			value: 'my-value',
+			container: "my-other-container",
+			key: "my-key",
+			value: "my-value",
 			version: 2,
-		})
+		});
 
 		const response = await supertest(ctMock.app)
-			.post('/dummy/custom-objects/my-other-container/my-key')
+			.post("/dummy/custom-objects/my-other-container/my-key")
 			.send({
-				value: 'new-value',
-			})
+				value: "new-value",
+			});
 
-		expect(response.status).toEqual(200)
+		expect(response.status).toEqual(200);
 		expect(response.body).toEqual({
-			container: 'my-other-container',
+			container: "my-other-container",
 			createdAt: expect.anything(),
 			id: expect.anything(),
-			key: 'my-key',
+			key: "my-key",
 			lastModifiedAt: expect.anything(),
-			value: 'new-value',
+			value: "new-value",
 			version: 3,
-		})
-	})
+		});
+	});
 
-	test('delete with container and key', async () => {
+	test("delete with container and key", async () => {
 		const response = await supertest(ctMock.app)
-			.delete('/dummy/custom-objects/my-container/my-key')
-			.send()
+			.delete("/dummy/custom-objects/my-container/my-key")
+			.send();
 
-		expect(response.status).toEqual(200)
+		expect(response.status).toEqual(200);
 		expect(response.body).toEqual({
-			container: 'my-container',
+			container: "my-container",
 			createdAt: expect.anything(),
 			id: expect.anything(),
-			key: 'my-key',
+			key: "my-key",
 			lastModifiedAt: expect.anything(),
-			value: 'my-value',
+			value: "my-value",
 			version: 1,
-		})
+		});
 
 		const fetchRes = await supertest(ctMock.app)
-			.get('/dummy/custom-objects/my-container/my-key')
-			.send()
+			.get("/dummy/custom-objects/my-container/my-key")
+			.send();
 
-		expect(fetchRes.status).toEqual(404)
-	})
-})
+		expect(fetchRes.status).toEqual(404);
+	});
+});

package/src/services/custom-object.ts

@@ -1,31 +1,34 @@
-import type { CustomObjectDraft } from '@commercetools/platform-sdk'
-import type { Request, Response, Router } from 'express'
-import type { CustomObjectRepository } from '../repositories/custom-object.js'
-import { getRepositoryContext } from '../repositories/helpers.js'
-import AbstractService from './abstract.js'
+import type { CustomObjectDraft } from "@commercetools/platform-sdk";
+import type { Request, Response, Router } from "express";
+import type { CustomObjectRepository } from "../repositories/custom-object";
+import { getRepositoryContext } from "../repositories/helpers";
+import AbstractService from "./abstract";
 
 export class CustomObjectService extends AbstractService {
-	public repository: CustomObjectRepository
+	public repository: CustomObjectRepository;
 
 	constructor(parent: Router, repository: CustomObjectRepository) {
-		super(parent)
-		this.repository = repository
+		super(parent);
+		this.repository = repository;
 	}
 
 	getBasePath() {
-		return 'custom-objects'
+		return "custom-objects";
 	}
 
 	extraRoutes(router: Router) {
-		router.get('/:container', this.getWithContainer.bind(this))
-		router.get('/:container/:key', this.getWithContainerAndKey.bind(this))
-		router.post('/:container/:key', this.createWithContainerAndKey.bind(this))
-		router.delete('/:container/:key', this.deleteWithContainerAndKey.bind(this))
+		router.get("/:container", this.getWithContainer.bind(this));
+		router.get("/:container/:key", this.getWithContainerAndKey.bind(this));
+		router.post("/:container/:key", this.createWithContainerAndKey.bind(this));
+		router.delete(
+			"/:container/:key",
+			this.deleteWithContainerAndKey.bind(this),
+		);
 	}
 
 	getWithContainer(request: Request, response: Response) {
-		const limit = this._parseParam(request.query.limit)
-		const offset = this._parseParam(request.query.offset)
+		const limit = this._parseParam(request.query.limit);
+		const offset = this._parseParam(request.query.offset);
 
 		const result = this.repository.queryWithContainer(
 			getRepositoryContext(request),
@@ -35,23 +38,23 @@ export class CustomObjectService extends AbstractService {
 				where: this._parseParam(request.query.where),
 				limit: limit !== undefined ? Number(limit) : undefined,
 				offset: offset !== undefined ? Number(offset) : undefined,
-			}
-		)
+			},
+		);
 
-		return response.status(200).send(result)
+		return response.status(200).send(result);
 	}
 
 	getWithContainerAndKey(request: Request, response: Response) {
 		const result = this.repository.getWithContainerAndKey(
 			getRepositoryContext(request),
 			request.params.container,
-			request.params.key
-		)
+			request.params.key,
+		);
 
 		if (!result) {
-			return response.status(404).send('Not Found')
+			return response.status(404).send("Not Found");
 		}
-		return response.status(200).send(result)
+		return response.status(200).send(result);
 	}
 
 	createWithContainerAndKey(request: Request, response: Response) {
@@ -59,28 +62,28 @@ export class CustomObjectService extends AbstractService {
 			...request.body,
 			key: request.params.key,
 			container: request.params.container,
-		}
+		};
 
-		const result = this.repository.create(getRepositoryContext(request), draft)
-		return response.status(200).send(result)
+		const result = this.repository.create(getRepositoryContext(request), draft);
+		return response.status(200).send(result);
 	}
 
 	deleteWithContainerAndKey(request: Request, response: Response) {
 		const current = this.repository.getWithContainerAndKey(
 			getRepositoryContext(request),
 			request.params.container,
-			request.params.key
-		)
+			request.params.key,
+		);
 
 		if (!current) {
-			return response.status(404).send('Not Found')
+			return response.status(404).send("Not Found");
 		}
 
 		const result = this.repository.delete(
 			getRepositoryContext(request),
-			current.id
-		)
+			current.id,
+		);
 
-		return response.status(200).send(result)
+		return response.status(200).send(result);
 	}
 }

package/src/services/customer-group.ts

@@ -1,16 +1,16 @@
-import { Router } from 'express'
-import { CustomerGroupRepository } from '../repositories/customer-group.js'
-import AbstractService from './abstract.js'
+import { Router } from "express";
+import { CustomerGroupRepository } from "../repositories/customer-group";
+import AbstractService from "./abstract";
 
 export class CustomerGroupService extends AbstractService {
-	public repository: CustomerGroupRepository
+	public repository: CustomerGroupRepository;
 
 	constructor(parent: Router, repository: CustomerGroupRepository) {
-		super(parent)
-		this.repository = repository
+		super(parent);
+		this.repository = repository;
 	}
 
 	getBasePath() {
-		return 'customer-groups'
+		return "customer-groups";
 	}
 }