@labdigital/commercetools-mock 2.17.0 → 2.18.0

package/src/services/subscription.ts

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

package/src/services/tax-category.test.ts

@@ -1,80 +1,80 @@
-import type { TaxCategoryDraft } from '@commercetools/platform-sdk'
-import supertest from 'supertest'
-import { afterEach, describe, expect, test } from 'vitest'
-import { CommercetoolsMock } from '../index.js'
+import type { TaxCategoryDraft } from "@commercetools/platform-sdk";
+import supertest from "supertest";
+import { afterEach, describe, expect, test } from "vitest";
+import { CommercetoolsMock } from "../index";
 
-const ctMock = new CommercetoolsMock()
+const ctMock = new CommercetoolsMock();
 
-describe('Tax Category', () => {
+describe("Tax Category", () => {
 	afterEach(() => {
-		ctMock.clear()
-	})
-	test('Create tax category', async () => {
+		ctMock.clear();
+	});
+	test("Create tax category", async () => {
 		const draft: TaxCategoryDraft = {
-			name: 'foo',
-			key: 'standard',
+			name: "foo",
+			key: "standard",
 			rates: [],
-		}
+		};
 		const response = await supertest(ctMock.app)
-			.post('/dummy/tax-categories')
-			.send(draft)
+			.post("/dummy/tax-categories")
+			.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: 'foo',
+			name: "foo",
 			rates: [],
-			key: 'standard',
+			key: "standard",
 			version: 1,
-		})
-	})
+		});
+	});
 
