@labdigital/commercetools-mock 1.5.0 → 1.6.0

package/src/repositories/product-projection.ts

@@ -1,59 +1,123 @@
-import type { ProductDraft, ProductProjection } from '@commercetools/platform-sdk'
+import type {
+	InvalidInputError,
+	ProductDraft,
+	ProductProjection,
+	QueryParam,
+} from '@commercetools/platform-sdk'
 import { ParsedQs } from 'qs'
 import { QueryParamsAsArray } from '../helpers.js'
 import { ProductProjectionSearch } from '../product-projection-search.js'
 import { type AbstractStorage } from '../storage/index.js'
-import {
-  AbstractResourceRepository,
-  type QueryParams,
-  RepositoryContext,
-} from './abstract.js'
+import { AbstractResourceRepository, RepositoryContext } from './abstract.js'
+import { parseQueryExpression } from '../lib/predicateParser.js'
+import { CommercetoolsError } from '../exceptions.js'
+
+type ProductProjectionQueryParams = {
+	staged?: boolean
+	priceCurrency?: string
+	priceCountry?: string
+	priceCustomerGroup?: string
+	priceChannel?: string
+	localeProjection?: string | string[]
+	storeProjection?: string
+	expand?: string | string[]
+	sort?: string | string[]
+	limit?: number
+	offset?: number
+	withTotal?: boolean
+	where?: string | string[]
+	[key: string]: QueryParam
+}
 
 export class ProductProjectionRepository extends AbstractResourceRepository<'product-projection'> {
-  protected _searchService: ProductProjectionSearch
-
-  constructor(storage: AbstractStorage) {
-    super(storage)
-    this._searchService = new ProductProjectionSearch(storage)
-  }
-
-  getTypeId() {
-    return 'product-projection' as const
-  }
-
-  create(context: RepositoryContext, draft: ProductDraft): ProductProjection {
-    throw new Error('No valid action')
-  }
-
-  query(context: RepositoryContext, params: QueryParams = {}) {
-    const response = this._storage.query(context.projectKey, 'product', {
-      expand: params.expand,
-      where: params.where,
-      offset: params.offset,
-      limit: params.limit,
-    })
-
-    return {
-      ...response,
-      results: response.results.map((r) =>
-        this._searchService.transform(r, false)
-      ),
-    }
-  }
-
-  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
-  }
-
-  actions = {}
+	protected _searchService: ProductProjectionSearch
+
+	constructor(storage: AbstractStorage) {
+		super(storage)
+		this._searchService = new ProductProjectionSearch(storage)
+	}
+
+	getTypeId() {
+		return 'product-projection' as const
+	}
+
+	create(context: RepositoryContext, draft: ProductDraft): ProductProjection {
+		throw new Error('No valid action')
+	}
+
+	query(context: RepositoryContext, params: ProductProjectionQueryParams = {}) {
+		let resources = this._storage
+			.all(context.projectKey, 'product')
+			.map((r) => this._searchService.transform(r, params.staged ?? false))
+			.filter((p) => {
+				if (!params.staged ?? false) {
+					return p.published
+				}
+				return true
+			})
+
+		// Apply predicates
+		if (params.where) {
+			const variableMap: Record<string, QueryParam> = {}
+			for (const [k, v] of Object.entries(params)) {
+				if (k.startsWith('var.')) {
+					variableMap[k.substring(4)] = v
+				}
+			}
+
+			try {
+				const filterFunc = parseQueryExpression(params.where)
+				resources = resources.filter((resource) =>
+					filterFunc(resource, variableMap)
+				)
+			} catch (err) {
+				throw new CommercetoolsError<InvalidInputError>(
+					{
+						code: 'InvalidInput',
+						message: (err as any).message,
+					},
+					400
+				)
+			}
+		}
+
+		// Expand the resources
+		if (params.expand !== undefined) {
+			resources = resources.map((resource) =>
+				this._storage.expand(context.projectKey, resource, params.expand)
+			)
+		}
+
+		// Create a slice for the pagination. If we were working with large datasets
+		// then we should have done this before transforming. But that isn't the
+		// goal of this library. So lets keep it simple.
+		const totalResults = resources.length
+		const offset = params.offset || 0
+		const limit = params.limit || 20
+		const results = resources.slice(offset, offset + limit)
+
+		return {
+			count: totalResults,
+			total: results.length,
+			offset: offset,
+			limit: limit,
+			results: results,
+		}
+	}
+
+	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
+	}
+
+	actions = {}
 }

