@labdigital/commercetools-mock 0.6.5 → 0.8.0

package/src/priceSelector.test.ts

@@ -0,0 +1,96 @@
+import { ProductData, Product } from '@commercetools/platform-sdk'
+import { applyPriceSelector } from './priceSelector'
+
+describe('priceSelector', () => {
+  let product: Product
+
+  beforeEach(() => {
+    const productData: ProductData = {
+      name: {
+        'nl-NL': 'test',
+      },
+      slug: {
+        'nl-NL': 'test',
+      },
+      variants: [],
+      searchKeywords: {},
+      categories: [],
+      masterVariant: {
+        id: 1,
+        sku: 'MYSKU',
+        attributes: [
+          {
+            name: 'Country',
+            value: {
+              key: 'NL',
+              label: {
+                de: 'niederlande',
+                en: 'netherlands',
+                nl: 'nederland',
+              },
+            },
+          },
+          {
+            name: 'number',
+            value: 4,
+          },
+        ],
+        prices: [
+          {
+            id: 'dummy-uuid',
+            value: {
+              type: 'centPrecision',
+              currencyCode: 'EUR',
+              centAmount: 1789,
+              fractionDigits: 2,
+            },
+          },
+        ],
+      },
+    }
+
+    product = {
+      id: '7401d82f-1378-47ba-996a-85beeb87ac87',
+      version: 2,
+      createdAt: '2022-07-22T10:02:40.851Z',
+      lastModifiedAt: '2022-07-22T10:02:44.427Z',
+      productType: {
+        typeId: 'product-type',
+        id: 'b9b4b426-938b-4ccb-9f36-c6f933e8446e',
+      },
+      masterData: {
+        current: productData,
+        staged: productData,
+        published: true,
+        hasStagedChanges: false,
+      },
+    }
+  })
+
+  test('currency (match)', async () => {
+    applyPriceSelector([product], { currency: 'EUR' })
+
+    expect(product).toMatchObject({
+      masterData: {
+        current: {
+          masterVariant: {
+            sku: 'MYSKU',
+            scopedPrice: { value: { centAmount: 1789 } },
+          },
+        },
+        staged: {
+          masterVariant: {
+            sku: 'MYSKU',
+            scopedPrice: { value: { centAmount: 1789 } },
+          },
+        },
+      },
+    })
+  })
+
+  test('currency, country (no match)', async () => {
+    applyPriceSelector([product], { currency: 'EUR', country: 'US' })
+    expect(product.masterData.current.masterVariant.scopedPrice).toBeUndefined()
+    expect(product.masterData.staged.masterVariant.scopedPrice).toBeUndefined()
+  })
+})

package/src/priceSelector.ts

@@ -0,0 +1,109 @@
+import {
+  InvalidInputError,
+  Price,
+  Product,
+  ProductVariant,
+} from '@commercetools/platform-sdk'
+import { CommercetoolsError } from './exceptions'
+import { Writable } from './types'
+
+export type PriceSelector = {
+  currency?: string
+  country?: string
+  customerGroup?: string
+  channel?: string
+}
+
+/**
+ * Apply the price selector on all the variants. The price selector is applied
+ * on all the prices per variant and the first match per variant is stored in
+ * the scopedPrice attribute
+ */
+export const applyPriceSelector = (
+  products: Product[],
+  selector: PriceSelector
+) => {
+  validatePriceSelector(selector)
+
+  for (const product of products) {
+    const variants: Writable<ProductVariant>[] = [
+      product.masterData.staged?.masterVariant,
+      ...(product.masterData.staged?.variants || []),
+
+      product.masterData.current?.masterVariant,
+      ...(product.masterData.current?.variants || []),
+    ].filter(x => x != undefined)
+
+    for (const variant of variants) {
+      const scopedPrices =
+        variant.prices?.filter(p => priceSelectorFilter(p, selector)) ?? []
+
+      if (scopedPrices.length > 0) {
+        const price = scopedPrices[0]
+
+        variant.scopedPriceDiscounted = false
+        variant.scopedPrice = {
+          ...price,
+          currentValue: price.value,
+        }
+      }
+    }
+  }
+}
+
+const validatePriceSelector = (selector: PriceSelector) => {
+  if (
+    (selector.country || selector.channel || selector.customerGroup) &&
+    !selector.currency
+  ) {
+    throw new CommercetoolsError<InvalidInputError>(
+      {
+        code: 'InvalidInput',
+        message:
+          'The price selecting parameters country, channel and customerGroup ' +
+          'cannot be used without the currency.',
+      },
+      400
+    )
+  }
+}
+
+/**
+ * Return a boolean to indicate if the price matches the selector. Price
+ * selection requires that if the selector or the price has a specific value
+ * then it should match.
+ */
+export const priceSelectorFilter = (
+  price: Price,
+  selector: PriceSelector
+): boolean => {
+  if (
+    (selector.country || price.country) &&
+    selector.country !== price.country
+  ) {
+    return false
+  }
+
+  if (
+    (selector.currency || price.value.currencyCode) &&
+    selector.currency !== price.value.currencyCode
+  ) {
+    return false
+  }
+
+  if (
+    (selector.channel || price.channel?.id) &&
+    selector.channel !== price.channel?.id
+  ) {
+    return false
+  }
+
+  if (
+    (selector.customerGroup || price.customerGroup?.id) &&
+    selector.customerGroup !== price.customerGroup?.id
+  ) {
+    return false
+  }
+
+  return true
+}

