@labdigital/commercetools-mock 2.17.1 → 2.18.1

package/src/services/discount-code.ts

@@ -1,16 +1,16 @@
-import { Router } from 'express'
-import { DiscountCodeRepository } from '../repositories/discount-code.js'
-import AbstractService from './abstract.js'
+import { Router } from "express";
+import { DiscountCodeRepository } from "../repositories/discount-code/index";
+import AbstractService from "./abstract";
 
 export class DiscountCodeService extends AbstractService {
-	public repository: DiscountCodeRepository
+	public repository: DiscountCodeRepository;
 
 	constructor(parent: Router, repository: DiscountCodeRepository) {
-		super(parent)
-		this.repository = repository
+		super(parent);
+		this.repository = repository;
 	}
 
 	getBasePath() {
-		return 'discount-codes'
+		return "discount-codes";
 	}
 }

package/src/services/extension.ts

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

package/src/services/index.ts

@@ -1,100 +1,104 @@
-import { AssociateRoleServices } from './associate-roles.js'
-import { AttributeGroupService } from './attribute-group.js'
-import { BusinessUnitServices } from './business-units.js'
-import { CartDiscountService } from './cart-discount.js'
-import { CartService } from './cart.js'
-import { CategoryServices } from './category.js'
-import { ChannelService } from './channel.js'
-import { CustomObjectService } from './custom-object.js'
-import { CustomerGroupService } from './customer-group.js'
-import { CustomerService } from './customer.js'
-import { DiscountCodeService } from './discount-code.js'
-import { ExtensionServices } from './extension.js'
-import { InventoryEntryService } from './inventory-entry.js'
-import { MyCartService } from './my-cart.js'
-import { MyCustomerService } from './my-customer.js'
-import { MyOrderService } from './my-order.js'
-import { MyPaymentService } from './my-payment.js'
-import { MyShoppingListService } from './my-shopping-list.js'
-import { OrderService } from './order.js'
-import { PaymentService } from './payment.js'
-import { ProductDiscountService } from './product-discount.js'
-import { ProductProjectionService } from './product-projection.js'
-import { ProductSelectionService } from './product-selection.js'
-import { ProductTypeService } from './product-type.js'
-import { ProductService } from './product.js'
-import { ReviewService } from './reviews.js'
-import { ShippingMethodService } from './shipping-method.js'
-import { ShoppingListService } from './shopping-list.js'
-import { StandAlonePriceService } from './standalone-price.js'
-import { StateService } from './state.js'
-import { StoreService } from './store.js'
-import { SubscriptionService } from './subscription.js'
-import { TaxCategoryService } from './tax-category.js'
-import { TypeService } from './type.js'
-import { ZoneService } from './zone.js'
+import { createRepositories } from "../repositories";
+import { AssociateRoleServices } from "./associate-roles";
+import { AttributeGroupService } from "./attribute-group";
+import { BusinessUnitServices } from "./business-units";
+import { CartService } from "./cart";
+import { CartDiscountService } from "./cart-discount";
+import { CategoryServices } from "./category";
+import { ChannelService } from "./channel";
+import { CustomObjectService } from "./custom-object";
+import { CustomerService } from "./customer";
+import { CustomerGroupService } from "./customer-group";
+import { DiscountCodeService } from "./discount-code";
+import { ExtensionServices } from "./extension";
+import { InventoryEntryService } from "./inventory-entry";
+import { MyCartService } from "./my-cart";
+import { MyCustomerService } from "./my-customer";
+import { MyOrderService } from "./my-order";
+import { MyPaymentService } from "./my-payment";
+import { MyShoppingListService } from "./my-shopping-list";
+import { OrderService } from "./order";
+import { PaymentService } from "./payment";
+import { ProductService } from "./product";
+import { ProductDiscountService } from "./product-discount";
+import { ProductProjectionService } from "./product-projection";
+import { ProductSelectionService } from "./product-selection";
+import { ProductTypeService } from "./product-type";
+import { ReviewService } from "./reviews";
+import { ShippingMethodService } from "./shipping-method";
+import { ShoppingListService } from "./shopping-list";
+import { StandAlonePriceService } from "./standalone-price";
+import { StateService } from "./state";
+import { StoreService } from "./store";
+import { SubscriptionService } from "./subscription";
+import { TaxCategoryService } from "./tax-category";
+import { TypeService } from "./type";
+import { ZoneService } from "./zone";
 
