@labdigital/commercetools-mock 2.17.1 → 2.18.1

package/src/services/product-projection.ts

@@ -1,31 +1,31 @@
-import { Request, Response, Router } from 'express'
-import { getRepositoryContext } from '../repositories/helpers.js'
+import { Request, Response, Router } from "express";
+import { queryParamsArray, queryParamsValue } from "../helpers";
+import { getRepositoryContext } from "../repositories/helpers";
 import {
 	ProductProjectionQueryParams,
 	ProductProjectionRepository,
-} from './../repositories/product-projection.js'
-import AbstractService from './abstract.js'
-import { queryParamsArray, queryParamsValue } from '../helpers.js'
+} from "./../repositories/product-projection";
+import AbstractService from "./abstract";
 
 export class ProductProjectionService extends AbstractService {
-	public repository: ProductProjectionRepository
+	public repository: ProductProjectionRepository;
 
 	constructor(parent: Router, repository: ProductProjectionRepository) {
-		super(parent)
-		this.repository = repository
+		super(parent);
+		this.repository = repository;
 	}
 
 	getBasePath() {
-		return 'product-projections'
+		return "product-projections";
 	}
 
 	extraRoutes(router: Router) {
-		router.get('/search', this.search.bind(this))
+		router.get("/search", this.search.bind(this));
 	}
 
 	get(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.query(getRepositoryContext(request), {
 			...request.query,
@@ -33,31 +33,33 @@ export class ProductProjectionService 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);
 	}
 
 	search(request: Request, response: Response) {
-		const query = request.query
+		const query = request.query;
 		const searchParams: ProductProjectionQueryParams = {
-			filter: queryParamsArray(query.filter),
-			'filter.query': queryParamsArray(query['filter.query']),
-			facet: queryParamsArray(query.facet),
-			expand: queryParamsArray(query.expand),
-			staged: queryParamsValue(query.staged) === 'true',
-			localeProjection: queryParamsValue(query.localeProjection),
-			storeProjection: queryParamsValue(query.storeProjection),
-			priceChannel: queryParamsValue(query.priceChannel),
-			priceCountry: queryParamsValue(query.priceCountry),
-			priceCurrency: queryParamsValue(query.priceCurrency),
-			priceCustomerGroup: queryParamsValue(query.priceCustomerGroup),
-			offset: query.offset ? Number(queryParamsValue(query.offset)) : undefined,
-			limit: query.limit ? Number(queryParamsValue(query.limit)) : undefined,
-		}
+			"filter": queryParamsArray(query.filter),
+			"filter.query": queryParamsArray(query["filter.query"]),
+			"facet": queryParamsArray(query.facet),
+			"expand": queryParamsArray(query.expand),
+			"staged": queryParamsValue(query.staged) === "true",
+			"localeProjection": queryParamsValue(query.localeProjection),
+			"storeProjection": queryParamsValue(query.storeProjection),
+			"priceChannel": queryParamsValue(query.priceChannel),
+			"priceCountry": queryParamsValue(query.priceCountry),
+			"priceCurrency": queryParamsValue(query.priceCurrency),
+			"priceCustomerGroup": queryParamsValue(query.priceCustomerGroup),
+			"offset": query.offset
+				? Number(queryParamsValue(query.offset))
+				: undefined,
+			"limit": query.limit ? Number(queryParamsValue(query.limit)) : undefined,
+		};
 		const resource = this.repository.search(
 			getRepositoryContext(request),
-			searchParams
-		)
-		return response.status(200).send(resource)
+			searchParams,
+		);
+		return response.status(200).send(resource);
 	}
 }

package/src/services/product-selection.test.ts

@@ -1,35 +1,35 @@
-import type { ProductSelectionDraft } from '@commercetools/platform-sdk'
-import supertest from 'supertest'
-import { describe, expect, test } from 'vitest'
-import { CommercetoolsMock } from '../index.js'
+import type { ProductSelectionDraft } from "@commercetools/platform-sdk";
+import supertest from "supertest";
+import { describe, expect, test } from "vitest";
+import { CommercetoolsMock } from "../index";
 
-const ctMock = new CommercetoolsMock()
+const ctMock = new CommercetoolsMock();
 
-describe('product-selection', () => {
-	test('Create product selection', async () => {
+describe("product-selection", () => {
+	test("Create product selection", async () => {
 		const draft: ProductSelectionDraft = {
 			name: {
-				en: 'foo',
+				en: "foo",
 			},
-			key: 'foo',
-		}
+			key: "foo",
+		};
 		const response = await supertest(ctMock.app)
-			.post('/dummy/product-selections')
-			.send(draft)
+			.post("/dummy/product-selections")
+			.send(draft);
 
-		expect(response.status).toBe(201)
+		expect(response.status).toBe(201);
 
 		expect(response.body).toEqual({
 			createdAt: expect.anything(),
 			id: expect.anything(),
 			lastModifiedAt: expect.anything(),
 			name: {
-				en: 'foo',
+				en: "foo",
 			},
-			key: 'foo',
+			key: "foo",
 			version: 1,
 			productCount: 0,
-			mode: 'Individual',
-		})
-	})
-})
+			mode: "Individual",
+		});
+	});
+});