package/src/product-projection-search.ts

@@ -0,0 +1,345 @@
+import {
+  InvalidInputError,
+  ProductProjectionPagedSearchResponse,
+  Product,
+  ProductProjection,
+  QueryParam,
+  FacetResults,
+  FacetTerm,
+  TermFacetResult,
+  RangeFacetResult,
+  FilteredFacetResult,
+} from '@commercetools/platform-sdk'
+import { ByProjectKeyProductProjectionsSearchRequestBuilder } from '@commercetools/platform-sdk/dist/declarations/src/generated/client/search/by-project-key-product-projections-search-request-builder'
+import { nestedLookup } from './helpers'
+import { ProductService } from './services/product'
+import { Writable } from './types'
+import { CommercetoolsError } from './exceptions'
+import {
+  FilterExpression,
+  generateFacetFunc,
+  getVariants,
+  parseFilterExpression,
+  RangeExpression,
+  resolveVariantValue,
+} from './lib/projectionSearchFilter'
+import { applyPriceSelector } from './priceSelector'
+import { AbstractStorage } from './storage'
+
+export type ProductProjectionSearchParams = {
+  fuzzy?: boolean
+  fuzzyLevel?: number
+  markMatchingVariants?: boolean
+  staged?: boolean
+  filter?: string[]
+  'filter.facets'?: string[]
+  'filter.query'?: string[]
+  facet?: string | string[]
+  sort?: string | string[]
+  limit?: number
+  offset?: number
+  withTotal?: boolean
+  priceCurrency?: string
+  priceCountry?: string
+  priceCustomerGroup?: string
+  priceChannel?: string
+  localeProjection?: string
+  storeProjection?: string
+  expand?: string | string[]
+  [key: string]: QueryParam
+}
+
+export class ProductProjectionSearch {
+  protected _storage: AbstractStorage
+
+  constructor(storage: AbstractStorage) {
+    this._storage = storage
+  }
+
+  search(
+    projectKey: string,
+    params: ProductProjectionSearchParams
+  ): ProductProjectionPagedSearchResponse {
+    // Get a copy of all the products in the storage engine. We need a copy
+    // since we will be modifying the data.
+    let resources = this._storage
+      .all(projectKey, 'product')
+      .map(r => JSON.parse(JSON.stringify(r)))
+
+    let markMatchingVariant = params.markMatchingVariants ?? false
+
+    // Apply the priceSelector
+    applyPriceSelector(resources, {
+      country: params.priceCountry,
+      channel: params.priceChannel,
+      customerGroup: params.priceCustomerGroup,
+      currency: params.priceCurrency,
+    })
+
+    // Apply filters pre facetting
+    if (params.filter) {
+      try {
+        const filters = params.filter.map(f =>
+          parseFilterExpression(f, params.staged ?? false)
+        )
+
+        // Filters can modify the output. So clone the resources first.
+        resources = resources.filter(resource =>
+          filters.every(f => f(resource, markMatchingVariant))
+        )
+      } catch (err) {
+        throw new CommercetoolsError<InvalidInputError>(
+          {
+            code: 'InvalidInput',
+            message: (err as any).message,
+          },
+          400
+        )
+      }
+    }
+
+    // TODO: Calculate facets
+    const facets = this.getFacets(params, resources)
+
+    // Apply filters post facetting
+    if (params['filter.query']) {
+      try {
+        const filters = params['filter.query'].map(f =>
+          parseFilterExpression(f, params.staged ?? false)
+        )
+        resources = resources.filter(resource =>
+          filters.every(f => f(resource, markMatchingVariant))
+        )
+      } catch (err) {
+        throw new CommercetoolsError<InvalidInputError>(
+          {
+            code: 'InvalidInput',
+            message: (err as any).message,
+          },
+          400
+        )
+      }
+    }
+
+    // Get the total before slicing the array
+    const totalResources = resources.length
+
+    // Apply offset, limit
+    const offset = params.offset || 0
+    const limit = params.limit || 20
+    resources = resources.slice(offset, offset + limit)
+
+    // Expand the resources
+    if (params.expand !== undefined) {
+      resources = resources.map(resource => {
+        return this._storage.expand(projectKey, resource, params.expand)
+      })
+    }
+
+    return {
+      count: totalResources,
+      total: resources.length,
+      offset: offset,
+      limit: limit,
+      results: resources.map(this.transform),
+      facets: facets,
+    }
+  }
+
+  transform(product: Product): ProductProjection {
+    const obj = product.masterData.current
+    return {
+      id: product.id,
+      createdAt: product.createdAt,
+      lastModifiedAt: product.lastModifiedAt,
+      version: product.version,
+      name: obj.name,
+      slug: obj.slug,
+      categories: obj.categories,
+      masterVariant: obj.masterVariant,
+      variants: obj.variants,
+      productType: product.productType,
+    }
+  }
+
+  getFacets(
+    params: ProductProjectionSearchParams,
+    products: Product[]
+  ): FacetResults {
+    if (!params.facet) return {}
+    const staged = false
+    const result: FacetResults = {}
+
+    for (const facet of params.facet) {
+      const expression = generateFacetFunc(facet)
+
+      // Term Facet
+      if (expression.type === 'TermExpression') {
+        result[facet] = this.termFacet(expression.source, products, staged)
+      }
+
+      // Range Facet
+      if (expression.type === 'RangeExpression') {
+        result[expression.source] = this.rangeFacet(
+          expression.source,
+          expression.children,
+          products,
+          staged
+        )
+      }
+
+      // FilteredFacet
+      if (expression.type === 'FilterExpression') {
+        result[expression.source] = this.filterFacet(
+          expression.source,
+          expression.children,
+          products,
+          staged
+        )
+      }
+    }
+
+    return result
+  }
+
+  /**
+   * TODO: This implemention needs the following additional features:
+   *  - counting products
+   *  - correct dataType
+   */
+  termFacet(
+    facet: string,
+    products: Product[],
+    staged: boolean
+  ): TermFacetResult {
+    const result: Writable<TermFacetResult> = {
+      type: 'terms',
+      dataType: 'text',
+      missing: 0,
+      total: 0,
+      other: 0,
+      terms: [],
+    }
+    const terms: Record<any, number> = {}
+
+    if (facet.startsWith('variants.')) {
+      products.forEach(p => {
+        const variants = getVariants(p, staged)
+        variants.forEach(v => {
+          result.total++
+
+          let value = resolveVariantValue(v, facet)
+          if (value === undefined) {
+            result.missing++
+          } else {
+            if (typeof value === 'number') {
+              value = Number(value).toFixed(1)
+            }
+            terms[value] = value in terms ? terms[value] + 1 : 1
+          }
+        })
+      })
+    } else {
+      products.forEach(p => {
+        const value = nestedLookup(p, facet)
+        result.total++
+        if (value === undefined) {
+          result.missing++
+        } else {
+          terms[value] = value in terms ? terms[value] + 1 : 1
+        }
+      })
+    }
+    for (const term in terms) {
+      result.terms.push({
+        term: term as any,
+        count: terms[term],
+      })
+    }
+    return result
+  }
+
+  filterFacet(
+    source: string,
+    filters: FilterExpression[] | undefined,
+    products: Product[],
+    staged: boolean
+  ): FilteredFacetResult {
+    let count = 0
+    if (source.startsWith('variants.')) {
+      for (const p of products) {
+        for (const v of getVariants(p, staged)) {
+          const val = resolveVariantValue(v, source)
+          if (filters?.some(f => f.match(val))) {
+            count++
+          }
+        }
+      }
+    } else {
+      throw new Error('not supported')
+    }
+
+    return {
+      type: 'filter',
+      count: count,
+    }
+  }
+
+  rangeFacet(
+    source: string,
+    ranges: RangeExpression[] | undefined,
+    products: Product[],
+    staged: boolean
+  ): RangeFacetResult {
+    const counts =
+      ranges?.map(range => {
+        if (source.startsWith('variants.')) {
+          const values = []
+          for (const p of products) {
+            for (const v of getVariants(p, staged)) {
+              const val = resolveVariantValue(v, source)
+              if (val === undefined) {
+                continue
+              }
+
+              if (range.match(val)) {
+                values.push(val)
+              }
+            }
+          }
+
+          const numValues = values.length
+          return {
+            type: 'double',
+            from: range.start || 0,
+            fromStr: range.start !== null ? Number(range.start).toFixed(1) : '',
+            to: range.stop || 0,
+            toStr: range.stop !== null ? Number(range.stop).toFixed(1) : '',
+            count: numValues,
+            // totalCount: 0,
+            total: values.reduce((a, b) => a + b, 0),
+            min: numValues > 0 ? Math.min(...values) : 0,
+            max: numValues > 0 ? Math.max(...values) : 0,
+            mean: numValues > 0 ? mean(values) : 0,
+          }
+        } else {
+          throw new Error('not supported')
+        }
+      }) || []
+    const data: RangeFacetResult = {
+      type: 'range',
+      // @ts-ignore
+      dataType: 'number',
+      ranges: counts,
+    }
+    return data
+  }
+}
+
+const mean = (arr: number[]) => {
+  let total = 0
+  for (let i = 0; i < arr.length; i++) {
+    total += arr[i]
+  }
+  return total / arr.length
+}