package/src/repositories/product-selection.ts

@@ -1,41 +1,41 @@
 import type {
-  ProductSelection,
-  ProductSelectionDraft,
-  Review,
-  ReviewUpdateAction,
+	ProductSelection,
+	ProductSelectionDraft,
+	Review,
+	ReviewUpdateAction,
 } from '@commercetools/platform-sdk'
 import { getBaseResourceProperties } from '../helpers.js'
 import type { Writable } from '../types.js'
 import { AbstractResourceRepository, RepositoryContext } from './abstract.js'
 
 export class ProductSelectionRepository extends AbstractResourceRepository<'product-selection'> {
-  getTypeId() {
-    return 'product-selection' as const
-  }
+	getTypeId() {
+		return 'product-selection' as const
+	}
 
-  create(
-    context: RepositoryContext,
-    draft: ProductSelectionDraft
-  ): ProductSelection {
-    const resource: ProductSelection = {
-      ...getBaseResourceProperties(),
-      productCount: 0,
-      name: draft.name,
-      type: 'individual',
-      mode: 'Individual',
-    }
-    this.saveNew(context, resource)
-    return resource
-  }
+	create(
+		context: RepositoryContext,
+		draft: ProductSelectionDraft
+	): ProductSelection {
+		const resource: ProductSelection = {
+			...getBaseResourceProperties(),
+			productCount: 0,
+			name: draft.name,
+			type: 'individual',
+			mode: 'Individual',
+		}
+		this.saveNew(context, resource)
+		return resource
+	}
 
-  actions: Partial<
-    Record<
-      ReviewUpdateAction['action'],
-      (
-        context: RepositoryContext,
-        resource: Writable<Review>,
-        action: any
-      ) => void
-    >
-  > = {}
+	actions: Partial<
+		Record<
+			ReviewUpdateAction['action'],
+			(
+				context: RepositoryContext,
+				resource: Writable<Review>,
+				action: any
+			) => void
+		>
+	> = {}
 }

package/src/repositories/product-type.ts

