@labdigital/commercetools-mock 1.8.0 → 1.9.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@labdigital/commercetools-mock",
   "author": "Michael van Tellingen",
-  "version": "1.8.0",
+  "version": "1.9.0",
   "license": "MIT",
   "main": "dist/index.cjs",
   "module": "dist/index.js",

package/src/helpers.ts

@@ -32,17 +32,30 @@ export const nestedLookup = (obj: any, path: string): any => {
 	return val
 }
 
-export const QueryParamsAsArray = (
+export const queryParamsArray = (
 	input: string | ParsedQs | string[] | ParsedQs[] | undefined
-): string[] => {
+): string[] | undefined => {
 	if (input == undefined) {
-		return []
+		return undefined
 	}
 
-	if (Array.isArray(input)) {
-		return input as string[]
+	const values: string[] = Array.isArray(input)
+		? (input as string[])
+		: ([input] as string[])
+	if (values.length < 1) {
+		return undefined
 	}
-	return [input] as string[]
+	return values
+}
+
+export const queryParamsValue = (
+	value: string | ParsedQs | string[] | ParsedQs[] | undefined
+): string | undefined => {
+	const values = queryParamsArray(value)
+	if (values && values.length > 0) {
+		return values[0]
+	}
+	return undefined
 }
 
 export const cloneObject = <T>(o: T): T => JSON.parse(JSON.stringify(o))

package/src/product-projection-search.ts

@@ -171,15 +171,25 @@ export class ProductProjectionSearch {
 		products: ProductProjection[]
 	): FacetResults {
 		if (!params.facet) return {}
-		const staged = false
 		const result: FacetResults = {}
 
-		for (const facet of params.facet) {
+		const regexp = new RegExp(/ counting products$/)
+		for (let facet of params.facet) {
+			let countProducts = false
+			if (facet.endsWith(' counting products')) {
+				facet = facet.replace(regexp, '')
+				countProducts = true
+			}
+
 			const expression = generateFacetFunc(facet)
 
 			// Term Facet
 			if (expression.type === 'TermExpression') {
-				result[facet] = this.termFacet(expression.source, products)
+				result[facet] = this.termFacet(
+					expression.source,
+					products,
+					countProducts
+				)
 			}
 
 			// Range Facet
@@ -187,7 +197,8 @@ export class ProductProjectionSearch {
 				result[expression.source] = this.rangeFacet(
 					expression.source,
 					expression.children,
-					products
+					products,
+					countProducts
 				)
 			}
 
@@ -196,7 +207,8 @@ export class ProductProjectionSearch {
 				result[expression.source] = this.filterFacet(
 					expression.source,
 					expression.children,
-					products
+					products,
+					countProducts
 				)
 			}
 		}
@@ -209,7 +221,11 @@ export class ProductProjectionSearch {
 	 *  - counting products
 	 *  - correct dataType
 	 */
-	termFacet(facet: string, products: ProductProjection[]): TermFacetResult {
+	termFacet(
+		facet: string,
+		products: ProductProjection[],
+		countProducts: boolean
+	): TermFacetResult {
 		const result: Writable<TermFacetResult> = {
 			type: 'terms',
 			dataType: 'text',
@@ -254,13 +270,15 @@ export class ProductProjectionSearch {
 				count: terms[term],
 			})
 		}
+
 		return result
 	}
 
 	filterFacet(
 		source: string,
 		filters: FilterExpression[] | undefined,
-		products: ProductProjection[]
+		products: ProductProjection[],
+		countProducts: boolean
 	): FilteredFacetResult {
 		let count = 0
 		if (source.startsWith('variants.')) {
@@ -285,7 +303,8 @@ export class ProductProjectionSearch {
 	rangeFacet(
 		source: string,
 		ranges: RangeExpression[] | undefined,
-		products: ProductProjection[]
+		products: ProductProjection[],
+		countProducts: boolean
 	): RangeFacetResult {
 		const counts =
 			ranges?.map((range) => {

package/src/repositories/business-unit.ts

@@ -1,14 +1,215 @@
-import type { BusinessUnit } from '@commercetools/platform-sdk'
+import {
+	type Associate,
+	type BusinessUnit,
+	type BusinessUnitAddAddressAction,
+	type BusinessUnitAddAssociateAction,
+	type BusinessUnitAddStoreAction,
+	type BusinessUnitChangeAddressAction,
+	type BusinessUnitChangeNameAction,
+	type BusinessUnitChangeParentUnitAction,
+	type BusinessUnitDraft,
+	type BusinessUnitSetAssociatesAction,
+	type BusinessUnitSetContactEmailAction,
+	type BusinessUnitSetStoreModeAction,
+	type Company,
+	type Division,
+	BusinessUnitChangeStatusAction,
+	CompanyDraft,
+	DivisionDraft,
+} from '@commercetools/platform-sdk'
 import {
 	AbstractResourceRepository,
 	type RepositoryContext,
 } from './abstract.js'
+import { getBaseResourceProperties } from '../helpers.js'
+import {
+	createAddress,
+	createAssociate,
+	createCustomFields,
+	getBusinessUnitKeyReference,
+	getStoreKeyReference,
+} from './helpers.js'
+import { Writable } from '../types.js'
 
 export class BusinessUnitRepository extends AbstractResourceRepository<'business-unit'> {
 	getTypeId() {
 		return 'business-unit' as const
 	}
-	create(context: RepositoryContext, draft: any): BusinessUnit {
-		throw new Error('Method not implemented.')
+
+	private _isCompanyDraft(draft: BusinessUnitDraft): draft is CompanyDraft {
+		return draft.unitType === 'Company'
+	}
+
+	private _isDivisionDraft(draft: BusinessUnitDraft): draft is DivisionDraft {
+		return draft.unitType === 'Division'
+	}
+
+	create(context: RepositoryContext, draft: BusinessUnitDraft): BusinessUnit {
+		const resource = {
+			...getBaseResourceProperties(),
+			key: draft.key,
+			status: draft.status,
+			stores: draft.stores?.map((s) =>
+				getStoreKeyReference(s, context.projectKey, this._storage)
+			),
+			storeMode: draft.storeMode,
+			name: draft.name,
+			contactEmail: draft.contactEmail,
+			addresses: draft.addresses?.map((a) =>
+				createAddress(a, context.projectKey, this._storage)
+			),
+			custom: createCustomFields(
+				draft.custom,
+				context.projectKey,
+				this._storage
+			),
+			shippingAddressIds: draft.shippingAddresses,
+			defaultShippingAddressId: draft.defaultShippingAddress,
+			billingAddressIds: draft.billingAddresses,
+			associateMode: draft.associateMode,
+			associates: draft.associates?.map((a) =>
+				createAssociate(a, context.projectKey, this._storage)
+			),
+		}
+
+		if (this._isDivisionDraft(draft)) {
+			const division = {
+				...resource,
+				parentUnit: getBusinessUnitKeyReference(
+					draft.parentUnit,
+					context.projectKey,
+					this._storage
+				),
+			} as Division
+
+			this.saveNew(context, division)
+			return division
+		} else if (this._isCompanyDraft(draft)) {
+			const company = resource as Company
+
+			this.saveNew(context, company)
+			return company
+		}
+
+		throw new Error('Invalid business unit type')
+	}
+
+	actions = {
+		addAddress: (
+			context: RepositoryContext,
+			resource: Writable<BusinessUnit>,
+			{ address }: BusinessUnitAddAddressAction
+		) => {
+			const newAddress = createAddress(
+				address,
+				context.projectKey,
+				this._storage
+			)
+			if (newAddress) {
+				resource.addresses.push(newAddress)
+			}
+		},
+		addAssociate: (
+			context: RepositoryContext,
+			resource: Writable<BusinessUnit>,
+			{ associate }: BusinessUnitAddAssociateAction
+		) => {
+			const newAssociate = createAssociate(
+				associate,
+				context.projectKey,
+				this._storage
+			)
+			if (newAssociate) {
+				resource.associates.push(newAssociate)
+			}
+		},
+		setAssociates: (
+			context: RepositoryContext,
+			resource: Writable<BusinessUnit>,
+			{ associates }: BusinessUnitSetAssociatesAction
+		) => {
+			const newAssociates = associates
+				.map((a) => createAssociate(a, context.projectKey, this._storage))
+				.filter((a): a is Writable<Associate> => a !== undefined)
+			resource.associates = newAssociates || undefined
+		},
+		setContactEmail: (
+			context: RepositoryContext,
+			resource: Writable<BusinessUnit>,
+			{ contactEmail }: BusinessUnitSetContactEmailAction
+		) => {
+			resource.contactEmail = contactEmail
+		},
+		setStoreMode: (
+			context: RepositoryContext,
+			resource: Writable<BusinessUnit>,
+			{ storeMode }: BusinessUnitSetStoreModeAction
+		) => {
+			resource.storeMode = storeMode
+		},
+		changeAssociateMode: (
+			context: RepositoryContext,
+			resource: Writable<BusinessUnit>,
+			{ storeMode }: BusinessUnitSetStoreModeAction
+		) => {
+			resource.associateMode = storeMode
+		},
+		changeName: (
+			context: RepositoryContext,
+			resource: Writable<BusinessUnit>,
+			{ name }: BusinessUnitChangeNameAction
+		) => {
+			resource.name = name
+		},
+		changeAddress: (
+			context: RepositoryContext,
+			resource: Writable<BusinessUnit>,
+			{ address }: BusinessUnitChangeAddressAction
+		) => {
+			const newAddress = createAddress(
+				address,
+				context.projectKey,
+				this._storage
+			)
+			if (newAddress) {
+				resource.addresses.push(newAddress)
+			}
+		},
+		addStore: (
+			context: RepositoryContext,
+			resource: Writable<BusinessUnit>,
+			{ store }: BusinessUnitAddStoreAction
+		) => {
+			const newStore = getStoreKeyReference(
+				store,
+				context.projectKey,
+				this._storage
+			)
+			if (newStore) {
+				if (!resource.stores) {
+					resource.stores = []
+				}
+
+				resource.stores.push(newStore)
+			}
+		},
+		changeParentUnit: (
+			context: RepositoryContext,
+			resource: Writable<BusinessUnit>,
+			{ parentUnit }: BusinessUnitChangeParentUnitAction
+		) => {
+			resource.parentUnit = getBusinessUnitKeyReference(
+				parentUnit,
+				context.projectKey,
+				this._storage
+			)
+		},
+		changeStatus: (
+			context: RepositoryContext,
+			resource: Writable<BusinessUnit>,
+			{ status }: BusinessUnitChangeStatusAction
+		) => {
+			resource.status = status
+		},
 	}
 }

package/src/repositories/cart-discount.ts

@@ -5,6 +5,7 @@ import type {
 	CartDiscountChangeTargetAction,
 	CartDiscountDraft,
 	CartDiscountSetCustomFieldAction,
+	CartDiscountSetCustomTypeAction,
 	CartDiscountSetDescriptionAction,
 	CartDiscountSetKeyAction,
 	CartDiscountSetValidFromAction,
@@ -162,7 +163,6 @@ export class CartDiscountRepository extends AbstractResourceRepository<'cart-dis
 		) => {
 			resource.target = target
 		},
-
 		setCustomField: (
 			context: RepositoryContext,
 			resource: Writable<CartDiscount>,
@@ -190,5 +190,30 @@ export class CartDiscountRepository extends AbstractResourceRepository<'cart-dis
 				resource.custom.fields[name] = value
 			}
 		},
+		setCustomType: (
+			context: RepositoryContext,
+			resource: Writable<CartDiscount>,
+			{ type, fields }: CartDiscountSetCustomTypeAction
+		) => {
+			if (!type) {
+				resource.custom = undefined
+			} else {
+				const resolvedType = this._storage.getByResourceIdentifier(
+					context.projectKey,
+					type
+				)
+				if (!resolvedType) {
+					throw new Error(`Type ${type} not found`)
+				}
+
+				resource.custom = {
+					type: {
+						typeId: 'type',
+						id: resolvedType.id,
+					},
+					fields: fields || {},
+				}
+			}
+		},
 	}
 }

package/src/repositories/helpers.ts

@@ -1,24 +1,34 @@
-import type {
-	Address,
-	BaseAddress,
-	CentPrecisionMoney,
-	CustomFields,
-	CustomFieldsDraft,
-	HighPrecisionMoney,
-	HighPrecisionMoneyDraft,
-	InvalidJsonInputError,
-	Price,
-	PriceDraft,
-	Reference,
-	ReferencedResourceNotFoundError,
-	ResourceIdentifier,
-	Store,
-	StoreKeyReference,
-	StoreReference,
-	StoreResourceIdentifier,
-	Type,
-	TypedMoney,
-	_Money,
+import {
+	AssociateRoleReference,
+	type Address,
+	type Associate,
+	type AssociateDraft,
+	type AssociateRoleAssignment,
+	type AssociateRoleAssignmentDraft,
+	type AssociateRoleKeyReference,
+	type AssociateRoleResourceIdentifier,
+	type BaseAddress,
+	type CentPrecisionMoney,
+	type CustomFields,
+	type CustomFieldsDraft,
+	type HighPrecisionMoney,
+	type HighPrecisionMoneyDraft,
+	type InvalidJsonInputError,
+	type Price,
+	type PriceDraft,
+	type Reference,
+	type ReferencedResourceNotFoundError,
+	type ResourceIdentifier,
+	type Store,
+	type StoreKeyReference,
+	type StoreReference,
+	type StoreResourceIdentifier,
+	type Type,
+	type TypedMoney,
+	type _Money,
+	BusinessUnitResourceIdentifier,
+	BusinessUnitKeyReference,
+	BusinessUnitReference,
 } from '@commercetools/platform-sdk'
 import type { Request } from 'express'
 import { v4 as uuidv4 } from 'uuid'
@@ -219,3 +229,90 @@ export const getRepositoryContext = (request: Request): RepositoryContext => ({
 	projectKey: request.params.projectKey,
 	storeKey: request.params.storeKey,
 })
+
+export const createAssociate = (
+	a: AssociateDraft,
+	projectKey: string,
+	storage: AbstractStorage
+): Associate | undefined => {
+	if (!a) return undefined
+
+	if (!a.associateRoleAssignments) {
+		throw new Error('AssociateRoleAssignments is required')
+	}
+
+	return {
+		customer: getReferenceFromResourceIdentifier(
+			a.customer,
+			projectKey,
+			storage
+		),
+		associateRoleAssignments: a.associateRoleAssignments?.map(
+			(a: AssociateRoleAssignmentDraft): AssociateRoleAssignment => ({
+				associateRole: getAssociateRoleKeyReference(
+					a.associateRole,
+					projectKey,
+					storage
+				),
+				inheritance: a.inheritance as string,
+			})
+		),
+		roles: a.roles as string[],
+	}
+}
+
+export const getAssociateRoleKeyReference = (
+	id: AssociateRoleResourceIdentifier,
+	projectKey: string,
+	storage: AbstractStorage
+): AssociateRoleKeyReference => {
+	if (id.key) {
+		return {
+			typeId: 'associate-role',
+			key: id.key,
+		}
+	}
+
+	const value = getReferenceFromResourceIdentifier<AssociateRoleReference>(
+		id,
+		projectKey,
+		storage
+	)
+
+	if (!value.obj?.key) {
+		throw new Error('No associate-role found for reference')
+	}
+
+	return {
+		typeId: 'associate-role',
+		key: value.obj?.key,
+	}
+}
+
+export const getBusinessUnitKeyReference = (
+	id: BusinessUnitResourceIdentifier,
+	projectKey: string,
+	storage: AbstractStorage
+): BusinessUnitKeyReference => {
+	if (id.key) {
+		return {
+			typeId: 'business-unit',
+			key: id.key,
+		}
+	}
+
+	const value = getReferenceFromResourceIdentifier<BusinessUnitReference>(
+		id,
+		projectKey,
+		storage
+	)
+
+	if (!value.obj?.key) {
+		throw new Error('No business-unit found for reference')
+	}
+
+	return {
+		typeId: 'business-unit',
+		key: value.obj?.key,
+	}
+}

package/src/repositories/product-projection.ts

@@ -4,9 +4,7 @@ import type {
 	ProductProjection,
 	QueryParam,
 } from '@commercetools/platform-sdk'
-import { ParsedQs } from 'qs'
 import { CommercetoolsError } from '../exceptions.js'
-import { QueryParamsAsArray } from '../helpers.js'
 import { parseQueryExpression } from '../lib/predicateParser.js'
 import { ProductProjectionSearch } from '../product-projection-search.js'
 import { type AbstractStorage } from '../storage/index.js'
@@ -16,13 +14,13 @@ import {
 	RepositoryContext,
 } from './abstract.js'
 
-type ProductProjectionQueryParams = {
+export type ProductProjectionQueryParams = {
 	staged?: boolean
 	priceCurrency?: string
 	priceCountry?: string
 	priceCustomerGroup?: string
 	priceChannel?: string
-	localeProjection?: string | string[]
+	localeProjection?: string
 	storeProjection?: string
 	expand?: string | string[]
 	sort?: string | string[]
@@ -126,18 +124,8 @@ export class ProductProjectionRepository extends AbstractResourceRepository<'pro
 		}
 	}
 
-	search(context: RepositoryContext, query: ParsedQs) {
-		const results = this._searchService.search(context.projectKey, {
-			filter: QueryParamsAsArray(query.filter),
-			'filter.query': QueryParamsAsArray(query['filter.query']),
-			facet: QueryParamsAsArray(query.facet),
-			offset: query.offset ? Number(query.offset) : undefined,
-			limit: query.limit ? Number(query.limit) : undefined,
-			expand: QueryParamsAsArray(query.expand),
-			staged: query.staged === 'true',
-		})
-
-		return results
+	search(context: RepositoryContext, query: ProductProjectionQueryParams) {
+		return this._searchService.search(context.projectKey, query)
 	}
 
 	actions = {}

package/src/services/abstract.ts

@@ -3,6 +3,7 @@ import { type Request, type Response, Router } from 'express'
 import { ParsedQs } from 'qs'
 import { AbstractResourceRepository } from '../repositories/abstract.js'
 import { getRepositoryContext } from '../repositories/helpers.js'
+import { queryParamsArray } from '../helpers.js'
 
 export default abstract class AbstractService {
 	protected abstract getBasePath(): string
@@ -170,12 +171,6 @@ export default abstract class AbstractService {
 	protected _parseParam(
 		value: string | ParsedQs | string[] | ParsedQs[] | undefined
 	): string[] | undefined {
-		if (Array.isArray(value)) {
-			// @ts-ignore
-			return value
-		} else if (value !== undefined) {
-			return [`${value}`]
-		}
-		return undefined
+		return queryParamsArray(value)
 	}
 }

package/src/services/business-units.test.ts

@@ -0,0 +1,42 @@
+import { afterEach, beforeEach, describe, expect, test } from 'vitest'
+import { CommercetoolsMock } from '../ctMock.js'
+import { BusinessUnit } from '@commercetools/platform-sdk'
+import supertest from 'supertest'
+
+describe('Business units query', () => {
+	const ctMock = new CommercetoolsMock()
+	let businessUnit: BusinessUnit | undefined
+
+	beforeEach(async () => {
+		const response = await supertest(ctMock.app)
+			.post('/dummy/business-units')
+			.send({
+				key: 'example-business-unit',
+				status: 'Active',
+				name: 'Example Business Unit',
+				unitType: 'Company',
+			})
+
+		expect(response.status).toBe(201)
+
+		businessUnit = response.body as BusinessUnit
+	})
+
+	afterEach(() => {
+		ctMock.clear()
+	})
+
+	test('no filter', async () => {
+		const response = await supertest(ctMock.app)
+			.get('/dummy/business-units')
+			.query('{}')
+			.send()
+
+		expect(response.status).toBe(200)
+		expect(response.body.count).toBe(1)
+
+		const businessUnit = response.body.results[0] as BusinessUnit
+
+		expect(businessUnit.key).toBe('example-business-unit')
+	})
+})

package/src/services/business-units.ts

@@ -0,0 +1,17 @@
+import { Router } from 'express'
+import { BusinessUnitRepository } from '../repositories/business-unit.js'
+import AbstractService from './abstract.js'
+
+export class BusinessUnitServices extends AbstractService {
+	public repository: BusinessUnitRepository
+
+	constructor(parent: Router, repository: BusinessUnitRepository) {
+		super(parent)
+
+		this.repository = repository
+	}
+
+	protected getBasePath(): string {
+		return 'business-units'
+	}
+}

package/src/services/cart-discount.test.ts

@@ -359,4 +359,22 @@ describe('Cart Discounts Update Actions', () => {
 			})
 		expect(response.status).toBe(400)
 	})
+
+	test('remove all custom fields', async () => {
+		assert(cartDiscount, 'cart discount not created')
+
+		const response = await supertest(ctMock.app)
+			.post(`/dummy/cart-discounts/${cartDiscount.id}`)
+			.send({
+				version: 1,
+				actions: [
+					{
+						action: 'setCustomType',
+					},
+				],
+			})
+		expect(response.status).toBe(200)
+		expect(response.body.version).toBe(2)
+		expect(response.body.custom).toBeUndefined()
+	})
 })