package/src/projectAPI.ts

@@ -1,7 +1,14 @@
+import { ReferenceTypeId } from '@commercetools/platform-sdk'
 import { GetParams } from 'repositories/abstract'
 import { getBaseResourceProperties } from './helpers'
 import { AbstractStorage } from './storage'
-import { RepositoryMap, ResourceMap, Services } from './types'
+import {
+  RepositoryMap,
+  RepositoryTypes,
+  ResourceMap,
+  Services,
+  ServiceTypes,
+} from './types'
 
 export class ProjectAPI {
   private projectKey: string
@@ -18,18 +25,10 @@ export class ProjectAPI {
     this._services = services
   }
 
-  add<ReferenceTypeId extends keyof ResourceMap>(
-    typeId: ReferenceTypeId | 'custom-object',
-    resource: ResourceMap[ReferenceTypeId]
-  ) {
-    //@ts-ignore
-    if (typeId === 'custom-object') typeId = 'key-value-document'
-
-    const parsedTypeId = typeId as ReferenceTypeId
-
-    const service = this._services[parsedTypeId]
+  add(typeId: ReferenceTypeId, resource: ResourceMap[ReferenceTypeId]) {
+    const service = this._services[typeId]
     if (service) {
-      this._storage.add(this.projectKey, parsedTypeId, {
+      this._storage.add(this.projectKey, typeId as ReferenceTypeId, {
         ...getBaseResourceProperties(),
         ...resource,
       })
@@ -38,26 +37,26 @@ export class ProjectAPI {
     }
   }
 
-  get<ReferenceTypeId extends keyof ResourceMap>(
-    typeId: ReferenceTypeId,
+  get<RT extends RepositoryTypes>(
+    typeId: RT,
     id: string,
     params?: GetParams
-  ): ResourceMap[ReferenceTypeId] {
+  ): ResourceMap[RT] {
     return this._storage.get(
       this.projectKey,
       typeId,
       id,
       params
-    ) as ResourceMap[ReferenceTypeId]
+    ) as ResourceMap[RT]
   }
 
   // TODO: Not sure if we want to expose this...
-  getRepository<ReferenceTypeId extends keyof RepositoryMap>(
-    typeId: ReferenceTypeId
-  ): RepositoryMap[ReferenceTypeId] {
+  getRepository<RT extends keyof RepositoryMap>(
+    typeId: ServiceTypes
+  ): RepositoryMap[RT] {
     const service = this._services[typeId]
     if (service !== undefined) {
-      return service.repository as RepositoryMap[ReferenceTypeId]
+      return service.repository as RepositoryMap[RT]
     }
     throw new Error('No such repository')
   }

package/src/repositories/category.ts

@@ -6,6 +6,8 @@ import {
   CategoryDraft,
   CategorySetAssetDescriptionAction,
   CategorySetAssetSourcesAction,
+  CategorySetCustomFieldAction,
+  CategorySetCustomTypeAction,
   CategorySetDescriptionAction,
   CategorySetKeyAction,
   CategorySetMetaDescriptionAction,
@@ -51,6 +53,11 @@ export class CategoryRepository extends AbstractResourceRepository {
             ),
           }
         }) || [],
+      custom: createCustomFields(
+        draft.custom,
+        context.projectKey,
+        this._storage
+      ),
     }
     this.save(context, resource)
     return resource
@@ -141,5 +148,34 @@ export class CategoryRepository extends AbstractResourceRepository {
     ) => {
       resource.metaTitle = metaTitle
     },
+    setCustomType: (
+      context: RepositoryContext,
+      resource: Writable<Category>,
+      { type, fields }: CategorySetCustomTypeAction
+    ) => {
+      if (type) {
+        resource.custom = createCustomFields(
+          { type, fields },
+          context.projectKey,
+          this._storage
+        )
+      } else {
+        resource.custom = undefined
+      }
+    },
+    setCustomField: (
+      context: RepositoryContext,
+      resource: Writable<Category>,
+      { name, value }: CategorySetCustomFieldAction
+    ) => {
+      if (!resource.custom) {
+        return
+      }
+      if (value === null) {
+        delete resource.custom.fields[name]
+      } else {
+        resource.custom.fields[name] = value
+      }
+    },
   }
 }