package/src/services/product-selection.ts

@@ -1,16 +1,16 @@
-import { Router } from 'express'
-import AbstractService from './abstract.js'
-import { ProductSelectionRepository } from '../repositories/product-selection.js'
+import { Router } from "express";
+import { ProductSelectionRepository } from "../repositories/product-selection";
+import AbstractService from "./abstract";
 
 export class ProductSelectionService extends AbstractService {
-	public repository: ProductSelectionRepository
+	public repository: ProductSelectionRepository;
 
 	constructor(parent: Router, repository: ProductSelectionRepository) {
-		super(parent)
-		this.repository = repository
+		super(parent);
+		this.repository = repository;
 	}
 
 	getBasePath() {
-		return 'product-selections'
+		return "product-selections";
 	}
 }

package/src/services/product-type.test.ts

@@ -1,71 +1,71 @@
-import type { ProductTypeDraft } from '@commercetools/platform-sdk'
-import supertest from 'supertest'
-import { describe, expect, test } from 'vitest'
-import { CommercetoolsMock } from '../index.js'
+import type { ProductTypeDraft } from "@commercetools/platform-sdk";
+import supertest from "supertest";
+import { describe, expect, test } from "vitest";
+import { CommercetoolsMock } from "../index";
 
-const ctMock = new CommercetoolsMock()
+const ctMock = new CommercetoolsMock();
 
-describe('Product type', () => {
-	test('Create product type', async () => {
+describe("Product type", () => {
+	test("Create product type", async () => {
 		const draft: ProductTypeDraft = {
-			name: 'foo',
-			description: 'bar',
+			name: "foo",
+			description: "bar",
 			attributes: [
 				{
-					name: 'name',
-					type: { name: 'boolean' },
-					label: { 'nl-NL': 'bar' },
+					name: "name",
+					type: { name: "boolean" },
+					label: { "nl-NL": "bar" },
 					isRequired: false,
 				},
 			],
-		}
+		};
 		const response = await supertest(ctMock.app)
-			.post('/dummy/product-types')
-			.send(draft)
+			.post("/dummy/product-types")
+			.send(draft);
 
-		expect(response.status).toBe(201)
+		expect(response.status).toBe(201);
 
 		expect(response.body).toEqual({
 			attributes: [
 				{
-					attributeConstraint: 'None',
-					inputHint: 'SingleLine',
+					attributeConstraint: "None",
+					inputHint: "SingleLine",
 					isRequired: false,
 					isSearchable: true,
 					label: {
-						'nl-NL': 'bar',
+						"nl-NL": "bar",
 					},
-					name: 'name',
+					name: "name",
 					type: {
-						name: 'boolean',
+						name: "boolean",
 					},
 				},
 			],
 			createdAt: expect.anything(),
-			description: 'bar',
+			description: "bar",
 			id: expect.anything(),
 			lastModifiedAt: expect.anything(),
-			name: 'foo',
+			name: "foo",
 			version: 1,
-		})
-	})
+		});
+	});
 
-	test('Get product type', async () => {
+	test("Get product type", async () => {
 		const draft: ProductTypeDraft = {
-			name: 'foo',
-			description: 'bar',
-		}
+			name: "foo",
+			description: "bar",
+		};
 		const createResponse = await supertest(ctMock.app)
-			.post('/dummy/product-types')
-			.send(draft)
+			.post("/dummy/product-types")
+			.send(draft);
 
-		expect(createResponse.status).toBe(201)
+		expect(createResponse.status).toBe(201);
 
 		const response = await supertest(ctMock.app).get(
-			`/dummy/product-types/${createResponse.body.id}`
-		)
+			`/dummy/product-types/${createResponse.body.id}`,
+		);
 
-		expect(response.status).toBe(200)
-		expect(response.body).toEqual(createResponse.body)
-	})
-})
+		expect(response.status).toBe(200);
+		expect(response.body).toEqual(createResponse.body);
+	});
+});

package/src/services/product-type.ts

@@ -1,16 +1,16 @@
-import { Router } from 'express'
-import { ProductTypeRepository } from '../repositories/product-type.js'
-import AbstractService from './abstract.js'
+import { Router } from "express";
+import { ProductTypeRepository } from "../repositories/product-type";
+import AbstractService from "./abstract";
 
 export class ProductTypeService extends AbstractService {
-	public repository: ProductTypeRepository
+	public repository: ProductTypeRepository;
 
 	constructor(parent: Router, repository: ProductTypeRepository) {
-		super(parent)
-		this.repository = repository
+		super(parent);
+		this.repository = repository;
 	}
 
 	getBasePath() {
-		return 'product-types'
+		return "product-types";
 	}
 }