@labdigital/commercetools-mock 2.7.0 → 2.9.0

package/src/repositories/product.ts

@@ -36,6 +36,7 @@ import type {
 	ProductAddToCategoryAction,
 	ProductRemoveFromCategoryAction,
 	ProductTransitionStateAction,
+	ChannelReference,
 } from '@commercetools/platform-sdk'
 import { v4 as uuidv4 } from 'uuid'
 import type { Writable } from '../types.js'
@@ -126,10 +127,10 @@ export class ProductRepository extends AbstractResourceRepository<'product'> {
 			slug: draft.slug,
 			description: draft.description,
 			categories: categoryReferences,
-			masterVariant: variantFromDraft(1, draft.masterVariant),
+			masterVariant: this.variantFromDraft(context, 1, draft.masterVariant),
 			variants:
 				draft.variants?.map((variant, index) =>
-					variantFromDraft(index + 2, variant)
+					this.variantFromDraft(context, index + 2, variant)
 				) ?? [],
 			metaTitle: draft.metaTitle,
 			metaDescription: draft.metaDescription,
@@ -156,6 +157,38 @@ export class ProductRepository extends AbstractResourceRepository<'product'> {
 		return resource
 	}
 
+	private variantFromDraft(
+		context: RepositoryContext,
+		variantId: number,
+		variant: ProductVariantDraft
+	): ProductVariant {
+		return {
+			id: variantId,
+			sku: variant?.sku,
+			key: variant?.key,
+			attributes: variant?.attributes ?? [],
+			prices: variant?.prices?.map((p) => this.priceFromDraft(context, p)),
+			assets: [],
+			images: [],
+		}
+	}
+
+	private priceFromDraft(context: RepositoryContext, draft: PriceDraft): Price {
+		return {
+			id: uuidv4(),
+			key: draft.key,
+			country: draft.country,
+			value: createTypedMoney(draft.value),
+			channel: draft.channel
+				? getReferenceFromResourceIdentifier<ChannelReference>(
+						draft.channel,
+						context.projectKey,
+						this._storage
+				  )
+				: undefined,
+		}
+	}
+
 	actions: Partial<
 		Record<
 			ProductUpdateAction['action'],
@@ -528,7 +561,7 @@ export class ProductRepository extends AbstractResourceRepository<'product'> {
 			}
 
 			// Pre-creating the price object ensures consistency between staged and current versions
-			const priceToAdd = priceFromDraft(price)
+			const priceToAdd = this.priceFromDraft(context, price)
 
 			// If true, only the staged Attribute is set. If false, both current and
 			// staged Attribute is set.  Default is true
@@ -754,7 +787,7 @@ export class ProductRepository extends AbstractResourceRepository<'product'> {
 				(max, element) => (element.id > max ? element.id : max),
 				0
 			)
-			const variant = variantFromDraft(maxId + 1, variantDraft)
+			const variant = this.variantFromDraft(context, maxId + 1, variantDraft)
 			dataStaged.variants.push(variant)
 
 			const onlyStaged = staged !== undefined ? staged : true
@@ -1071,23 +1104,3 @@ const getVariant = (
 				: -1,
 	}
 }
-
-const variantFromDraft = (
-	variantId: number,
-	variant: ProductVariantDraft
-): ProductVariant => ({
-	id: variantId,
-	sku: variant?.sku,
-	key: variant?.key,
-	attributes: variant?.attributes ?? [],
-	prices: variant?.prices?.map(priceFromDraft),
-	assets: [],
-	images: [],
-})
-
-const priceFromDraft = (draft: PriceDraft): Price => ({
-	id: uuidv4(),
-	key: draft.key,
-	country: draft.country,
-	value: createTypedMoney(draft.value),
-})

package/src/repositories/review.ts

