@labdigital/commercetools-mock 2.7.0 → 2.9.0

package/src/shippingCalculator.test.ts

@@ -0,0 +1,280 @@
+import {
+	Cart,
+	ShippingRate,
+	ShippingRatePriceTier,
+} from '@commercetools/platform-sdk'
+import { describe, expect, it } from 'vitest'
+import {
+	markMatchingShippingRate,
+	markMatchingShippingRatePriceTiers,
+} from './shippingCalculator'
+
+// describe('markMatchingShippingMethods', () => {
+// 	const zones: Record<string, Zone> = {
+// 		NL: {
+// 			id: '45b39469-4f3d-4d03-9e24-ed6bd5c038d9',
+// 			createdAt: '2021-08-05T09:00:00.000Z',
+// 			lastModifiedAt: '2021-08-05T09:00:00.000Z',
+// 			version: 1,
+// 			name: 'NL',
+// 			description: '',
+// 			locations: [
+// 				{
+// 					country: 'NL',
+// 				},
+// 			],
+// 		},
+// 		DE: {
+// 			id: '45b39469-4f3d-4d03-9e24-ed6bd5c038d9',
+// 			createdAt: '2021-08-05T09:00:00.000Z',
+// 			lastModifiedAt: '2021-08-05T09:00:00.000Z',
+// 			version: 1,
+// 			name: 'DE',
+// 			description: '',
+// 			locations: [
+// 				{
+// 					country: 'DE',
+// 				},
+// 			],
+// 		},
+// 	}
+
+// 	const shippingMethods: Record<string, Partial<ShippingMethod>> = {
+// 		default: {
+// 			id: '1c39b73f-186c-4711-8fd9-de60ec561ac0',
+// 			key: 'default',
+// 			zoneRates: [
+// 				{
+// 					zone: {
+// 						typeId: 'zone',
+// 						id: '45b39469-4f3d-4d03-9e24-ed6bd5c038d9',
+// 						obj: zones['NL'],
+// 					},
+// 					shippingRates: [
+// 						{
+// 							price: {
+// 								type: 'centPrecision',
+// 								currencyCode: 'EUR',
+// 								centAmount: 495,
+// 								fractionDigits: 2,
+// 							},
+// 							freeAbove: {
+// 								type: 'centPrecision',
+// 								currencyCode: 'USD',
+// 								centAmount: 5000,
+// 								fractionDigits: 2,
+// 							},
+// 							tiers: [],
+// 						},
+// 					],
+// 				},
+// 			],
+// 			isDefault: true,
+// 		},
+// 		tiered: {
+// 			id: '2c39b73f-186c-4711-8fd9-de60ec561ac0',
+// 			key: 'tiered',
+// 			description: 'More expensive optional one',
+// 			zoneRates: [
+// 				{
+// 					zone: {
+// 						typeId: 'zone',
+// 						id: '45b39469-4f3d-4d03-9e24-ed6bd5c038d9',
+// 						obj: zones['NL'],
+// 					},
+// 					shippingRates: [
+// 						{
+// 							price: {
+// 								type: 'centPrecision',
+// 								currencyCode: 'EUR',
+// 								centAmount: 495,
+// 								fractionDigits: 2,
+// 							},
+// 							freeAbove: {
+// 								type: 'centPrecision',
+// 								currencyCode: 'USD',
+// 								centAmount: 5000,
+// 								fractionDigits: 2,
+// 							},
+// 							tiers: [],
+// 						},
+// 					],
+// 				},
+// 			],
+// 			isDefault: false,
+// 		},
+// 		german: {
+// 			id: '8c39b73f-186c-4711-8fd9-de60ec561ac0',
+// 			key: 'tiered',
+// 			description: 'More expensive optional one',
+// 			zoneRates: [
+// 				{
+// 					zone: {
+// 						typeId: 'zone',
+// 						id: '45b39469-4f3d-4d03-9e24-ed6bd5c038d9',
+// 						obj: zones['DE'],
+// 					},
+// 					shippingRates: [
+// 						{
+// 							price: {
+// 								type: 'centPrecision',
+// 								currencyCode: 'EUR',
+// 								centAmount: 495,
+// 								fractionDigits: 2,
+// 							},
+// 							freeAbove: {
+// 								type: 'centPrecision',
+// 								currencyCode: 'USD',
+// 								centAmount: 5000,
+// 								fractionDigits: 2,
+// 							},
+// 							tiers: [],
+// 						},
+// 					],
+// 				},
+// 			],
+// 			isDefault: false,
+// 		},
+// 	}
+
+// 	it('should mark the default shipping method', () => {
+// 		const cart: Partial<Cart> = {
+// 			id: '1',
+// 			version: 1,
+// 			totalPrice: {
+// 				currencyCode: 'EUR',
+// 				centAmount: 1000,
+// 				fractionDigits: 2,
+// 				type: 'centPrecision',
+// 			},
+// 			shippingAddress: {
+// 				country: 'NL',
+// 			},
+// 			lineItems: [],
+// 			customLineItems: [],
+// 		}
+
+// 		const data = markMatchingShippingMethods(
+// 			cart as Cart,
+// 			Object.values(shippingMethods) as ShippingMethod[]
+// 		)
+// 	})
+// })
+
+describe('markMatchingShippingRate', () => {
+	const rate: ShippingRate = {
+		price: {
+			type: 'centPrecision',
+			currencyCode: 'EUR',
+			centAmount: 495,
+			fractionDigits: 2,
+		},
+		freeAbove: {
+			type: 'centPrecision',
+			currencyCode: 'USD',
+			centAmount: 5000,
+			fractionDigits: 2,
+		},
+		tiers: [],
+	}
+
+	it('should mark the shipping rate as matching', () => {
+		const cart: Partial<Cart> = {
+			totalPrice: {
+				currencyCode: 'EUR',
+				centAmount: 1000,
+				fractionDigits: 2,
+				type: 'centPrecision',
+			},
+		}
+
+		const result = markMatchingShippingRate(cart as Cart, rate)
+		expect(result).toMatchObject({
+			...rate,
+			isMatching: true,
+		})
+	})
+
+	it('should mark the shipping rate as not matching', () => {
+		const cart: Partial<Cart> = {
+			totalPrice: {
+				currencyCode: 'USD',
+				centAmount: 1000,
+				fractionDigits: 2,
+				type: 'centPrecision',
+			},
+		}
+
+		const result = markMatchingShippingRate(cart as Cart, rate)
+		expect(result).toMatchObject({
+			...rate,
+			isMatching: false,
+		})
+	})
+})
+
+describe('markMatchingShippingRatePriceTiers', () => {
+	it('should handle CartValue types', () => {
+		const tiers: ShippingRatePriceTier[] = [
+			// Above 100 euro shipping is 4 euro
+			{
+				type: 'CartValue',
+				minimumCentAmount: 10000,
+				price: {
+					type: 'centPrecision',
+					currencyCode: 'EUR',
+					centAmount: 400,
+					fractionDigits: 2,
+				},
+			},
+			// Above 200 euro shipping is 3 euro
+			{
+				type: 'CartValue',
+				minimumCentAmount: 20000,
+				price: {
+					type: 'centPrecision',
+					currencyCode: 'EUR',
+					centAmount: 300,
+					fractionDigits: 2,
+				},
+			},
+			// Above 50 euro shipping is 5 euro
+			{
+				type: 'CartValue',
+				minimumCentAmount: 500,
+				price: {
+					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',
+				centAmount: 9000,
+				fractionDigits: 2,
+				type: 'centPrecision',
+			},
+		}
+
+		const result = markMatchingShippingRatePriceTiers(cart as Cart, tiers)
+		expect(result).toMatchObject([
+			{
+				minimumCentAmount: 10000,
+				isMatching: false,
+			},
+			{
+				minimumCentAmount: 20000,
+				isMatching: false,
+			},
+			{
+				minimumCentAmount: 500,
+				isMatching: true,
+			},
+		])
+	})
+})

package/src/shippingCalculator.ts

@@ -0,0 +1,74 @@
+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])
+}