-	test('Get tax category', async () => {
+	test("Get tax category", async () => {
 		const draft: TaxCategoryDraft = {
-			name: 'foo',
-			key: 'standard',
+			name: "foo",
+			key: "standard",
 			rates: [],
-		}
+		};
 		const createResponse = await supertest(ctMock.app)
-			.post('/dummy/tax-categories')
-			.send(draft)
+			.post("/dummy/tax-categories")
+			.send(draft);
 
-		expect(createResponse.status).toBe(201)
+		expect(createResponse.status).toBe(201);
 
 		const response = await supertest(ctMock.app).get(
-			`/dummy/tax-categories/${createResponse.body.id}`
-		)
+			`/dummy/tax-categories/${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);
+	});
 
-	test('Get tax category with key', async () => {
+	test("Get tax category with key", async () => {
 		const draft: TaxCategoryDraft = {
-			name: 'foo',
-			key: 'standard',
+			name: "foo",
+			key: "standard",
 			rates: [],
-		}
+		};
 		const createResponse = await supertest(ctMock.app)
-			.post('/dummy/tax-categories')
-			.send(draft)
+			.post("/dummy/tax-categories")
+			.send(draft);
 
-		expect(createResponse.status).toBe(201)
+		expect(createResponse.status).toBe(201);
 
 		const response = await supertest(ctMock.app)
 			.get(`/dummy/tax-categories/`)
-			.query({ where: `key="${createResponse.body.key}"` })
+			.query({ where: `key="${createResponse.body.key}"` });
 
-		expect(response.status).toBe(200)
+		expect(response.status).toBe(200);
 		expect(response.body).toEqual({
 			count: 1,
 			limit: 20,
 			offset: 0,
 			total: 1,
 			results: [createResponse.body],
-		})
-	})
-})
+		});
+	});
+});

package/src/services/tax-category.ts

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

package/src/services/type.ts

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

package/src/services/zone.ts

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

package/src/shippingCalculator.test.ts

@@ -2,12 +2,12 @@ import {
 	Cart,
 	ShippingRate,
 	ShippingRatePriceTier,
-} from '@commercetools/platform-sdk'
-import { describe, expect, it } from 'vitest'
+} from "@commercetools/platform-sdk";
+import { describe, expect, it } from "vitest";
 import {
 	markMatchingShippingRate,
 	markMatchingShippingRatePriceTiers,
-} from './shippingCalculator'
+} from "./shippingCalculator";
 
 // describe('markMatchingShippingMethods', () => {
 // 	const zones: Record<string, Zone> = {
@@ -161,107 +161,107 @@ import {
 // 	})
 // })
 
-describe('markMatchingShippingRate', () => {
+describe("markMatchingShippingRate", () => {
 	const rate: ShippingRate = {
 		price: {
-			type: 'centPrecision',
-			currencyCode: 'EUR',
+			type: "centPrecision",
+			currencyCode: "EUR",
 			centAmount: 495,
 			fractionDigits: 2,
 		},
 		freeAbove: {
-			type: 'centPrecision',
-			currencyCode: 'USD',
+			type: "centPrecision",
+			currencyCode: "USD",
 			centAmount: 5000,
 			fractionDigits: 2,
 		},
 		tiers: [],
-	}
+	};
 
-	it('should mark the shipping rate as matching', () => {
+	it("should mark the shipping rate as matching", () => {
 		const cart: Partial<Cart> = {
 			totalPrice: {
-				currencyCode: 'EUR',
+				currencyCode: "EUR",
 				centAmount: 1000,
 				fractionDigits: 2,
-				type: 'centPrecision',
+				type: "centPrecision",
 			},
-		}
+		};
 
-		const result = markMatchingShippingRate(cart as Cart, rate)
+		const result = markMatchingShippingRate(cart as Cart, rate);
 		expect(result).toMatchObject({
 			...rate,
 			isMatching: true,
-		})
-	})
+		});
+	});
 
-	it('should mark the shipping rate as not matching', () => {
+	it("should mark the shipping rate as not matching", () => {
 		const cart: Partial<Cart> = {
 			totalPrice: {
-				currencyCode: 'USD',
+				currencyCode: "USD",
 				centAmount: 1000,
 				fractionDigits: 2,
-				type: 'centPrecision',
+				type: "centPrecision",
 			},
-		}
+		};
 
-		const result = markMatchingShippingRate(cart as Cart, rate)
+		const result = markMatchingShippingRate(cart as Cart, rate);
 		expect(result).toMatchObject({
 			...rate,
 			isMatching: false,
-		})
-	})
-})
+		});
+	});
+});
 
-describe('markMatchingShippingRatePriceTiers', () => {
-	it('should handle CartValue types', () => {
+describe("markMatchingShippingRatePriceTiers", () => {
+	it("should handle CartValue types", () => {
 		const tiers: ShippingRatePriceTier[] = [
 			// Above 100 euro shipping is 4 euro
 			{
-				type: 'CartValue',
+				type: "CartValue",
 				minimumCentAmount: 10000,
 				price: {
-					type: 'centPrecision',
-					currencyCode: 'EUR',
+					type: "centPrecision",
+					currencyCode: "EUR",
 					centAmount: 400,
 					fractionDigits: 2,
 				},
 			},
 			// Above 200 euro shipping is 3 euro
 			{
-				type: 'CartValue',
+				type: "CartValue",
 				minimumCentAmount: 20000,
 				price: {
-					type: 'centPrecision',
-					currencyCode: 'EUR',
+					type: "centPrecision",
+					currencyCode: "EUR",
 					centAmount: 300,
 					fractionDigits: 2,
 				},
 			},
 			// Above 50 euro shipping is 5 euro
 			{
-				type: 'CartValue',
+				type: "CartValue",
 				minimumCentAmount: 500,
 				price: {
-					type: 'centPrecision',
-					currencyCode: 'EUR',
+					type: "centPrecision",
+					currencyCode: "EUR",
 					centAmount: 700,
 					fractionDigits: 2,
 				},
 			},
-		]
+		];
 
 		// Create a cart with a total price of 90 euro
 		const cart: Partial<Cart> = {
 			totalPrice: {
-				currencyCode: 'EUR',
+				currencyCode: "EUR",
 				centAmount: 9000,
 				fractionDigits: 2,
-				type: 'centPrecision',
+				type: "centPrecision",
 			},
-		}
+		};
 
-		const result = markMatchingShippingRatePriceTiers(cart as Cart, tiers)
+		const result = markMatchingShippingRatePriceTiers(cart as Cart, tiers);
 		expect(result).toMatchObject([
 			{
 				minimumCentAmount: 10000,
@@ -275,6 +275,6 @@ describe('markMatchingShippingRatePriceTiers', () => {
 				minimumCentAmount: 500,
 				isMatching: true,
 			},
-		])
-	})
-})
+		]);
+	});
+});

package/src/shippingCalculator.ts

@@ -3,72 +3,72 @@ import {
 	CartValueTier,
 	ShippingRate,
 	ShippingRatePriceTier,
-} from '@commercetools/platform-sdk'
+} from "@commercetools/platform-sdk";
 
 export const markMatchingShippingRate = (
 	cart: Cart,
-	shippingRate: ShippingRate
+	shippingRate: ShippingRate,
 ): ShippingRate => {
 	const isMatching =
-		shippingRate.price.currencyCode === cart.totalPrice.currencyCode
+		shippingRate.price.currencyCode === cart.totalPrice.currencyCode;
 	return {
 		...shippingRate,
 		tiers: markMatchingShippingRatePriceTiers(cart, shippingRate.tiers),
 		isMatching: isMatching,
-	}
-}
+	};
+};
 
 export const markMatchingShippingRatePriceTiers = (
 	cart: Cart,
-	tiers: ShippingRatePriceTier[]
+	tiers: ShippingRatePriceTier[],
 ): ShippingRatePriceTier[] => {
 	if (tiers.length === 0) {
-		return []
+		return [];
 	}
 
 	if (new Set(tiers.map((tier) => tier.type)).size > 1) {
-		throw new Error("Can't handle multiple types of tiers")
+		throw new Error("Can't handle multiple types of tiers");
 	}
 
-	const tierType = tiers[0].type
+	const tierType = tiers[0].type;
 	switch (tierType) {
-		case 'CartValue':
-			return markMatchingCartValueTiers(cart, tiers as CartValueTier[])
+		case "CartValue":
+			return markMatchingCartValueTiers(cart, tiers as CartValueTier[]);
 		// case 'CartClassification':
 		// 	return markMatchingCartClassificationTiers(cart, tiers)
 		// case 'CartScore':
 		// 	return markMatchingCartScoreTiers(cart, tiers)
 		default:
-			throw new Error(`Unsupported tier type: ${tierType}`)
+			throw new Error(`Unsupported tier type: ${tierType}`);
 	}
-}
+};
 
 const markMatchingCartValueTiers = (
 	cart: Cart,
-	tiers: readonly CartValueTier[]
+	tiers: readonly CartValueTier[],
 ): ShippingRatePriceTier[] => {
 	// Sort tiers from high to low since we only want to match the highest tier
 	const sortedTiers = [...tiers].sort(
-		(a, b) => b.minimumCentAmount - a.minimumCentAmount
-	)
+		(a, b) => b.minimumCentAmount - a.minimumCentAmount,
+	);
 
 	// Find the first tier that matches the cart and set the flag. We push
 	// the results into a map so that we can output the tiers in the same order as
 	// we received them.
-	const result: Record<number, ShippingRatePriceTier> = {}
-	let hasMatchingTier = false
+	const result: Record<number, ShippingRatePriceTier> = {};
+	let hasMatchingTier = false;
 	for (const tier of sortedTiers) {
 		const isMatching =
 			!hasMatchingTier &&
 			cart.totalPrice.currencyCode === tier.price.currencyCode &&
-			cart.totalPrice.centAmount >= tier.minimumCentAmount
+			cart.totalPrice.centAmount >= tier.minimumCentAmount;
 
-		if (isMatching) hasMatchingTier = true
+		if (isMatching) hasMatchingTier = true;
 		result[tier.minimumCentAmount] = {
 			...tier,
 			isMatching: isMatching,
-		}
+		};
 	}
 
-	return tiers.map((tier) => result[tier.minimumCentAmount])
-}
+	return tiers.map((tier) => result[tier.minimumCentAmount]);
+};

package/src/storage/abstract.ts

@@ -3,80 +3,82 @@ import type {
 	Project,
 	QueryParam,
 	ResourceIdentifier,
-} from '@commercetools/platform-sdk'
-import { PagedQueryResponseMap, ResourceMap, ResourceType } from '../types.js'
+} from "@commercetools/platform-sdk";
+import { PagedQueryResponseMap, ResourceMap, ResourceType } from "../types";
 
 export type GetParams = {
-	expand?: string[]
-}
+	expand?: string[];
+};
 
 export type QueryParams = {
-	expand?: string | string[]
-	sort?: string | string[]
-	limit?: number
-	offset?: number
-	withTotal?: boolean
-	where?: string | string[]
-	[key: string]: QueryParam
-}
+	expand?: string | string[];
+	sort?: string | string[];
+	limit?: number;
+	offset?: number;
+	withTotal?: boolean;
+	where?: string | string[];
+	[key: string]: QueryParam;
+};
 
 export abstract class AbstractStorage {
-	abstract clear(): void
+	abstract clear(): void;
 
 	abstract all<RT extends ResourceType>(
 		projectKey: string,
-		typeId: RT
-	): Array<ResourceMap[RT]>
+		typeId: RT,
+	): Array<ResourceMap[RT]>;
 
 	abstract add<RT extends ResourceType>(
 		projectKey: string,
 		typeId: RT,
-		obj: ResourceMap[RT]
-	): void
+		obj: ResourceMap[RT],
+	): ResourceMap[RT];
 
 	abstract get<RT extends ResourceType>(
 		projectKey: string,
 		typeId: RT,
 		id: string,
-		params?: GetParams
-	): ResourceMap[RT] | null
+		params?: GetParams,
+	): ResourceMap[RT] | null;
 
 	abstract getByKey<RT extends ResourceType>(
 		projectKey: string,
 		typeId: RT,
 		key: string,
-		params: GetParams
-	): ResourceMap[RT] | null
+		params: GetParams,
+	): ResourceMap[RT] | null;
 
-	abstract addProject(projectKey: string): Project
-	abstract getProject(projectKey: string): Project
-	abstract saveProject(project: Project): Project
+	abstract addProject(projectKey: string): Project;
+
+	abstract getProject(projectKey: string): Project;
+
+	abstract saveProject(project: Project): Project;
 
 	abstract delete<RT extends ResourceType>(
 		projectKey: string,
 		typeId: RT,
 		id: string,
-		params: GetParams
-	): ResourceMap[RT] | null
+		params: GetParams,
+	): ResourceMap[RT] | null;
 
 	abstract query<RT extends ResourceType>(
 		projectKey: string,
 		typeId: RT,
-		params: QueryParams
-	): PagedQueryResponseMap[RT]
+		params: QueryParams,
+	): PagedQueryResponseMap[RT];
 
 	abstract getByResourceIdentifier<RT extends ResourceType>(
 		projectKey: string,
-		identifier: ResourceIdentifier
-	): ResourceMap[RT]
+		identifier: ResourceIdentifier,
+	): ResourceMap[RT];
 
 	abstract expand<T>(
 		projectKey: string,
 		obj: T,
-		clause: undefined | string | string[]
-	): T
+		clause: undefined | string | string[],
+	): T;
 }
 
 export type ProjectStorage = {
-	[index in ResourceType]: Map<string, BaseResource>
-}
+	[index in ResourceType]: Map<string, BaseResource>;
+};