-export const createServices = (router: any, repos: any) => ({
-	'associate-role': new AssociateRoleServices(router, repos['associate-role']),
-	'business-unit': new BusinessUnitServices(router, repos['business-unit']),
-	category: new CategoryServices(router, repos['category']),
-	cart: new CartService(router, repos['cart'], repos['order']),
-	'cart-discount': new CartDiscountService(router, repos['cart-discount']),
-	customer: new CustomerService(router, repos['customer']),
-	channel: new ChannelService(router, repos['channel']),
-	'customer-group': new CustomerGroupService(router, repos['customer-group']),
-	'discount-code': new DiscountCodeService(router, repos['discount-code']),
-	extension: new ExtensionServices(router, repos['extension']),
-	'inventory-entry': new InventoryEntryService(
+export const createServices = (
+	router: any,
+	repos: ReturnType<typeof createRepositories>,
+) => ({
+	"associate-role": new AssociateRoleServices(router, repos["associate-role"]),
+	"business-unit": new BusinessUnitServices(router, repos["business-unit"]),
+	"category": new CategoryServices(router, repos["category"]),
+	"cart": new CartService(router, repos["cart"], repos["order"]),
+	"cart-discount": new CartDiscountService(router, repos["cart-discount"]),
+	"customer": new CustomerService(router, repos["customer"]),
+	"channel": new ChannelService(router, repos["channel"]),
+	"customer-group": new CustomerGroupService(router, repos["customer-group"]),
+	"discount-code": new DiscountCodeService(router, repos["discount-code"]),
+	"extension": new ExtensionServices(router, repos["extension"]),
+	"inventory-entry": new InventoryEntryService(
 		router,
-		repos['inventory-entry']
+		repos["inventory-entry"],
 	),
-	'key-value-document': new CustomObjectService(
+	"key-value-document": new CustomObjectService(
 		router,
-		repos['key-value-document']
+		repos["key-value-document"],
 	),
-	order: new OrderService(router, repos['order']),
-	payment: new PaymentService(router, repos['payment']),
-	'standalone-price': new StandAlonePriceService(
+	"order": new OrderService(router, repos["order"]),
+	"payment": new PaymentService(router, repos["payment"]),
+	"standalone-price": new StandAlonePriceService(
 		router,
-		repos['standalone-price']
+		repos["standalone-price"],
 	),
-	'my-cart': new MyCartService(router, repos['my-cart']),
-	'my-order': new MyOrderService(router, repos['my-order']),
-	'my-customer': new MyCustomerService(router, repos['my-customer']),
-	'my-payment': new MyPaymentService(router, repos['my-payment']),
-	'my-shopping-list': new MyShoppingListService(
+	"my-cart": new MyCartService(router, repos["my-cart"]),
+	"my-order": new MyOrderService(router, repos["my-order"]),
+	"my-customer": new MyCustomerService(router, repos["my-customer"]),
+	"my-payment": new MyPaymentService(router, repos["my-payment"]),
+	"my-shopping-list": new MyShoppingListService(
 		router,
-		repos['my-shopping-list']
+		repos["my-shopping-list"],
 	),
-	'shipping-method': new ShippingMethodService(
+	"shipping-method": new ShippingMethodService(
 		router,
-		repos['shipping-method']
+		repos["shipping-method"],
 	),
-	'product-type': new ProductTypeService(router, repos['product-type']),
-	product: new ProductService(router, repos['product']),
-	'product-discount': new ProductDiscountService(
+	"product-type": new ProductTypeService(router, repos["product-type"]),
+	"product": new ProductService(router, repos["product"]),
+	"product-discount": new ProductDiscountService(
 		router,
-		repos['product-discount']
+		repos["product-discount"],
 	),
-	'product-projection': new ProductProjectionService(
+	"product-projection": new ProductProjectionService(
 		router,
-		repos['product-projection']
+		repos["product-projection"],
 	),
-	'product-selection': new ProductSelectionService(
+	"product-selection": new ProductSelectionService(
 		router,
-		repos['product-selection']
+		repos["product-selection"],
 	),
-	reviews: new ReviewService(router, repos['review']),
-	'shopping-list': new ShoppingListService(router, repos['shopping-list']),
-	state: new StateService(router, repos['state']),
-	store: new StoreService(router, repos['store']),
-	subscription: new SubscriptionService(router, repos['subscription']),
-	'tax-category': new TaxCategoryService(router, repos['tax-category']),
-	'attribute-group': new AttributeGroupService(
+	"reviews": new ReviewService(router, repos["review"]),
+	"shopping-list": new ShoppingListService(router, repos["shopping-list"]),
+	"state": new StateService(router, repos["state"]),
+	"store": new StoreService(router, repos["store"]),
+	"subscription": new SubscriptionService(router, repos["subscription"]),
+	"tax-category": new TaxCategoryService(router, repos["tax-category"]),
+	"attribute-group": new AttributeGroupService(
 		router,
-		repos['attribute-group']
+		repos["attribute-group"],
 	),
-	type: new TypeService(router, repos['type']),
-	zone: new ZoneService(router, repos['zone']),
-})
+	"type": new TypeService(router, repos["type"]),
+	"zone": new ZoneService(router, repos["zone"]),
+});

package/src/services/inventory-entry.test.ts

@@ -1,101 +1,101 @@
-import type { InventoryEntry, Type } from '@commercetools/platform-sdk'
-import assert from 'assert'
-import supertest from 'supertest'
-import { afterEach, beforeEach, describe, expect, test } from 'vitest'
-import { CommercetoolsMock } from '../index.js'
+import type { InventoryEntry, Type } from "@commercetools/platform-sdk";
+import assert from "assert";
+import supertest from "supertest";
+import { afterEach, beforeEach, describe, expect, test } from "vitest";
+import { CommercetoolsMock } from "../index";
 
-describe('Inventory Entry Query', () => {
-	const ctMock = new CommercetoolsMock()
-	let inventoryEntry: InventoryEntry | undefined
+describe("Inventory Entry Query", () => {
+	const ctMock = new CommercetoolsMock();
+	let inventoryEntry: InventoryEntry | undefined;
 
 	beforeEach(async () => {
-		const response = await supertest(ctMock.app).post('/dummy/inventory').send({
-			sku: '1337',
+		const response = await supertest(ctMock.app).post("/dummy/inventory").send({
+			sku: "1337",
 			quantityOnStock: 100,
-		})
-		expect(response.status).toBe(201)
-		inventoryEntry = response.body
-	})
+		});
+		expect(response.status).toBe(201);
+		inventoryEntry = response.body;
+	});
 
 	afterEach(() => {
-		ctMock.clear()
-	})
+		ctMock.clear();
+	});
 
-	test('no filter', async () => {
-		assert(inventoryEntry, 'inventory entry not created')
+	test("no filter", async () => {
+		assert(inventoryEntry, "inventory entry not created");
 
-		const response = await supertest(ctMock.app).get(`/dummy/inventory`)
-		expect(response.status).toBe(200)
-		expect(response.body.count).toBe(1)
-		expect(response.body.total).toBe(1)
-		expect(response.body.offset).toBe(0)
-		expect(response.body.limit).toBe(20)
-	})
+		const response = await supertest(ctMock.app).get(`/dummy/inventory`);
+		expect(response.status).toBe(200);
+		expect(response.body.count).toBe(1);
+		expect(response.body.total).toBe(1);
+		expect(response.body.offset).toBe(0);
+		expect(response.body.limit).toBe(20);
+	});
 
-	test('filter sku', async () => {
-		assert(inventoryEntry, 'inventory entry not created')
+	test("filter sku", async () => {
+		assert(inventoryEntry, "inventory entry not created");
 
 		{
 			const response = await supertest(ctMock.app)
 				.get(`/dummy/inventory`)
-				.query({ where: 'sku="unknown"' })
-			expect(response.status).toBe(200)
-			expect(response.body.count).toBe(0)
+				.query({ where: 'sku="unknown"' });
+			expect(response.status).toBe(200);
+			expect(response.body.count).toBe(0);
 		}
 		{
 			const response = await supertest(ctMock.app)
 				.get(`/dummy/inventory`)
-				.query({ where: 'sku="1337"' })
-			expect(response.status).toBe(200)
-			expect(response.body.count).toBe(1)
+				.query({ where: 'sku="1337"' });
+			expect(response.status).toBe(200);
+			expect(response.body.count).toBe(1);
 		}
-	})
-})
+	});
+});
 
-describe('Inventory Entry Update Actions', () => {
-	const ctMock = new CommercetoolsMock()
-	let inventoryEntry: InventoryEntry | undefined
-	let customType: Type | undefined
+describe("Inventory Entry Update Actions", () => {
+	const ctMock = new CommercetoolsMock();
+	let inventoryEntry: InventoryEntry | undefined;
+	let customType: Type | undefined;
 
 	beforeEach(async () => {
-		let response = await supertest(ctMock.app).post('/dummy/inventory').send({
-			sku: '1337',
+		let response = await supertest(ctMock.app).post("/dummy/inventory").send({
+			sku: "1337",
 			quantityOnStock: 100,
-		})
-		expect(response.status).toBe(201)
-		inventoryEntry = response.body
+		});
+		expect(response.status).toBe(201);
+		inventoryEntry = response.body;
 
 		response = await supertest(ctMock.app)
-			.post('/dummy/types')
+			.post("/dummy/types")
 			.send({
-				key: 'custom-inventory',
+				key: "custom-inventory",
 				name: {
-					'nl-NL': 'custom-inventory',
+					"nl-NL": "custom-inventory",
 				},
-				resourceTypeIds: ['inventory-entry'],
-			})
-		expect(response.status).toBe(201)
-		customType = response.body
-	})
+				resourceTypeIds: ["inventory-entry"],
+			});
+		expect(response.status).toBe(201);
+		customType = response.body;
+	});
 
-	test('changeQuantity', async () => {
-		assert(inventoryEntry, 'inventory entry not created')
+	test("changeQuantity", async () => {
+		assert(inventoryEntry, "inventory entry not created");
 
 		const response = await supertest(ctMock.app)
 			.post(`/dummy/inventory/${inventoryEntry.id}`)
 			.send({
 				version: 1,
-				actions: [{ action: 'changeQuantity', quantity: 300 }],
-			})
-		expect(response.status).toBe(200)
-		expect(response.body.version).toBe(2)
-		expect(response.body.availableQuantity).toBe(300)
-		expect(response.body.quantityOnStock).toBe(300)
-	})
-
-	test('set custom type', async () => {
-		assert(inventoryEntry, 'inventory entry not created')
-		assert(customType, 'custom type not created')
+				actions: [{ action: "changeQuantity", quantity: 300 }],
+			});
+		expect(response.status).toBe(200);
+		expect(response.body.version).toBe(2);
+		expect(response.body.availableQuantity).toBe(300);
+		expect(response.body.quantityOnStock).toBe(300);
+	});
+
+	test("set custom type", async () => {
+		assert(inventoryEntry, "inventory entry not created");
+		assert(customType, "custom type not created");
 
 		const response = await supertest(ctMock.app)
 			.post(`/dummy/inventory/${inventoryEntry.id}`)
@@ -103,33 +103,33 @@ describe('Inventory Entry Update Actions', () => {
 				version: 1,
 				actions: [
 					{
-						action: 'setCustomType',
-						type: { typeId: 'type', id: customType.id },
+						action: "setCustomType",
+						type: { typeId: "type", id: customType.id },
 					},
 				],
-			})
-		expect(response.status).toBe(200)
-		expect(response.body.version).toBe(2)
-		expect(response.body.custom.type.id).toBe(customType.id)
-	})
-
-	test('set expected delivery', async () => {
-		assert(inventoryEntry, 'inventory entry not created')
-		const expectedDelivery = '2021-04-02T15:06:19.700Z'
+			});
+		expect(response.status).toBe(200);
+		expect(response.body.version).toBe(2);
+		expect(response.body.custom.type.id).toBe(customType.id);
+	});
+
+	test("set expected delivery", async () => {
+		assert(inventoryEntry, "inventory entry not created");
+		const expectedDelivery = "2021-04-02T15:06:19.700Z";
 		const response = await supertest(ctMock.app)
 			.post(`/dummy/inventory/${inventoryEntry.id}`)
 			.send({
 				version: 1,
-				actions: [{ action: 'setExpectedDelivery', expectedDelivery }],
-			})
-		expect(response.status).toBe(200)
-		expect(response.body.version).toBe(2)
-		expect(response.body.expectedDelivery).toBe(expectedDelivery)
-	})
+				actions: [{ action: "setExpectedDelivery", expectedDelivery }],
+			});
+		expect(response.status).toBe(200);
+		expect(response.body.version).toBe(2);
+		expect(response.body.expectedDelivery).toBe(expectedDelivery);
+	});
 
