@labdigital/commercetools-mock 2.34.3 → 2.35.0

package/src/services/cart.test.ts

@@ -3,6 +3,12 @@ import type {
 	Cart,
 	CentPrecisionMoney,
 	ProductDraft,
+	ShippingMethod,
+	ShippingMethodDraft,
+	ShippingMethodResourceIdentifier,
+	TaxCategory,
+	TaxCategoryDraft,
+	Zone,
 } from "@commercetools/platform-sdk";
 import assert from "assert";
 import supertest from "supertest";
@@ -89,6 +95,41 @@ describe("Cart Update Actions", () => {
 		cart = response.body;
 	};
 
+	const createZone = async (country: string): Promise<Zone> => {
+		const response = await supertest(ctMock.app)
+			.post("/dummy/zones")
+			.send({
+				name: country,
+				locations: [
+					{
+						country,
+					},
+				],
+			});
+		expect(response.status).toBe(201);
+		return response.body;
+	};
+
+	const createTaxCategory = async (
+		draft: TaxCategoryDraft,
+	): Promise<TaxCategory> => {
+		const response = await supertest(ctMock.app)
+			.post("/dummy/tax-categories")
+			.send(draft);
+		expect(response.status).toBe(201);
+		return response.body;
+	};
+
+	const createShippingMethod = async (
+		draft: ShippingMethodDraft,
+	): Promise<ShippingMethod> => {
+		const response = await supertest(ctMock.app)
+			.post("/dummy/shipping-methods")
+			.send(draft);
+		expect(response.status).toBe(201);
+		return response.body;
+	};
+
 	const productDraft: ProductDraft = {
 		name: {
 			"nl-NL": "test product",
@@ -672,6 +713,7 @@ describe("Cart Update Actions", () => {
 			},
 		});
 	});
+
 	test("setShippingAddressCustomType", async () => {
 		assert(cart, "cart not created");
 
@@ -739,6 +781,381 @@ describe("Cart Update Actions", () => {
 			},
 		});
 	});
