@labdigital/commercetools-mock 2.41.0 → 2.42.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@labdigital/commercetools-mock",
-  "version": "2.41.0",
+  "version": "2.42.0",
   "license": "MIT",
   "author": "Michael van Tellingen",
   "type": "module",

package/src/ctMock.ts

@@ -12,7 +12,6 @@ import { OAuth2Server } from "./oauth/server";
 import { ProjectAPI } from "./projectAPI";
 import type { AbstractStorage } from "./storage";
 import { InMemoryStorage } from "./storage";
-import type { Services } from "./types";
 
 // Services
 import { warnDeprecation } from "./deprecation";
@@ -56,15 +55,12 @@ export class CommercetoolsMock {
 
 	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;
 
@@ -154,7 +150,7 @@ export class CommercetoolsMock {
 		}
 
 		// Register the rest api services in the router
-		this._services = createServices(projectRouter, this._repositories);
+		createServices(projectRouter, this._repositories);
 		this._projectService = new ProjectService(
 			projectRouter,
 			this._repositories.project as ProjectRepository,

package/src/repositories/as-associate.ts

@@ -0,0 +1,5 @@
+import { CartRepository } from "./cart";
+import { OrderRepository } from "./order";
+
+export class AsAssociateOrderRepository extends OrderRepository {}
+export class AsAssociateCartRepository extends CartRepository {}

package/src/repositories/business-unit.ts

@@ -91,9 +91,10 @@ export class BusinessUnitRepository extends AbstractResourceRepository<"business
 			associateMode: draft.associateMode,
 			approvalRuleMode: draft.approvalRuleMode,
 
-			associates: draft.associates?.map((a) =>
-				createAssociate(a, context.projectKey, this._storage),
-			),
+			associates:
+				draft.associates?.map((a) =>
+					createAssociate(a, context.projectKey, this._storage),
+				) ?? [],
 		};
 
 		if (this._isDivisionDraft(draft)) {

package/src/repositories/customer/index.test.ts

@@ -46,7 +46,7 @@ describe("Customer repository", () => {
 		);
 	});
 
-	test("adding stores to customer", async () => {
+	test("adding multiple stores to customer", async () => {
 		const store1: Store = {
 			id: "d0016081-e9af-48a7-8133-1f04f340a335",
 			key: "store-1",
@@ -112,6 +112,46 @@ describe("Customer repository", () => {
 		]);
 	});
 
+	test("adding single store to customer", async () => {
+		const store1: Store = {
+			id: "58082253-fe4e-4714-941f-86ab596d42ed",
+			key: "store-1",
+			name: {
+				en: "Store 1",
+			},
+			version: 1,
+			createdAt: "2021-09-02T12:23:30.036Z",
+			lastModifiedAt: "2021-09-02T12:23:30.546Z",
+			languages: [],
+			distributionChannels: [],
+			countries: [],
+			supplyChannels: [],
+			productSelections: [],
+		};
+
+		storage.add("dummy", "store", store1);
+
+		const result = repository.create(
+			{ projectKey: "dummy" },
+			{
+				email: "my-customer2@email.com",
+				stores: [
+					{
+						typeId: "store",
+						key: store1.key,
+					},
+				],
+			},
+		);
+
+		expect(result?.stores).toEqual([
+			{
+				typeId: "store",
+				key: store1.key,
+			},
+		]);
+	});
+
 	test("adding customer without linked stores", async () => {
 		const result = repository.create(
 			{ projectKey: "dummy" },

package/src/repositories/customer/index.ts

@@ -9,7 +9,9 @@ import type {
 	InvalidInputError,
 	MyCustomerResetPassword,
 	ResourceNotFoundError,
+	Store,
 	StoreKeyReference,
+	StoreResourceIdentifier,
 } from "@commercetools/platform-sdk";
 import { CommercetoolsError } from "~src/exceptions";
 import { generateRandomString, getBaseResourceProperties } from "~src/helpers";
@@ -106,28 +108,10 @@ export class CustomerRepository extends AbstractResourceRepository<"customer"> {
 		let storesForCustomer: StoreKeyReference[] = [];
 
 		if (draft.stores && draft.stores.length > 0) {
-			const storeIds = draft.stores
-				.map((storeReference) => storeReference.id)
-				.filter(Boolean);
-
-			const stores = this._storage.query(context.projectKey, "store", {
-				where: storeIds.map((id) => `id="${id}"`),
-			}).results;
-
-			if (storeIds.length !== stores.length) {
-				throw new CommercetoolsError<ResourceNotFoundError>({
-					code: "ResourceNotFound",
-					message: `Store with ID '${storeIds.find((id) => !stores.some((store) => store.id === id))}' was not found.`,
-				});
-			}
-
-			storesForCustomer = draft.stores.map((storeReference) => ({
-				typeId: "store",
-				key:
-					storeReference.key ??
-					(stores.find((store) => store.id === storeReference.id)
-						?.key as string),
-			}));
+			storesForCustomer = this.storeReferenceToStoreKeyReference(
+				draft.stores,
+				context.projectKey,
+			);
 		}
 
 		const resource: Customer = {
@@ -267,4 +251,35 @@ export class CustomerRepository extends AbstractResourceRepository<"customer"> {
 			value: token,
 		};
 	}
+
+	private storeReferenceToStoreKeyReference(
+		draftStores: StoreResourceIdentifier[],
+		projectKey: string,
+	): StoreKeyReference[] {
+		const storeIds = draftStores
+			.map((storeReference) => storeReference.id)
+			.filter(Boolean);
+
+		let stores: Store[] = [];
+
+		if (storeIds.length > 0) {
+			stores = this._storage.query(projectKey, "store", {
+				where: storeIds.map((id) => `id="${id}"`),
+			}).results;
+
+			if (storeIds.length !== stores.length) {
+				throw new CommercetoolsError<ResourceNotFoundError>({
+					code: "ResourceNotFound",
+					message: `Store with ID '${storeIds.find((id) => !stores.some((store) => store.id === id))}' was not found.`,
+				});
+			}
+		}
+
+		return draftStores.map((storeReference) => ({
+			typeId: "store",
+			key:
+				storeReference.key ??
+				(stores.find((store) => store.id === storeReference.id)?.key as string),
+		}));
+	}
 }

package/src/repositories/index.ts

@@ -1,5 +1,9 @@
 import { ProductTailoringRepository } from "~src/repositories/product-tailoring";
 import type { AbstractStorage } from "../storage";
+import {
+	AsAssociateCartRepository,
+	AsAssociateOrderRepository,
+} from "./as-associate";
 import { AssociateRoleRepository } from "./associate-role";
 import { AttributeGroupRepository } from "./attribute-group";
 import { BusinessUnitRepository } from "./business-unit";
@@ -41,6 +45,10 @@ import { ZoneRepository } from "./zone";
 export type RepositoryMap = ReturnType<typeof createRepositories>;
 
 export const createRepositories = (storage: AbstractStorage) => ({
+	"as-associate": {
+		cart: new AsAssociateCartRepository(storage),
+		order: new AsAssociateOrderRepository(storage),
+	},
 	"associate-role": new AssociateRoleRepository(storage),
 	"attribute-group": new AttributeGroupRepository(storage),
 	"business-unit": new BusinessUnitRepository(storage),

package/src/services/as-associate-cart.ts

@@ -0,0 +1,33 @@
+import { Router } from "express";
+import type { CartRepository } from "../repositories/cart";
+import AbstractService from "./abstract";
+
+export class AsAssociateCartService extends AbstractService {
+	public repository: CartRepository;
+
+	constructor(parent: Router, repository: CartRepository) {
+		super(parent);
+		this.repository = repository;
+	}
+
+	getBasePath() {
+		return "carts";
+	}
+
+	registerRoutes(parent: Router) {
+		const basePath = this.getBasePath();
+		const router = Router({ mergeParams: true });
+
+		this.extraRoutes(router);
+
+		router.get("/", this.get.bind(this));
+		router.get("/:id", this.getWithId.bind(this));
+
+		router.delete("/:id", this.deleteWithId.bind(this));
+
+		router.post("/", this.post.bind(this));
+		router.post("/:id", this.postWithId.bind(this));
+
+		parent.use(`/${basePath}`, router);
+	}
+}

package/src/services/as-associate-order.test.ts

@@ -0,0 +1,64 @@
+import type { Order } 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("Order Query", () => {
+	const ctMock = new CommercetoolsMock();
+	let order: Order | undefined;
+	const projectKey = "dummy";
+	const customerId = "5fac8fca-2484-4b14-a1d1-cfdce2f8d3c4";
+	const businessUnitKey = "business-unit";
+
+	beforeEach(async () => {
+		let response = await supertest(ctMock.app)
+			.post(
+				`/${projectKey}/as-associate/${customerId}/in-business-unit/key=${businessUnitKey}/carts`,
+			)
+			.send({
+				currency: "EUR",
+				custom: {
+					type: {
+						key: "my-cart",
+					},
+					fields: {
+						description: "example description",
+					},
+				},
+			});
+		expect(response.status).toBe(201);
+		const cart = response.body;
+
+		response = await supertest(ctMock.app)
+			.post(
+				`/${projectKey}/as-associate/${customerId}/in-business-unit/key=${businessUnitKey}/orders`,
+			)
+			.send({
+				cart: {
+					typeId: "cart",
+					id: cart.id,
+				},
+				orderNumber: "foobar",
+			});
+		expect(response.status).toBe(201);
+		order = response.body;
+	});
+
+	afterEach(() => {
+		ctMock.clear();
+	});
+
+	test("no filter", async () => {
+		assert(order, "order not created");
+
+		const response = await supertest(ctMock.app).get(
+			`/${projectKey}/as-associate/${customerId}/in-business-unit/key=${businessUnitKey}/orders`,
+		);
+		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);
+	});
+});

package/src/services/as-associate-order.ts

@@ -0,0 +1,33 @@
+import { Router } from "express";
+import type { MyOrderRepository } from "../repositories/my-order";
+import AbstractService from "./abstract";
+
+export class AsAssociateOrderService extends AbstractService {
+	public repository: MyOrderRepository;
+
+	constructor(parent: Router, repository: MyOrderRepository) {
+		super(parent);
+		this.repository = repository;
+	}
+
+	getBasePath() {
+		return "orders";
+	}
+
+	registerRoutes(parent: Router) {
+		const basePath = this.getBasePath();
+		const router = Router({ mergeParams: true });
+
+		this.extraRoutes(router);
+
+		router.get("/", this.get.bind(this));
+		router.get("/:id", this.getWithId.bind(this));
+
+		router.delete("/:id", this.deleteWithId.bind(this));
+
+		router.post("/", this.post.bind(this));
+		router.post("/:id", this.postWithId.bind(this));
+
+		parent.use(`/${basePath}`, router);
+	}
+}

package/src/services/as-associate.ts

@@ -0,0 +1,34 @@
+import { Router } from "express";
+import type {
+	AsAssociateCartRepository,
+	AsAssociateOrderRepository,
+} from "~src/repositories/as-associate";
+import { AsAssociateCartService } from "./as-associate-cart";
+import { AsAssociateOrderService } from "./as-associate-order";
+
+type Repositories = {
+	cart: AsAssociateCartRepository;
+	order: AsAssociateOrderRepository;
+};
+
+export class AsAssociateService {
+	router: Router;
+
+	subServices: {
+		cart: AsAssociateCartService;
+		order: AsAssociateOrderService;
+	};
+
+	constructor(parent: Router, repositories: Repositories) {
+		this.router = Router({ mergeParams: true });
+
+		this.subServices = {
+			order: new AsAssociateOrderService(this.router, repositories.order),
+			cart: new AsAssociateCartService(this.router, repositories.cart),
+		};
+		parent.use(
+			"/as-associate/:associateId/in-business-unit/key=:businessUnitId",
+			this.router,
+		);
+	}
+}

package/src/services/index.ts

@@ -1,4 +1,5 @@
 import type { createRepositories } from "../repositories";
+import { AsAssociateService } from "./as-associate";
 import { AssociateRoleServices } from "./associate-roles";
 import { AttributeGroupService } from "./attribute-group";
 import { BusinessUnitServices } from "./business-units";
@@ -41,6 +42,7 @@ export const createServices = (
 	repos: ReturnType<typeof createRepositories>,
 ) => ({
 	"associate-role": new AssociateRoleServices(router, repos["associate-role"]),
+	"as-associate": new AsAssociateService(router, repos["as-associate"]),
 	"business-unit": new BusinessUnitServices(router, repos["business-unit"]),
 	"category": new CategoryServices(router, repos["category"]),
 	"cart": new CartService(router, repos["cart"], repos["order"]),

package/src/types.ts

@@ -1,6 +1,5 @@
 import type * as ctp from "@commercetools/platform-sdk";
 import type { RepositoryMap } from "./repositories";
-import type AbstractService from "./services/abstract";
 
 export const isType = <T>(x: T) => x;
 
@@ -17,10 +16,6 @@ export type ServiceTypes =
 	| "my-customer"
 	| "my-business-unit";
 
-export type Services = Partial<{
-	[index in ServiceTypes]: AbstractService;
-}>;
-
 export type ResourceType = keyof ResourceMap & keyof RepositoryMap;
 
 export type ResourceMap = {