@@ -1,173 +1,173 @@
 import type {
-  AttributeDefinition,
-  AttributeDefinitionDraft,
-  AttributeType,
-  ProductType,
-  ProductTypeAddAttributeDefinitionAction,
-  ProductTypeChangeAttributeOrderByNameAction,
-  ProductTypeChangeLabelAction,
-  ProductTypeChangeLocalizedEnumValueLabelAction,
-  ProductTypeDraft,
-  ProductTypeRemoveAttributeDefinitionAction,
-  ProductTypeRemoveEnumValuesAction,
-  ProductTypeUpdateAction,
+	AttributeDefinition,
+	AttributeDefinitionDraft,
+	AttributeType,
+	ProductType,
+	ProductTypeAddAttributeDefinitionAction,
+	ProductTypeChangeAttributeOrderByNameAction,
+	ProductTypeChangeLabelAction,
+	ProductTypeChangeLocalizedEnumValueLabelAction,
+	ProductTypeDraft,
+	ProductTypeRemoveAttributeDefinitionAction,
+	ProductTypeRemoveEnumValuesAction,
+	ProductTypeUpdateAction,
 } from '@commercetools/platform-sdk'
 import { getBaseResourceProperties } from '../helpers.js'
 import type { Writable } from '../types.js'
 import { AbstractResourceRepository, RepositoryContext } from './abstract.js'
 
 export class ProductTypeRepository extends AbstractResourceRepository<'product-type'> {
-  getTypeId() {
-    return 'product-type' as const
-  }
+	getTypeId() {
+		return 'product-type' as const
+	}
 
-  create(context: RepositoryContext, draft: ProductTypeDraft): ProductType {
-    const resource: ProductType = {
-      ...getBaseResourceProperties(),
-      key: draft.key,
-      name: draft.name,
-      description: draft.description,
-      attributes: (draft.attributes ?? []).map((a) =>
-        this.attributeDefinitionFromAttributeDefinitionDraft(context, a)
-      ),
-    }
+	create(context: RepositoryContext, draft: ProductTypeDraft): ProductType {
+		const resource: ProductType = {
+			...getBaseResourceProperties(),
+			key: draft.key,
+			name: draft.name,
+			description: draft.description,
+			attributes: (draft.attributes ?? []).map((a) =>
+				this.attributeDefinitionFromAttributeDefinitionDraft(context, a)
+			),
+		}
 
-    this.saveNew(context, resource)
-    return resource
-  }
+		this.saveNew(context, resource)
+		return resource
+	}
 
-  attributeDefinitionFromAttributeDefinitionDraft = (
-    _context: RepositoryContext,
-    draft: AttributeDefinitionDraft
-  ): AttributeDefinition => ({
-    ...draft,
-    attributeConstraint: draft.attributeConstraint ?? 'None',
-    inputHint: draft.inputHint ?? 'SingleLine',
-    inputTip:
-      draft.inputTip && Object.keys(draft.inputTip).length > 0
-        ? draft.inputTip
-        : undefined,
-    isSearchable: draft.isSearchable ?? true,
-  })
+	attributeDefinitionFromAttributeDefinitionDraft = (
+		_context: RepositoryContext,
+		draft: AttributeDefinitionDraft
+	): AttributeDefinition => ({
+		...draft,
+		attributeConstraint: draft.attributeConstraint ?? 'None',
+		inputHint: draft.inputHint ?? 'SingleLine',
+		inputTip:
+			draft.inputTip && Object.keys(draft.inputTip).length > 0
+				? draft.inputTip
+				: undefined,
+		isSearchable: draft.isSearchable ?? true,
+	})
 
-  actions: Partial<
-    Record<
-      ProductTypeUpdateAction['action'],
-      (
-        context: RepositoryContext,
-        resource: Writable<ProductType>,
-        action: any
-      ) => void
-    >
-  > = {
-    changeLocalizedEnumValueLabel: (
-      context: RepositoryContext,
-      resource: Writable<ProductType>,
-      {
-        attributeName,
-        newValue,
-      }: ProductTypeChangeLocalizedEnumValueLabelAction
-    ) => {
-      const updateAttributeType = (type: Writable<AttributeType>) => {
-        switch (type.name) {
-          case 'lenum':
-            type.values.forEach((v) => {
-              if (v.key === newValue.key) {
-                v.label = newValue.label
-              }
-            })
-            return
-          case 'set':
-            updateAttributeType(type.elementType)
-            return
-        }
-      }
+	actions: Partial<
+		Record<
+			ProductTypeUpdateAction['action'],
+			(
+				context: RepositoryContext,
+				resource: Writable<ProductType>,
+				action: any
+			) => void
+		>
+	> = {
+		changeLocalizedEnumValueLabel: (
+			context: RepositoryContext,
+			resource: Writable<ProductType>,
+			{
+				attributeName,
+				newValue,
+			}: ProductTypeChangeLocalizedEnumValueLabelAction
+		) => {
+			const updateAttributeType = (type: Writable<AttributeType>) => {
+				switch (type.name) {
+					case 'lenum':
+						type.values.forEach((v) => {
+							if (v.key === newValue.key) {
+								v.label = newValue.label
+							}
+						})
+						return
+					case 'set':
+						updateAttributeType(type.elementType)
+						return
+				}
+			}
 
-      resource.attributes?.forEach((value) => {
-        if (value.name === attributeName) {
-          updateAttributeType(value.type)
-        }
-      })
-    },
-    changeLabel: (
-      context: RepositoryContext,
-      resource: Writable<ProductType>,
-      { attributeName, label }: ProductTypeChangeLabelAction
-    ) => {
-      resource.attributes?.forEach((value) => {
-        if (value.name === attributeName) {
-          value.label = label
-        }
-      })
-    },
-    addAttributeDefinition: (
-      context: RepositoryContext,
-      resource: Writable<ProductType>,
-      { attribute }: ProductTypeAddAttributeDefinitionAction
-    ) => {
-      resource.attributes?.push(
-        this.attributeDefinitionFromAttributeDefinitionDraft(context, attribute)
-      )
-    },
-    changeAttributeOrderByName: (
-      context: RepositoryContext,
-      resource: Writable<ProductType>,
-      { attributeNames }: ProductTypeChangeAttributeOrderByNameAction
-    ) => {
-      const attrs = new Map(
-        resource.attributes?.map((item) => [item.name, item])
-      )
-      const result: AttributeDefinition[] = []
-      let current = resource.attributes
+			resource.attributes?.forEach((value) => {
+				if (value.name === attributeName) {
+					updateAttributeType(value.type)
+				}
+			})
+		},
+		changeLabel: (
+			context: RepositoryContext,
+			resource: Writable<ProductType>,
+			{ attributeName, label }: ProductTypeChangeLabelAction
+		) => {
+			resource.attributes?.forEach((value) => {
+				if (value.name === attributeName) {
+					value.label = label
+				}
+			})
+		},
+		addAttributeDefinition: (
+			context: RepositoryContext,
+			resource: Writable<ProductType>,
+			{ attribute }: ProductTypeAddAttributeDefinitionAction
+		) => {
+			resource.attributes?.push(
+				this.attributeDefinitionFromAttributeDefinitionDraft(context, attribute)
+			)
+		},
+		changeAttributeOrderByName: (
+			context: RepositoryContext,
+			resource: Writable<ProductType>,
+			{ attributeNames }: ProductTypeChangeAttributeOrderByNameAction
+		) => {
+			const attrs = new Map(
+				resource.attributes?.map((item) => [item.name, item])
+			)
+			const result: AttributeDefinition[] = []
+			let current = resource.attributes
 
-      attributeNames.forEach((attrName) => {
-        const attr = attrs.get(attrName)
-        if (attr === undefined) {
-          throw new Error('New attr')
-        }
-        result.push(attr)
+			attributeNames.forEach((attrName) => {
+				const attr = attrs.get(attrName)
+				if (attr === undefined) {
+					throw new Error('New attr')
+				}
+				result.push(attr)
 
-        // Remove from current items
-        current = current?.filter((f) => f.name !== attrName)
-      })
+				// Remove from current items
+				current = current?.filter((f) => f.name !== attrName)
+			})
 
-      resource.attributes = result
-      // Add attrs which were not specified in the order as last items. Not
-      // sure if this follows commercetools
-      if (current) {
-        resource.attributes.push(...current)
-      }
-    },
-    removeAttributeDefinition: (
-      context: RepositoryContext,
-      resource: Writable<ProductType>,
-      { name }: ProductTypeRemoveAttributeDefinitionAction
-    ) => {
-      resource.attributes = resource.attributes?.filter((f) => f.name !== name)
-    },
-    removeEnumValues: (
-      context: RepositoryContext,
-      resource: Writable<ProductType>,
-      { attributeName, keys }: ProductTypeRemoveEnumValuesAction
-    ) => {
-      resource.attributes?.forEach((attr) => {
-        if (attr.name == attributeName) {
-          if (attr.type.name == 'enum') {
-            attr.type.values = attr.type.values.filter(
-              (v) => !keys.includes(v.key)
-            )
-          }
+			resource.attributes = result
+			// Add attrs which were not specified in the order as last items. Not
+			// sure if this follows commercetools
+			if (current) {
+				resource.attributes.push(...current)
+			}
+		},
+		removeAttributeDefinition: (
+			context: RepositoryContext,
+			resource: Writable<ProductType>,
+			{ name }: ProductTypeRemoveAttributeDefinitionAction
+		) => {
+			resource.attributes = resource.attributes?.filter((f) => f.name !== name)
+		},
+		removeEnumValues: (
+			context: RepositoryContext,
+			resource: Writable<ProductType>,
+			{ attributeName, keys }: ProductTypeRemoveEnumValuesAction
+		) => {
+			resource.attributes?.forEach((attr) => {
+				if (attr.name == attributeName) {
+					if (attr.type.name == 'enum') {
+						attr.type.values = attr.type.values.filter(
+							(v) => !keys.includes(v.key)
+						)
+					}
 
-          if (attr.type.name == 'set') {
-            if (attr.type.elementType.name == 'enum') {
-              attr.type.elementType.values =
-                attr.type.elementType.values.filter(
-                  (v) => !keys.includes(v.key)
-                )
-            }
-          }
-        }
-      })
-    },
-  }
+					if (attr.type.name == 'set') {
+						if (attr.type.elementType.name == 'enum') {
+							attr.type.elementType.values =
+								attr.type.elementType.values.filter(
+									(v) => !keys.includes(v.key)
+								)
+						}
+					}
+				}
+			})
+		},
+	}
 }