@labdigital/commercetools-mock 2.8.0 → 2.9.0

package/src/services/shipping-method.test.ts

@@ -1,24 +1,48 @@
 import type {
+	Cart,
+	CartDraft,
 	ShippingMethodDraft,
 	TaxCategoryDraft,
+	ZoneDraft,
 } from '@commercetools/platform-sdk'
 import supertest from 'supertest'
 import { afterEach, beforeEach, describe, expect, test } from 'vitest'
 import { CommercetoolsMock } from '../index.js'
+import { isType } from '../types.js'
 
 const ctMock = new CommercetoolsMock()
 
 describe('Shipping method', () => {
 	beforeEach(async () => {
-		const draft: TaxCategoryDraft = {
-			name: 'foo',
-			key: 'standard',
-			rates: [],
-		}
-		const createResponse = await supertest(ctMock.app)
+		await supertest(ctMock.app)
 			.post('/dummy/tax-categories')
-			.send(draft)
-		expect(createResponse.status).toEqual(201)
+			.send(
+				isType<TaxCategoryDraft>({
+					name: 'foo',
+					key: 'standard',
+					rates: [],
+				})
+			)
+			.then((res) => {
+				expect(res.status).toEqual(201)
+			})
+
+		await supertest(ctMock.app)
+			.post('/dummy/zones')
+			.send(
+				isType<ZoneDraft>({
+					name: 'The Netherlands',
+					key: 'NL',
+					locations: [
+						{
+							country: 'NL',
+						},
+					],
+				})
+			)
+			.then((res) => {
+				expect(res.status).toEqual(201)
+			})
 	})
 
 	afterEach(async () => {
@@ -75,28 +99,103 @@ describe('Shipping method', () => {
 	})
 
 	test('Get shipping methods matching cart', async () => {
-		const draft: ShippingMethodDraft = {
-			name: 'foo',
-			taxCategory: { typeId: 'tax-category', key: 'standard' },
-			isDefault: true,
-			zoneRates: [],
-		}
-		const createResponse = await supertest(ctMock.app)
+		const cart = await supertest(ctMock.app)
+			.post('/dummy/carts')
+			.send(
+				isType<CartDraft>({
+					currency: 'EUR',
+					shippingAddress: {
+						country: 'NL',
+					},
+				})
+			)
+			.then((res) => res.body as Cart)
+
+		await supertest(ctMock.app)
 			.post('/dummy/shipping-methods')
-			.send(draft)
+			.send(
+				isType<ShippingMethodDraft>({
+					name: 'NL',
+					taxCategory: { typeId: 'tax-category', key: 'standard' },
+					isDefault: true,
+					zoneRates: [
+						{
+							zone: {
+								typeId: 'zone',
+								key: 'NL',
+							},
+							shippingRates: [
+								{
+									price: {
+										currencyCode: 'EUR',
+										centAmount: 495,
+									},
+								},
+							],
+						},
+					],
+				})
+			)
+			.then((res) => {
+				expect(res.status).toEqual(201)
+			})
 
-		expect(createResponse.status).toBe(201)
+		await supertest(ctMock.app)
+			.post('/dummy/shipping-methods')
+			.send(
+				isType<ShippingMethodDraft>({
+					name: 'NL/GBP',
+					taxCategory: { typeId: 'tax-category', key: 'standard' },
+					isDefault: true,
+					zoneRates: [
+						{
+							zone: {
+								typeId: 'zone',
+								key: 'NL',
+							},
+							shippingRates: [
+								{
+									price: {
+										currencyCode: 'GBP',
+										centAmount: 495,
+									},
+								},
+							],
+						},
+					],
+				})
+			)
+			.then((res) => {
+				expect(res.status).toEqual(201)
+			})
 
 		const response = await supertest(ctMock.app).get(
-			`/dummy/shipping-methods/matching-cart?cartId=fake-cart-id`
+			`/dummy/shipping-methods/matching-cart?cartId=${cart.id}`
 		)
 
-		expect(response.status).toBe(200)
-		expect(response.body).toEqual({
+		expect(response.status, JSON.stringify(response.body)).toBe(200)
+		expect(response.body).toMatchObject({
 			count: 1,
 			limit: 20,
 			offset: 0,
-			results: [createResponse.body],
+			results: [
+				{
+					name: 'NL',
+					zoneRates: [
+						{
+							shippingRates: [
+								{
+									isMatching: true,
+									price: {
+										currencyCode: 'EUR',
+										centAmount: 495,
+									},
+								},
+							],
+						},
+					],
+				},
+			],
 			total: 1,
 		})
 	})

package/src/services/shipping-method.ts

@@ -1,6 +1,8 @@
-import { Router } from 'express'
+import { Request, Response, Router } from 'express'
 import { ShippingMethodRepository } from '../repositories/shipping-method.js'
 import AbstractService from './abstract.js'
+import { getRepositoryContext } from '../repositories/helpers.js'
+import { queryParamsValue } from '../helpers.js'
 
 export class ShippingMethodService extends AbstractService {
 	public repository: ShippingMethodRepository
@@ -16,6 +18,21 @@ export class ShippingMethodService extends AbstractService {
 	}
 
 	extraRoutes(parent: Router) {
-		parent.get('/matching-cart', this.get.bind(this))
+		parent.get('/matching-cart', this.matchingCart.bind(this))
+	}
+
+	matchingCart(request: Request, response: Response) {
+		const cartId = queryParamsValue(request.query.cartId)
+		if (!cartId) {
+			return response.status(400).send()
+		}
+		const result = this.repository.matchingCart(
+			getRepositoryContext(request),
+			cartId,
+			{
+				expand: this._parseParam(request.query.expand),
+			}
+		)
+		return response.status(200).send(result)
 	}
 }

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,