-	test('set custom field', async () => {
-		assert(inventoryEntry, 'inventory entry not created')
-		assert(customType, 'custom type not created')
+	test("set custom field", async () => {
+		assert(inventoryEntry, "inventory entry not created");
+		assert(customType, "custom type not created");
 
 		const setCustomTypeResponse = await supertest(ctMock.app)
 			.post(`/dummy/inventory/${inventoryEntry.id}`)
@@ -137,37 +137,37 @@ describe('Inventory Entry Update Actions', () => {
 				version: 1,
 				actions: [
 					{
-						action: 'setCustomType',
-						type: { typeId: 'type', id: customType.id },
-						fields: { lol: 'bar' },
+						action: "setCustomType",
+						type: { typeId: "type", id: customType.id },
+						fields: { lol: "bar" },
 					},
 				],
-			})
-		expect(setCustomTypeResponse.status).toBe(200)
-		expect(setCustomTypeResponse.body.custom.type.id).toBe(customType.id)
+			});
+		expect(setCustomTypeResponse.status).toBe(200);
+		expect(setCustomTypeResponse.body.custom.type.id).toBe(customType.id);
 
 		const response = await supertest(ctMock.app)
 			.post(`/dummy/inventory/${inventoryEntry.id}`)
 			.send({
 				version: 2,
-				actions: [{ action: 'setCustomField', name: 'foo', value: 'bar' }],
-			})
+				actions: [{ action: "setCustomField", name: "foo", value: "bar" }],
+			});
 
-		expect(response.status).toBe(200)
-		expect(response.body.version).toBe(3)
-		expect(response.body.custom.fields['foo']).toBe('bar')
-	})
+		expect(response.status).toBe(200);
+		expect(response.body.version).toBe(3);
+		expect(response.body.custom.fields["foo"]).toBe("bar");
+	});
 
-	test('set restockable in days', async () => {
-		assert(inventoryEntry, 'inventory entry not created')
+	test("set restockable in days", async () => {
+		assert(inventoryEntry, "inventory entry not created");
 		const response = await supertest(ctMock.app)
 			.post(`/dummy/inventory/${inventoryEntry.id}`)
 			.send({
 				version: 1,
-				actions: [{ action: 'setRestockableInDays', restockableInDays: 0 }],
-			})
-		expect(response.status).toEqual(200)
-		expect(response.body.version).toEqual(2)
-		expect(response.body.restockableInDays).toEqual(0)
-	})
-})
+				actions: [{ action: "setRestockableInDays", restockableInDays: 0 }],
+			});
+		expect(response.status).toEqual(200);
+		expect(response.body.version).toEqual(2);
+		expect(response.body.restockableInDays).toEqual(0);
+	});
+});

package/src/services/inventory-entry.ts

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