@labdigital/commercetools-mock 2.59.0 → 2.60.0

package/src/repositories/order/index.ts

@@ -2,21 +2,36 @@ import assert from "node:assert";
 import type {
 	Cart,
 	CartReference,
+	CentPrecisionMoney,
 	CustomLineItem,
 	CustomLineItemImportDraft,
 	GeneralError,
+	InvalidOperationError,
 	LineItem,
 	LineItemImportDraft,
+	MissingTaxRateForCountryError,
 	Order,
 	OrderFromCartDraft,
 	OrderImportDraft,
 	Product,
 	ProductPagedQueryResponse,
 	ProductVariant,
+	ShippingInfo,
+	ShippingMethodDoesNotMatchCartError,
+	ShippingMethodReference,
+	TaxPortion,
+	TaxedItemPrice,
 } from "@commercetools/platform-sdk";
+import { Decimal } from "decimal.js/decimal";
 import type { Config } from "~src/config";
 import { CommercetoolsError } from "~src/exceptions";
 import { generateRandomString, getBaseResourceProperties } from "~src/helpers";
+import { calculateTaxTotals, calculateTaxedPriceFromRate } from "~src/lib/tax";
+import {
+	createShippingInfoFromMethod,
+	getShippingMethodsMatchingCart,
+} from "~src/shipping";
+import type { Writable } from "~src/types";
 import type { RepositoryContext } from "../abstract";
 import { AbstractResourceRepository, type QueryParams } from "../abstract";
 import {
@@ -26,6 +41,7 @@ import {
 	createPrice,
 	createTypedMoney,
 	resolveStoreReference,
+	roundDecimal,
 } from "../helpers";
 import { OrderUpdateHandler } from "./actions";
 
@@ -60,7 +76,7 @@ export class OrderRepository extends AbstractResourceRepository<"order"> {
 			throw new Error("Cannot find cart");
 		}
 
-		const resource: Order = {
+		const resource: Writable<Order> = {
 			...getBaseResourceProperties(),
 			anonymousId: cart.anonymousId,
 			billingAddress: cart.billingAddress,
@@ -84,6 +100,7 @@ export class OrderRepository extends AbstractResourceRepository<"order"> {
 			refusedGifts: [],
 			shipping: cart.shipping,
 			shippingAddress: cart.shippingAddress,
+			shippingInfo: cart.shippingInfo,
 			shippingMode: cart.shippingMode,
 			syncInfo: [],
 			taxCalculationMode: cart.taxCalculationMode,
@@ -94,13 +111,23 @@ export class OrderRepository extends AbstractResourceRepository<"order"> {
 			totalPrice: cart.totalPrice,
 			store: cart.store,
 		};
+
+		const { taxedPrice, taxedShippingPrice } = calculateTaxTotals({
+			lineItems: cart.lineItems,
+			customLineItems: cart.customLineItems,
+			shippingInfo: cart.shippingInfo,
+			totalPrice: cart.totalPrice,
+		});
+		resource.taxedPrice = resource.taxedPrice ?? taxedPrice;
+		resource.taxedShippingPrice =
+			resource.taxedShippingPrice ?? taxedShippingPrice;
 		return this.saveNew(context, resource);
 	}
 
 	import(context: RepositoryContext, draft: OrderImportDraft): Order {
 		// TODO: Check if order with given orderNumber already exists
 		assert(this, "OrderRepository not valid");
-		const resource: Order = {
+		const resource: Writable<Order> = {
 			...getBaseResourceProperties(),
 
 			billingAddress: createAddress(
@@ -132,7 +159,7 @@ export class OrderRepository extends AbstractResourceRepository<"order"> {
 			refusedGifts: [],
 			shippingMode: "Single",
 			shipping: [],
-
+			shippingInfo: undefined,
 			store: resolveStoreReference(
 				draft.store,
 				context.projectKey,
@@ -151,6 +178,43 @@ export class OrderRepository extends AbstractResourceRepository<"order"> {
 
 			totalPrice: createCentPrecisionMoney(draft.totalPrice),
 		};
+
+		// Set shipping info after resource is created
+		if (draft.shippingInfo?.shippingMethod) {
+			const { ...shippingMethodRef } = draft.shippingInfo.shippingMethod;
+
+			// get id when reference is by key only
+			if (shippingMethodRef.key && !shippingMethodRef.id) {
+				const shippingMethod =
+					this._storage.getByResourceIdentifier<"shipping-method">(
+						context.projectKey,
+						shippingMethodRef,
+					);
+				if (!shippingMethod) {
+					throw new CommercetoolsError<GeneralError>({
+						code: "General",
+						message: `A shipping method with key '${shippingMethodRef.key}' does not exist.`,
+					});
+				}
+				shippingMethodRef.id = shippingMethod.id;
+			}
+
+			resource.shippingInfo = this.createShippingInfo(context, resource, {
+				typeId: "shipping-method",
+				id: shippingMethodRef.id as string,
+			});
+		}
+
+		const { taxedPrice, taxedShippingPrice } = calculateTaxTotals({
+			lineItems: resource.lineItems,
+			customLineItems: resource.customLineItems,
+			shippingInfo: resource.shippingInfo,
+			totalPrice: resource.totalPrice,
+		});
+		resource.taxedPrice = resource.taxedPrice ?? taxedPrice;
+		resource.taxedShippingPrice =
+			resource.taxedShippingPrice ?? taxedShippingPrice;
+
 		return this.saveNew(context, resource);
 	}
 
@@ -195,6 +259,12 @@ export class OrderRepository extends AbstractResourceRepository<"order"> {
 			throw new Error("No product found");
 		}
 
+		const quantity = draft.quantity ?? 1;
+		const totalPrice = createCentPrecisionMoney({
+			...draft.price.value,
+			centAmount: (draft.price.value.centAmount ?? 0) * quantity,
+		});
+
 		const lineItem: LineItem = {
 			...getBaseResourceProperties(),
 			custom: createCustomFields(
@@ -209,12 +279,17 @@ export class OrderRepository extends AbstractResourceRepository<"order"> {
 			priceMode: "Platform",
 			productId: product.id,
 			productType: product.productType,
-			quantity: draft.quantity,
+			quantity,
 			state: draft.state || [],
 			taxRate: draft.taxRate,
+			taxedPrice: calculateTaxedPriceFromRate(
+				totalPrice.centAmount,
+				totalPrice.currencyCode,
+				draft.taxRate,
+			),
 			taxedPricePortions: [],
 			perMethodTaxRate: [],
-			totalPrice: createCentPrecisionMoney(draft.price.value),
+			totalPrice,
 			variant: {
 				id: variant.id,
 				sku: variant.sku,
@@ -230,6 +305,12 @@ export class OrderRepository extends AbstractResourceRepository<"order"> {
 		context: RepositoryContext,
 		draft: CustomLineItemImportDraft,
 	): CustomLineItem {
+		const quantity = draft.quantity ?? 1;
+		const totalPrice = createCentPrecisionMoney({
+			...draft.money,
+			centAmount: (draft.money.centAmount ?? 0) * quantity,
+		});
+
 		const lineItem: CustomLineItem = {
 			...getBaseResourceProperties(),
 			custom: createCustomFields(
@@ -240,12 +321,17 @@ export class OrderRepository extends AbstractResourceRepository<"order"> {
 			discountedPricePerQuantity: [],
 			money: createTypedMoney(draft.money),
 			name: draft.name,
-			quantity: draft.quantity ?? 0,
+			quantity,
 			perMethodTaxRate: [],
 			priceMode: draft.priceMode ?? "Standard",
 			slug: draft.slug,
 			state: [],
-			totalPrice: createCentPrecisionMoney(draft.money),
+			totalPrice,
+			taxedPrice: calculateTaxedPriceFromRate(
+				totalPrice.centAmount,
+				totalPrice.currencyCode,
+				draft.taxRate,
+			),
 			taxedPricePortions: [],
 		};
 
@@ -272,4 +358,56 @@ export class OrderRepository extends AbstractResourceRepository<"order"> {
 
 		return;
 	}
+
+	createShippingInfo(
+		context: RepositoryContext,
+		resource: Writable<Order>,
+		shippingMethodRef: ShippingMethodReference,
+	): ShippingInfo {
+		const cartLikeForMatching: Writable<Cart> = {
+			...resource,
+			cartState: "Active" as const,
+			inventoryMode: "None" as const,
+			itemShippingAddresses: [],
+			priceRoundingMode: resource.taxRoundingMode || "HalfEven",
+			taxMode: resource.taxMode || "Platform",
+			taxCalculationMode: resource.taxCalculationMode || "LineItemLevel",
+			taxRoundingMode: resource.taxRoundingMode || "HalfEven",
+			discountCodes: resource.discountCodes || [],
+			directDiscounts: resource.directDiscounts || [],
+			shippingInfo: undefined,
+		};
+
+		const shippingMethods = getShippingMethodsMatchingCart(
+			context,
+			this._storage,
+			cartLikeForMatching,
+			{
+				expand: ["zoneRates[*].zone"],
+			},
+		);
+
+		const method = shippingMethods.results.find(
+			(candidate) => candidate.id === shippingMethodRef.id,
+		);
+
+		if (!method) {
+			throw new CommercetoolsError<ShippingMethodDoesNotMatchCartError>({
+				code: "ShippingMethodDoesNotMatchCart",
+				message: `The shipping method with ID '${shippingMethodRef.id}' is not allowed for the order with ID '${resource.id}'.`,
+			});
+		}
+
+		const baseShippingInfo = createShippingInfoFromMethod(
+			context,
+			this._storage,
+			resource,
+			method,
+		);
+
+		return {
+			...baseShippingInfo,
+			deliveries: [],
+		};
+	}
 }

package/src/services/cart.test.ts

@@ -711,6 +711,217 @@ describe("Cart Update Actions", () => {
 		]);
 	});
 
+	test("setLineItemPrice sets an external price for a line item", async () => {
+		const product = await supertest(ctMock.app)
+			.post("/dummy/products")
+			.send(productDraft)
+			.then((x) => x.body);
+
+		assert(product, "product not created");
+
+		const baseCartResponse = await supertest(ctMock.app)
+			.post("/dummy/carts")
+			.send({ currency: "EUR" });
+		expect(baseCartResponse.status).toBe(201);
+		const baseCart = baseCartResponse.body as Cart;
+
+		const addLineItemResponse = await supertest(ctMock.app)
+			.post(`/dummy/carts/${baseCart.id}`)
+			.send({
+				version: baseCart.version,
+				actions: [
+					{
+						action: "addLineItem",
+						sku: product.masterData.current.masterVariant.sku,
+						quantity: 2,
+						key: "line-item-key",
+					},
+				],
+			});
+		expect(addLineItemResponse.status).toBe(200);
+		const cartWithLineItem = addLineItemResponse.body as Cart;
+		const lineItem = cartWithLineItem.lineItems[0];
+		assert(lineItem, "lineItem not created");
+
+		const externalPrice: CentPrecisionMoney = {
+			type: "centPrecision",
+			currencyCode: "EUR",
+			centAmount: 2500,
+			fractionDigits: 2,
+		};
+
+		const response = await supertest(ctMock.app)
+			.post(`/dummy/carts/${cartWithLineItem.id}`)
+			.send({
+				version: cartWithLineItem.version,
+				actions: [
+					{
+						action: "setLineItemPrice",
+						lineItemKey: lineItem.key,
+						externalPrice,
+					},
+				],
+			});
+
+		expect(response.status).toBe(200);
+		expect(response.body.version).toBe(cartWithLineItem.version + 1);
+		expect(response.body.lineItems).toHaveLength(1);
+
+		const updatedLineItem = response.body.lineItems[0];
+		expect(updatedLineItem.priceMode).toBe("ExternalPrice");
+		expect(updatedLineItem.price.value.centAmount).toBe(
+			externalPrice.centAmount,
+		);
+		expect(updatedLineItem.price.value.currencyCode).toBe(
+			externalPrice.currencyCode,
+		);
+		expect(updatedLineItem.totalPrice.centAmount).toBe(
+			externalPrice.centAmount * updatedLineItem.quantity,
+		);
+		expect(response.body.totalPrice.centAmount).toBe(
+			externalPrice.centAmount * updatedLineItem.quantity,
+		);
+	});
+
+	test("setLineItemPrice fails when the money uses another currency", async () => {
+		const product = await supertest(ctMock.app)
+			.post("/dummy/products")
+			.send(productDraft)
+			.then((x) => x.body);
+
+		assert(product, "product not created");
+
+		const baseCartResponse = await supertest(ctMock.app)
+			.post("/dummy/carts")
+			.send({ currency: "EUR" });
+		expect(baseCartResponse.status).toBe(201);
+		const baseCart = baseCartResponse.body as Cart;
+
+		const addLineItemResponse = await supertest(ctMock.app)
+			.post(`/dummy/carts/${baseCart.id}`)
+			.send({
+				version: baseCart.version,
+				actions: [
+					{
+						action: "addLineItem",
+						sku: product.masterData.current.masterVariant.sku,
+						quantity: 1,
+					},
+				],
+			});
+		expect(addLineItemResponse.status).toBe(200);
+		const cartWithLineItem = addLineItemResponse.body as Cart;
+		const lineItem = cartWithLineItem.lineItems[0];
+		assert(lineItem, "lineItem not created");
+
+		const response = await supertest(ctMock.app)
+			.post(`/dummy/carts/${cartWithLineItem.id}`)
+			.send({
+				version: cartWithLineItem.version,
+				actions: [
+					{
+						action: "setLineItemPrice",
+						lineItemId: lineItem.id,
+						externalPrice: {
+							type: "centPrecision",
+							currencyCode: "USD",
+							centAmount: 5000,
+							fractionDigits: 2,
+						},
+					},
+				],
+			});
+
+		expect(response.status).toBe(400);
+		expect(response.body.message).toContain("Currency mismatch");
+	});
+
+	test("setLineItemPrice removes external price when no value is provided", async () => {
+		const product = await supertest(ctMock.app)
+			.post("/dummy/products")
+			.send(productDraft)
+			.then((x) => x.body);
+
+		assert(product, "product not created");
+
+		const baseCartResponse = await supertest(ctMock.app)
+			.post("/dummy/carts")
+			.send({ currency: "EUR" });
+		expect(baseCartResponse.status).toBe(201);
+		const baseCart = baseCartResponse.body as Cart;
+
+		const addLineItemResponse = await supertest(ctMock.app)
+			.post(`/dummy/carts/${baseCart.id}`)
+			.send({
+				version: baseCart.version,
+				actions: [
+					{
+						action: "addLineItem",
+						sku: product.masterData.current.masterVariant.sku,
+						quantity: 1,
+					},
+				],
+			});
+		expect(addLineItemResponse.status).toBe(200);
+		const cartWithLineItem = addLineItemResponse.body as Cart;
+		const lineItem = cartWithLineItem.lineItems[0];
+		assert(lineItem, "lineItem not created");
+
+		const externalPrice: CentPrecisionMoney = {
+			type: "centPrecision",
+			currencyCode: "EUR",
+			centAmount: 1000,
+			fractionDigits: 2,
+		};
+
+		const setExternalPriceResponse = await supertest(ctMock.app)
+			.post(`/dummy/carts/${cartWithLineItem.id}`)
+			.send({
+				version: cartWithLineItem.version,
+				actions: [
+					{
+						action: "setLineItemPrice",
+						lineItemId: lineItem.id,
+						externalPrice,
+					},
+				],
+			});
+		expect(setExternalPriceResponse.status).toBe(200);
+		const cartWithExternalPrice = setExternalPriceResponse.body as Cart;
+		expect(cartWithExternalPrice.lineItems[0].priceMode).toBe("ExternalPrice");
+
+		const resetResponse = await supertest(ctMock.app)
+			.post(`/dummy/carts/${cartWithExternalPrice.id}`)
+			.send({
+				version: cartWithExternalPrice.version,
+				actions: [
+					{
+						action: "setLineItemPrice",
+						lineItemId: lineItem.id,
+					},
+				],
+			});
+
+		expect(resetResponse.status).toBe(200);
+		expect(resetResponse.body.version).toBe(cartWithExternalPrice.version + 1);
+		expect(resetResponse.body.lineItems).toHaveLength(1);
+
+		const revertedLineItem = resetResponse.body.lineItems[0];
+		const expectedCentAmount =
+			product.masterData.current.masterVariant.prices?.[0].value.centAmount;
+		if (typeof expectedCentAmount !== "number") {
+			throw new Error("product price not found");
+		}
+		expect(revertedLineItem.priceMode).toBe("Platform");
+		expect(revertedLineItem.price.value.centAmount).toBe(expectedCentAmount);
+		expect(revertedLineItem.totalPrice.centAmount).toBe(
+			expectedCentAmount * revertedLineItem.quantity,
+		);
+		expect(resetResponse.body.totalPrice.centAmount).toBe(
+			expectedCentAmount * revertedLineItem.quantity,
+		);
+	});
+
 	test("setLineItemCustomField", async () => {
 		const product = await supertest(ctMock.app)
 			.post("/dummy/products")

package/src/shipping.ts

@@ -1,12 +1,23 @@
 import type {
 	Cart,
 	CartValueTier,
+	CentPrecisionMoney,
 	InvalidOperationError,
+	MissingTaxRateForCountryError,
+	Order,
+	ShippingInfo,
+	ShippingMethod,
+	ShippingMethodDoesNotMatchCartError,
 	ShippingRate,
 	ShippingRatePriceTier,
+	TaxPortion,
+	TaxRate,
+	TaxedItemPrice,
 } from "@commercetools/platform-sdk";
+import { Decimal } from "decimal.js";
 import { CommercetoolsError } from "./exceptions";
 import type { GetParams, RepositoryContext } from "./repositories/abstract";
+import { createCentPrecisionMoney, roundDecimal } from "./repositories/helpers";
 import type { AbstractStorage } from "./storage/abstract";
 
 export const markMatchingShippingRate = (
@@ -145,3 +156,149 @@ export const getShippingMethodsMatchingCart = (
 		results: results,
 	};
 };
+
+/**
+ * Interface for cart-like objects that can be used for shipping calculations
+ */
+interface ShippingCalculationSource {
+	id: string;
+	totalPrice: CentPrecisionMoney;
+	shippingAddress?: {
+		country: string;
+		[key: string]: any;
+	};
+	taxRoundingMode?: string;
+}
+
+/**
+ * Creates shipping info from a shipping method, handling all tax calculations and pricing logic.
+ */
+export const createShippingInfoFromMethod = (
+	context: RepositoryContext,
+	storage: AbstractStorage,
+	resource: ShippingCalculationSource,
+	method: ShippingMethod,
+): Omit<ShippingInfo, "deliveries"> => {
+	const country = resource.shippingAddress!.country;
+
+	// There should only be one zone rate matching the address, since
+	// Locations cannot be assigned to more than one zone.
+	// See https://docs.commercetools.com/api/projects/zones#location
+	const zoneRate = method.zoneRates.find((rate) =>
+		rate.zone.obj?.locations.some((loc) => loc.country === country),
+	);
+
+	if (!zoneRate) {
+		// This shouldn't happen because getShippingMethodsMatchingCart already
+		// filtered out shipping methods without any zones matching the address
+		throw new Error("Zone rate not found");
+	}
+
+	// Shipping rates are defined by currency, and getShippingMethodsMatchingCart
+	// also matches on currency, so there should only be one in the array.
+	// See https://docs.commercetools.com/api/projects/shippingMethods#zonerate
+	const shippingRate = zoneRate.shippingRates[0];
+	if (!shippingRate) {
+		// This shouldn't happen because getShippingMethodsMatchingCart already
+		// filtered out shipping methods without any matching rates
+		throw new Error("Shipping rate not found");
+	}
+
+	const taxCategory = storage.getByResourceIdentifier<"tax-category">(
+		context.projectKey,
+		method.taxCategory,
+	);
+
+	// TODO: match state in addition to country
+	const taxRate = taxCategory.rates.find((rate) => rate.country === country);
+
+	if (!taxRate) {
+		throw new CommercetoolsError<MissingTaxRateForCountryError>({
+			code: "MissingTaxRateForCountry",
+			message: `Tax category '${taxCategory.id}' is missing a tax rate for country '${country}'.`,
+			taxCategoryId: taxCategory.id,
+		});
+	}
+
+	const shippingRateTier = shippingRate.tiers.find((tier) => tier.isMatching);
+	if (shippingRateTier && shippingRateTier.type !== "CartValue") {
+		throw new Error("Non-CartValue shipping rate tier is not supported");
+	}
+
+	let shippingPrice = shippingRateTier
+		? createCentPrecisionMoney(shippingRateTier.price)
+		: shippingRate.price;
+
+	// Handle freeAbove: if total is above the freeAbove threshold, shipping is free
+	if (
+		shippingRate.freeAbove &&
+		shippingRate.freeAbove.currencyCode === resource.totalPrice.currencyCode &&
+		resource.totalPrice.centAmount >= shippingRate.freeAbove.centAmount
+	) {
+		shippingPrice = {
+			...shippingPrice,
+			centAmount: 0,
+		};
+	}
+
+	// Calculate tax amounts
+	const totalGross: CentPrecisionMoney = taxRate.includedInPrice
+		? shippingPrice
+		: {
+				...shippingPrice,
+				centAmount: roundDecimal(
+					new Decimal(shippingPrice.centAmount).mul(1 + taxRate.amount),
+					resource.taxRoundingMode || "HalfEven",
+				).toNumber(),
+			};
+
+	const totalNet: CentPrecisionMoney = taxRate.includedInPrice
+		? {
+				...shippingPrice,
+				centAmount: roundDecimal(
+					new Decimal(shippingPrice.centAmount).div(1 + taxRate.amount),
+					resource.taxRoundingMode || "HalfEven",
+				).toNumber(),
+			}
+		: shippingPrice;
+
+	const taxPortions: TaxPortion[] = [
+		{
+			name: taxRate.name,
+			rate: taxRate.amount,
+			amount: {
+				...shippingPrice,
+				centAmount: totalGross.centAmount - totalNet.centAmount,
+			},
+		},
+	];
+
+	const totalTax: CentPrecisionMoney = {
+		...shippingPrice,
+		centAmount: taxPortions.reduce(
+			(acc, portion) => acc + portion.amount.centAmount,
+			0,
+		),
+	};
+
+	const taxedPrice: TaxedItemPrice = {
+		totalNet,
+		totalGross,
+		taxPortions,
+		totalTax,
+	};
+
+	return {
+		shippingMethod: {
+			typeId: "shipping-method" as const,
+			id: method.id,
+		},
+		shippingMethodName: method.name,
+		price: shippingPrice,
+		shippingRate,
+		taxedPrice,
+		taxRate,
+		taxCategory: method.taxCategory,
+		shippingMethodState: "MatchesCart",
+	};
+};