@@ -1,11 +1,18 @@
-import type {
-	Review,
-	ReviewDraft,
-	ReviewUpdateAction,
+import {
+	ChannelReference,
+	ProductReference,
+	type Review,
+	type ReviewDraft,
+	type ReviewUpdateAction,
+	type StateReference,
 } from '@commercetools/platform-sdk'
 import { getBaseResourceProperties } from '../helpers.js'
 import type { Writable } from '../types.js'
 import { AbstractResourceRepository, RepositoryContext } from './abstract.js'
+import {
+	createCustomFields,
+	getReferenceFromResourceIdentifier,
+} from './helpers.js'
 
 export class ReviewRepository extends AbstractResourceRepository<'review'> {
 	getTypeId() {
@@ -13,9 +20,34 @@ export class ReviewRepository extends AbstractResourceRepository<'review'> {
 	}
 
 	create(context: RepositoryContext, draft: ReviewDraft): Review {
+		if (!draft.target) throw new Error('Missing target')
 		const resource: Review = {
 			...getBaseResourceProperties(),
+
+			locale: draft.locale,
+			authorName: draft.authorName,
+			title: draft.title,
+			text: draft.text,
+			rating: draft.rating,
+			uniquenessValue: draft.uniquenessValue,
+			state: draft.state
+				? getReferenceFromResourceIdentifier<StateReference>(
+						draft.state,
+						context.projectKey,
+						this._storage
+				  )
+				: undefined,
+			target: draft.target
+				? getReferenceFromResourceIdentifier<
+						ProductReference | ChannelReference
+				  >(draft.target, context.projectKey, this._storage)
+				: undefined,
 			includedInStatistics: false,
+			custom: createCustomFields(
+				draft.custom,
+				context.projectKey,
+				this._storage
+			),
 		}
 		this.saveNew(context, resource)
 		return resource

package/src/repositories/shipping-method.ts

@@ -1,34 +1,41 @@
-import type {
-	ShippingMethod,
-	ShippingMethodAddShippingRateAction,
-	ShippingMethodAddZoneAction,
-	ShippingMethodChangeIsDefaultAction,
-	ShippingMethodChangeNameAction,
-	ShippingMethodDraft,
-	ShippingMethodRemoveZoneAction,
-	ShippingMethodSetCustomFieldAction,
-	ShippingMethodSetCustomTypeAction,
-	ShippingMethodSetDescriptionAction,
-	ShippingMethodSetKeyAction,
-	ShippingMethodSetLocalizedDescriptionAction,
-	ShippingMethodSetLocalizedNameAction,
-	ShippingMethodSetPredicateAction,
-	ShippingMethodUpdateAction,
-	ShippingRate,
-	ShippingRateDraft,
-	ZoneRate,
-	ZoneRateDraft,
-	ZoneReference,
+import {
+	InvalidOperationError,
+	type ShippingMethod,
+	type ShippingMethodAddShippingRateAction,
+	type ShippingMethodAddZoneAction,
+	type ShippingMethodChangeIsDefaultAction,
+	type ShippingMethodChangeNameAction,
+	type ShippingMethodDraft,
+	type ShippingMethodRemoveZoneAction,
+	type ShippingMethodSetCustomFieldAction,
+	type ShippingMethodSetCustomTypeAction,
+	type ShippingMethodSetDescriptionAction,
+	type ShippingMethodSetKeyAction,
+	type ShippingMethodSetLocalizedDescriptionAction,
+	type ShippingMethodSetLocalizedNameAction,
+	type ShippingMethodSetPredicateAction,
+	type ShippingMethodUpdateAction,
+	type ShippingRate,
+	type ShippingRateDraft,
+	type ZoneRate,
+	type ZoneRateDraft,
+	type ZoneReference,
 } from '@commercetools/platform-sdk'
 import deepEqual from 'deep-equal'
 import { getBaseResourceProperties } from '../helpers.js'
 import type { Writable } from '../types.js'
-import { AbstractResourceRepository, RepositoryContext } from './abstract.js'
+import {
+	AbstractResourceRepository,
+	GetParams,
+	RepositoryContext,
+} from './abstract.js'
 import {
 	createCustomFields,
 	createTypedMoney,
 	getReferenceFromResourceIdentifier,
 } from './helpers.js'
+import { CommercetoolsError } from '../exceptions.js'
+import { markMatchingShippingRate } from '../shippingCalculator.js'
 
 export class ShippingMethodRepository extends AbstractResourceRepository<'shipping-method'> {
 	getTypeId() {
@@ -79,6 +86,75 @@ export class ShippingMethodRepository extends AbstractResourceRepository<'shippi
 		tiers: rate.tiers || [],
 	})
 
+	/*
+	 * 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.
+	 */
+	public matchingCart(
+		context: RepositoryContext,
+		cartId: string,
+		params: GetParams = {}
+	) {
+		const cart = this._storage.get(context.projectKey, 'cart', cartId)
+		if (!cart) {
+			return undefined
+		}
+
+		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 = this._storage.query<'zone'>(context.projectKey, 'zone', {
+			where: [`locations(country="${cart.shippingAddress.country}"))`],
+			limit: 100,
+		})
+		const zoneIds = zones.results.map((zone) => zone.id)
+		const shippingMethods = this.query(context, {
+			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,
+		}
+	}
+
 	actions: Partial<
 		Record<
 			ShippingMethodUpdateAction['action'],

package/src/services/custom-object.ts

@@ -17,11 +17,30 @@ export class CustomObjectService extends AbstractService {
 	}
 
 	extraRoutes(router: Router) {
+		router.get('/:container', this.getWithContainer.bind(this))
 		router.get('/:container/:key', this.getWithContainerAndKey.bind(this))
 		router.post('/:container/:key', this.createWithContainerAndKey.bind(this))
 		router.delete('/:container/:key', this.deleteWithContainerAndKey.bind(this))
 	}
 
+	getWithContainer(request: Request, response: Response) {
+		const limit = this._parseParam(request.query.limit)
+		const offset = this._parseParam(request.query.offset)
+
+		const result = this.repository.queryWithContainer(
+			getRepositoryContext(request),
+			request.params.container,
+			{
+				expand: this._parseParam(request.query.expand),
+				where: this._parseParam(request.query.where),
+				limit: limit !== undefined ? Number(limit) : undefined,
+				offset: offset !== undefined ? Number(offset) : undefined,
+			}
+		)
+
+		return response.status(200).send(result)
+	}
+
 	getWithContainerAndKey(request: Request, response: Response) {
 		const result = this.repository.getWithContainerAndKey(
 			getRepositoryContext(request),

package/src/services/index.ts

@@ -23,6 +23,7 @@ import { ProductProjectionService } from './product-projection.js'
 import { ProductSelectionService } from './product-selection.js'
 import { ProductTypeService } from './product-type.js'
 import { ProductService } from './product.js'
+import { ReviewService } from './reviews.js'
 import { ShippingMethodService } from './shipping-method.js'
 import { ShoppingListService } from './shopping-list.js'
 import { StandAlonePriceService } from './standalone-price.js'
@@ -84,6 +85,7 @@ export const createServices = (router: any, repos: any) => ({
 		router,
 		repos['product-selection']
 	),
+	reviews: new ReviewService(router, repos['review']),
 	'shopping-list': new ShoppingListService(router, repos['shopping-list']),
 	state: new StateService(router, repos['state']),
 	store: new StoreService(router, repos['store']),

package/src/services/product-selection.test.ts

@@ -29,7 +29,6 @@ describe('product-selection', () => {
 			key: 'foo',
 			version: 1,
 			productCount: 0,
-			type: 'individual',
 			mode: 'Individual',
 		})
 	})

package/src/services/reviews.ts

@@ -0,0 +1,16 @@
+import { Router } from 'express'
+import AbstractService from './abstract.js'
+import { ReviewRepository } from '../repositories/review.js'
+
+export class ReviewService extends AbstractService {
+	public repository: ReviewRepository
+
+	constructor(parent: Router, repository: ReviewRepository) {
+		super(parent)
+		this.repository = repository
+	}
+
+	getBasePath() {
+		return 'reviews'
+	}
+}

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)
 	}
 }