+
+	describe("setShippingMethod", () => {
+		let standardShippingMethod: ShippingMethod;
+		let standardExcludedShippingMethod: ShippingMethod;
+		beforeEach(async () => {
+			assert(cart, "cart not created");
+			const nlZone = await createZone("NL");
+			const frZone = await createZone("FR");
+			const standardTax = await createTaxCategory({
+				name: "Standard tax category",
+				key: "standard",
+				rates: [
+					{
+						name: "FR standard tax rate",
+						amount: 0.2,
+						includedInPrice: true,
+						country: "FR",
+					},
+					{
+						name: "NL standard tax rate",
+						amount: 0.21,
+						includedInPrice: true,
+						country: "NL",
+					},
+				],
+			});
+			await createTaxCategory({
+				name: "Reduced tax category",
+				key: "reduced",
+				rates: [
+					{
+						name: "FR reduced tax rate",
+						amount: 0.1,
+						includedInPrice: true,
+						country: "FR",
+					},
+					{
+						name: "NL reduced tax rate",
+						amount: 0.09,
+						includedInPrice: true,
+						country: "NL",
+					},
+				],
+			});
+			const standardExcludedTax = await createTaxCategory({
+				name: "Tax category that is excluded from price",
+				key: "standard-excluded",
+				rates: [
+					{
+						name: "FR standard-excluded tax rate",
+						amount: 0.2,
+						includedInPrice: false,
+						country: "FR",
+					},
+					{
+						name: "NL standard-excluded tax rate",
+						amount: 0.21,
+						includedInPrice: false,
+						country: "NL",
+					},
+				],
+			});
+			standardShippingMethod = await createShippingMethod({
+				isDefault: false,
+				key: "standard",
+				name: "Standard shipping",
+				taxCategory: {
+					typeId: "tax-category",
+					id: standardTax.id,
+				},
+				zoneRates: [
+					{
+						zone: {
+							typeId: "zone",
+							id: nlZone.id,
+						},
+						shippingRates: [
+							{
+								price: {
+									type: "centPrecision",
+									currencyCode: "EUR",
+									centAmount: 499,
+									fractionDigits: 2,
+								},
+							},
+						],
+					},
+					{
+						zone: {
+							typeId: "zone",
+							id: frZone.id,
+						},
+						shippingRates: [
+							{
+								price: {
+									type: "centPrecision",
+									currencyCode: "EUR",
+									centAmount: 699,
+									fractionDigits: 2,
+								},
+							},
+						],
+					},
+				],
+			});
+
+			standardExcludedShippingMethod = await createShippingMethod({
+				isDefault: false,
+				key: "standard-excluded",
+				name: "Standard shipping with tax excluded from price",
+				taxCategory: {
+					typeId: "tax-category",
+					id: standardExcludedTax.id,
+				},
+				zoneRates: [
+					{
+						zone: {
+							typeId: "zone",
+							id: nlZone.id,
+						},
+						shippingRates: [
+							{
+								price: {
+									type: "centPrecision",
+									currencyCode: "EUR",
+									centAmount: 499,
+									fractionDigits: 2,
+								},
+							},
+						],
+					},
+					{
+						zone: {
+							typeId: "zone",
+							id: frZone.id,
+						},
+						shippingRates: [
+							{
+								price: {
+									type: "centPrecision",
+									currencyCode: "EUR",
+									centAmount: 699,
+									fractionDigits: 2,
+								},
+							},
+						],
+					},
+				],
+			});
+			await createShippingMethod({
+				isDefault: false,
+				key: "express",
+				name: "Express shipping",
+				taxCategory: {
+					typeId: "tax-category",
+					id: standardTax.id,
+				},
+				zoneRates: [
+					{
+						zone: {
+							typeId: "zone",
+							id: nlZone.id,
+						},
+						shippingRates: [
+							{
+								price: {
+									type: "centPrecision",
+									currencyCode: "EUR",
+									centAmount: 899,
+									fractionDigits: 2,
+								},
+							},
+						],
+					},
+					{
+						zone: {
+							typeId: "zone",
+							id: frZone.id,
+						},
+						shippingRates: [
+							{
+								price: {
+									type: "centPrecision",
+									currencyCode: "EUR",
+									centAmount: 1099,
+									fractionDigits: 2,
+								},
+							},
+						],
+					},
+				],
+			});
+
+			expect(
+				(
+					await supertest(ctMock.app)
+						.post(`/dummy/carts/${cart.id}`)
+						.send({
+							version: 1,
+							actions: [
+								{
+									action: "setShippingAddress",
+									address: {
+										streetName: "Street name",
+										city: "Utrecht",
+										country: "NL",
+									},
+								},
+							],
+						})
+				).status,
+			).toBe(200);
+		});
+
+		test("correctly sets shipping method", async () => {
+			assert(cart, "cart not created");
+
+			const shippingMethod: ShippingMethodResourceIdentifier = {
+				typeId: "shipping-method",
+				id: standardShippingMethod.id,
+			};
+
+			const response = await supertest(ctMock.app)
+				.post(`/dummy/carts/${cart.id}`)
+				.send({
+					version: 2,
+					actions: [{ action: "setShippingMethod", shippingMethod }],
+				});
+			expect(response.status).toBe(200);
+			expect(response.body.version).toBe(3);
+			expect(response.body.shippingInfo.shippingMethod.id).toEqual(
+				standardShippingMethod.id,
+			);
+		});
+
+		test("correctly sets shippingInfo rates + tax when includedInPrice: true", async () => {
+			assert(cart, "cart not created");
+			assert(standardShippingMethod, "shipping method not created");
+
+			const shippingMethod: ShippingMethodResourceIdentifier = {
+				typeId: "shipping-method",
+				id: standardShippingMethod.id,
+			};
+
+			const response = await supertest(ctMock.app)
+				.post(`/dummy/carts/${cart.id}`)
+				.send({
+					version: 2,
+					actions: [{ action: "setShippingMethod", shippingMethod }],
+				});
+			expect(response.status).toBe(200);
+			expect(response.body.version).toBe(3);
+			expect(response.body.shippingInfo.shippingRate.price).toMatchObject({
+				centAmount: 499,
+				currencyCode: "EUR",
+				fractionDigits: 2,
+				type: "centPrecision",
+			});
+			expect(response.body.shippingInfo.price).toMatchObject({
+				centAmount: 499,
+				currencyCode: "EUR",
+				fractionDigits: 2,
+				type: "centPrecision",
+			});
+			expect(response.body.shippingInfo.taxRate).toMatchObject({
+				name: "NL standard tax rate",
+				amount: 0.21,
+				includedInPrice: true,
+				country: "NL",
+			});
+			expect(response.body.shippingInfo.taxedPrice).toMatchObject({
+				totalNet: {
+					type: "centPrecision",
+					centAmount: 412,
+					currencyCode: "EUR",
+					fractionDigits: 2,
+				},
+				totalGross: {
+					type: "centPrecision",
+					centAmount: 499,
+					currencyCode: "EUR",
+					fractionDigits: 2,
+				},
+				taxPortions: [
+					{
+						name: "NL standard tax rate",
+						rate: 0.21,
+						amount: {
+							type: "centPrecision",
+							centAmount: 87,
+							currencyCode: "EUR",
+							fractionDigits: 2,
+						},
+					},
+				],
+				totalTax: {
+					type: "centPrecision",
+					centAmount: 87,
+					currencyCode: "EUR",
+					fractionDigits: 2,
+				},
+			});
+		});
+
+		test("correctly sets shippingInfo rates + tax when includedInPrice: false", async () => {
+			assert(cart, "cart not created");
+			assert(standardExcludedShippingMethod, "shipping method not created");
+
+			const shippingMethod: ShippingMethodResourceIdentifier = {
+				typeId: "shipping-method",
+				id: standardExcludedShippingMethod.id,
+			};
+
+			const response = await supertest(ctMock.app)
+				.post(`/dummy/carts/${cart.id}`)
+				.send({
+					version: 2,
+					actions: [{ action: "setShippingMethod", shippingMethod }],
+				});
+			expect(response.status).toBe(200);
+			expect(response.body.version).toBe(3);
+			expect(response.body.shippingInfo.shippingRate.price).toMatchObject({
+				centAmount: 499,
+				currencyCode: "EUR",
+				fractionDigits: 2,
+				type: "centPrecision",
+			});
+			// TODO: should this be gross or net? docs unclear (currently always just returns the shipping rate (tier) price)
+			expect(response.body.shippingInfo.price).toMatchObject({
+				centAmount: 499,
+				currencyCode: "EUR",
+				fractionDigits: 2,
+				type: "centPrecision",
+			});
+			expect(response.body.shippingInfo.taxRate).toMatchObject({
+				name: "NL standard-excluded tax rate",
+				amount: 0.21,
+				includedInPrice: false,
+				country: "NL",
+			});
+			expect(response.body.shippingInfo.taxedPrice).toMatchObject({
+				totalNet: {
+					type: "centPrecision",
+					centAmount: 499,
+					currencyCode: "EUR",
+					fractionDigits: 2,
+				},
+				totalGross: {
+					type: "centPrecision",
+					centAmount: 604,
+					currencyCode: "EUR",
+					fractionDigits: 2,
+				},
+				taxPortions: [
+					{
+						name: "NL standard-excluded tax rate",
+						rate: 0.21,
+						amount: {
+							type: "centPrecision",
+							centAmount: 105,
+							currencyCode: "EUR",
+							fractionDigits: 2,
+						},
+					},
+				],
+				totalTax: {
+					type: "centPrecision",
+					centAmount: 105,
+					currencyCode: "EUR",
+					fractionDigits: 2,
+				},
+			});
+		});
+	});
+
 	test("setLineItemShippingDetails", async () => {
 		const product = await supertest(ctMock.app)
 			.post(`/dummy/products`)

package/src/{shippingCalculator.test.ts → shipping.test.ts}

@@ -7,7 +7,7 @@ import { describe, expect, it } from "vitest";
 import {
 	markMatchingShippingRate,
 	markMatchingShippingRatePriceTiers,
-} from "./shippingCalculator";
+} from "./shipping";
 
 // describe('markMatchingShippingMethods', () => {
 // 	const zones: Record<string, Zone> = {

package/src/shipping.ts

@@ -0,0 +1,147 @@
+import {
+	Cart,
+	CartValueTier,
+	InvalidOperationError,
+	ShippingRate,
+	ShippingRatePriceTier,
+} from "@commercetools/platform-sdk";
+import { CommercetoolsError } from "./exceptions";
+import { GetParams, RepositoryContext } from "./repositories/abstract";
+import { AbstractStorage } from "./storage/abstract";
+
+export const markMatchingShippingRate = (
+	cart: Cart,
+	shippingRate: ShippingRate,
+): ShippingRate => {
+	const isMatching =
+		shippingRate.price.currencyCode === cart.totalPrice.currencyCode;
+	return {
+		...shippingRate,
+		tiers: markMatchingShippingRatePriceTiers(cart, shippingRate.tiers),
+		isMatching: isMatching,
+	};
+};
+
+export const markMatchingShippingRatePriceTiers = (
+	cart: Cart,
+	tiers: ShippingRatePriceTier[],
+): ShippingRatePriceTier[] => {
+	if (tiers.length === 0) {
+		return [];
+	}
+
+	if (new Set(tiers.map((tier) => tier.type)).size > 1) {
+		throw new Error("Can't handle multiple types of tiers");
+	}
+
+	const tierType = tiers[0].type;
+	switch (tierType) {
+		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}`);
+	}
+};
+
+const markMatchingCartValueTiers = (
+	cart: Cart,
+	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,
+	);
+
+	// 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;
+	for (const tier of sortedTiers) {
+		const isMatching =
+			!hasMatchingTier &&
+			cart.totalPrice.currencyCode === tier.price.currencyCode &&
+			cart.totalPrice.centAmount >= tier.minimumCentAmount;
+
+		if (isMatching) hasMatchingTier = true;
+		result[tier.minimumCentAmount] = {
+			...tier,
+			isMatching: isMatching,
+		};
+	}
+
+	return tiers.map((tier) => result[tier.minimumCentAmount]);
+};
+
+/*
+ * Retrieves all the ShippingMethods that can ship to the shipping address of
+ * the given Cart. Each ShippingMethod contains exactly one ShippingRate with
+ * the flag isMatching set to true. This ShippingRate is used when the
+ * ShippingMethod is added to the Cart.
+ */
+export const getShippingMethodsMatchingCart = (
+	context: RepositoryContext,
+	storage: AbstractStorage,
+	cart: Cart,
+	params: GetParams = {},
+) => {
+	if (!cart.shippingAddress?.country) {
+		throw new CommercetoolsError<InvalidOperationError>({
+			code: "InvalidOperation",
+			message: `The cart with ID '${cart.id}' does not have a shipping address set.`,
+		});
+	}
+
+	// Get all shipping methods that have a zone that matches the shipping address
+	const zones = storage.query<"zone">(context.projectKey, "zone", {
+		where: [`locations(country="${cart.shippingAddress.country}"))`],
+		limit: 100,
+	});
+	const zoneIds = zones.results.map((zone) => zone.id);
+	const shippingMethods = storage.query<"shipping-method">(
+		context.projectKey,
+		"shipping-method",
+		{
+			"where": [
+				`zoneRates(zone(id in (:zoneIds)))`,
+				`zoneRates(shippingRates(price(currencyCode="${cart.totalPrice.currencyCode}")))`,
+			],
+			"var.zoneIds": zoneIds,
+			"expand": params.expand,
+		},
+	);
+
+	// Make sure that each shipping method has exactly one shipping rate and
+	// that the shipping rate is marked as matching
+	const results = shippingMethods.results
+		.map((shippingMethod) => {
+			// Iterate through the zoneRates, process the shipping rates and filter
+			// out all zoneRates which have no matching shipping rates left
+			const rates = shippingMethod.zoneRates
+				.map((zoneRate) => ({
+					zone: zoneRate.zone,
+
+					// Iterate through the shippingRates and mark the matching ones
+					// then we filter out the non-matching ones
+					shippingRates: zoneRate.shippingRates
+						.map((rate) => markMatchingShippingRate(cart, rate))
+						.filter((rate) => rate.isMatching),
+				}))
+				.filter((zoneRate) => zoneRate.shippingRates.length > 0);
+
+			return {
+				...shippingMethod,
+				zoneRates: rates,
+			};
+		})
+		.filter((shippingMethod) => shippingMethod.zoneRates.length > 0);
+
+	return {
+		...shippingMethods,
+		results: results,
+	};
+};

package/src/shippingCalculator.ts

@@ -1,74 +0,0 @@
-import {
-	Cart,
-	CartValueTier,
-	ShippingRate,
-	ShippingRatePriceTier,
-} from "@commercetools/platform-sdk";
-
-export const markMatchingShippingRate = (
-	cart: Cart,
-	shippingRate: ShippingRate,
-): ShippingRate => {
-	const isMatching =
-		shippingRate.price.currencyCode === cart.totalPrice.currencyCode;
-	return {
-		...shippingRate,
-		tiers: markMatchingShippingRatePriceTiers(cart, shippingRate.tiers),
-		isMatching: isMatching,
-	};
-};
-
-export const markMatchingShippingRatePriceTiers = (
-	cart: Cart,
-	tiers: ShippingRatePriceTier[],
-): ShippingRatePriceTier[] => {
-	if (tiers.length === 0) {
-		return [];
-	}
-
-	if (new Set(tiers.map((tier) => tier.type)).size > 1) {
-		throw new Error("Can't handle multiple types of tiers");
-	}
-
-	const tierType = tiers[0].type;
-	switch (tierType) {
-		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}`);
-	}
-};
-
-const markMatchingCartValueTiers = (
-	cart: Cart,
-	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,
-	);
-
-	// 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;
-	for (const tier of sortedTiers) {
-		const isMatching =
-			!hasMatchingTier &&
-			cart.totalPrice.currencyCode === tier.price.currencyCode &&
-			cart.totalPrice.centAmount >= tier.minimumCentAmount;
-
-		if (isMatching) hasMatchingTier = true;
-		result[tier.minimumCentAmount] = {
-			...tier,
-			isMatching: isMatching,
-		};
-	}
-
-	return tiers.map((tier) => result[tier.minimumCentAmount]);
-};