package/src/storage/abstract.ts

@@ -68,7 +68,7 @@ export abstract class AbstractStorage {
 	abstract getByResourceIdentifier<RT extends ResourceType>(
 		projectKey: string,
 		identifier: ResourceIdentifier
-	): ResourceMap[RT] | null
+	): ResourceMap[RT]
 
 	abstract expand<T>(
 		projectKey: string,

package/src/storage/in-memory.ts

@@ -1,39 +1,41 @@
-import type {
-	AssociateRole,
-	AttributeGroup,
-	BusinessUnit,
-	Cart,
-	CartDiscount,
-	Category,
-	Channel,
-	Customer,
-	CustomerGroup,
-	CustomObject,
-	DiscountCode,
-	Extension,
-	InvalidInputError,
-	InventoryEntry,
-	Order,
-	PagedQueryResponse,
-	Payment,
-	Product,
-	ProductDiscount,
-	ProductProjection,
-	ProductType,
-	Project,
-	Quote,
-	QuoteRequest,
-	Reference,
-	ResourceIdentifier,
-	ShippingMethod,
-	ShoppingList,
-	StagedQuote,
-	State,
-	Store,
-	Subscription,
-	TaxCategory,
-	Type,
-	Zone,
+import {
+	ReferencedResourceNotFoundError,
+	type AssociateRole,
+	type AttributeGroup,
+	type BusinessUnit,
+	type Cart,
+	type CartDiscount,
+	type Category,
+	type Channel,
+	type Customer,
+	type CustomerGroup,
+	type CustomObject,
+	type DiscountCode,
+	type Extension,
+	type InvalidInputError,
+	type InventoryEntry,
+	type Order,
+	type PagedQueryResponse,
+	type Payment,
+	type Product,
+	type ProductDiscount,
+	type ProductProjection,
+	type ProductType,
+	type Project,
+	type Quote,
+	type QuoteRequest,
+	type Reference,
+	type ResourceIdentifier,
+	type ShippingMethod,
+	type ShoppingList,
+	type StagedQuote,
+	type State,
+	type Store,
+	type Subscription,
+	type TaxCategory,
+	type Type,
+	type Zone,
+	InvalidJsonInputError,
 } from '@commercetools/platform-sdk'
 import assert from 'assert'
 import { CommercetoolsError } from '../exceptions.js'
@@ -204,9 +206,17 @@ export class InMemoryStorage extends AbstractStorage {
 
 		// Apply predicates
 		if (params.where) {
+			// Get all key-value pairs starting with 'var.' to pass as variables, removing
+			// the 'var.' prefix.
+			const vars = Object.fromEntries(
+				Object.entries(params)
+					.filter(([key]) => key.startsWith('var.'))
+					.map(([key, value]) => [key.slice(4), value])
+			)
+
 			try {
 				const filterFunc = parseQueryExpression(params.where)
-				resources = resources.filter((resource) => filterFunc(resource, {}))
+				resources = resources.filter((resource) => filterFunc(resource, vars))
 			} catch (err) {
 				throw new CommercetoolsError<InvalidInputError>(
 					{
@@ -292,38 +302,51 @@ export class InMemoryStorage extends AbstractStorage {
 	getByResourceIdentifier<RT extends ResourceType>(
 		projectKey: string,
 		identifier: ResourceIdentifier
-	): ResourceMap[RT] | null {
+	): ResourceMap[RT] {
 		if (identifier.id) {
 			const resource = this.get(projectKey, identifier.typeId, identifier.id)
 			if (resource) {
 				return resource as ResourceMap[RT]
 			}
-			console.error(
-				`No resource found with typeId=${identifier.typeId}, id=${identifier.id}`
-			)
-			return null
+
+			throw new CommercetoolsError<ReferencedResourceNotFoundError>({
+				code: 'ReferencedResourceNotFound',
+				message:
+					`The referenced object of type '${identifier.typeId}' with id ` +
+					`'${identifier.id}' was not found. It either doesn't exist, or it ` +
+					`can't be accessed from this endpoint (e.g., if the endpoint ` +
+					`filters by store or customer account).`,
+				typeId: identifier.typeId,
+				id: identifier.id,
+			})
 		}
 
 		if (identifier.key) {
-			const store = this.forProjectKey(projectKey)[identifier.typeId]
-
-			if (store) {
-				// TODO: BaseResource has no key attribute, but the subclasses should
-				// have them all.
-				const resource = Array.from(store.values()).find(
-					// @ts-ignore
-					(r) => r.key === identifier.key
-				)
-				if (resource) {
-					return resource as ResourceMap[RT]
-				}
-			} else {
-				throw new Error(
-					`No storage found for resource type: ${identifier.typeId}`
-				)
+			const resource = this.getByKey(
+				projectKey,
+				identifier.typeId,
+				identifier.key
+			)
+			if (resource) {
+				return resource as ResourceMap[RT]
 			}
+
+			throw new CommercetoolsError<ReferencedResourceNotFoundError>({
+				code: 'ReferencedResourceNotFound',
+				message:
+					`The referenced object of type '${identifier.typeId}' with key ` +
+					`'${identifier.key}' was not found. It either doesn't exist, or it ` +
+					`can't be accessed from this endpoint (e.g., if the endpoint ` +
+					`filters by store or customer account).`,
+				typeId: identifier.typeId,
+				key: identifier.key,
+			})
 		}
-		return null
+		throw new CommercetoolsError<InvalidJsonInputError>({
+			code: 'InvalidJsonInput',
+			message: 'Request body does not contain valid JSON.',
+			detailedErrorMessage: "ResourceIdentifier requires an 'id' xor a 'key'",
+		})
 	}
 
 	addProject = (projectKey: string): Project => {
@@ -415,12 +438,15 @@ export class InMemoryStorage extends AbstractStorage {
 			reference.typeId !== undefined &&
 			(reference.id !== undefined || reference.key !== undefined)
 		) {
-			// @ts-ignore
-			reference.obj = this.getByResourceIdentifier(projectKey, {
-				typeId: reference.typeId,
-				id: reference.id,
-				key: reference.key,
-			} as ResourceIdentifier)
+			// First check if the object is already resolved. This is the case when
+			// the complete resource is pushed via the .add() method.
+			if (!reference.obj) {
+				reference.obj = this.getByResourceIdentifier(projectKey, {
+					typeId: reference.typeId,
+					id: reference.id,
+					key: reference.key,
+				} as ResourceIdentifier)
+			}
 			if (expand) {
 				this._resolveResource(projectKey, reference.obj, expand)
 			}

package/src/types.ts

@@ -2,6 +2,8 @@ import type * as ctp from '@commercetools/platform-sdk'
 import { RepositoryMap } from './repositories/index.js'
 import AbstractService from './services/abstract.js'
 
+export const isType = <T>(x: T) => x
+
 export type Writable<T> = { -readonly [P in keyof T]: Writable<T[P]> }
 export type ShallowWritable<T> = { -readonly [P in keyof T]: T[P] }