@labdigital/commercetools-mock 0.7.0 → 0.9.0

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.7.0",
+  "version": "0.9.0",
   "license": "MIT",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -7,16 +7,15 @@
     "dist",
     "src"
   ],
+  "exports": {
+    ".": {
+      "require": "./dist/index.js",
+      "import": "./dist/index.mjs"
+    }
+  },
   "engines": {
     "node": ">=14"
   },
-  "scripts": {
-    "start": "nodemon --watch src --exec 'node -r esbuild-register' src/server.ts",
-    "generate": "node -r esbuild-register generate-validation.ts",
-    "build": "tsup",
-    "test": "jest test --coverage",
-    "lint": "eslint"
-  },
   "prettier": {
     "printWidth": 80,
     "semi": false,
@@ -57,8 +56,6 @@
   },
   "dependencies": {
     "@types/lodash": "^4.14.182",
-    "ajv": "^8.8.2",
-    "ajv-formats": "^2.1.1",
     "basic-auth": "^2.0.1",
     "body-parser": "^1.20.0",
     "deep-equal": "^2.0.5",
@@ -73,5 +70,11 @@
   },
   "peerDependencies": {
     "@commercetools/platform-sdk": "^2.4.1"
+  },
+  "scripts": {
+    "start": "nodemon --watch src --exec 'node -r esbuild-register' src/server.ts",
+    "build": "tsup",
+    "test": "jest test --coverage",
+    "lint": "eslint"
   }
-}
+}

package/src/helpers.ts

@@ -11,6 +11,30 @@ export const getBaseResourceProperties = () => {
   }
 }
 
+/**
+ * Do a nested lookup by using a path. For example `foo.bar.value` will
+ * return obj['foo']['bar']['value']
+ */
+export const nestedLookup = (obj: any, path: string): any => {
+  if (!path || path === '') {
+    return obj
+  }
+
+  const parts = path.split('.')
+  let val = obj
+
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i]
+    if (val == undefined) {
+      return undefined
+    }
+
+    val = val[part]
+  }
+
+  return val
+}
+
 export const QueryParamsAsArray = (
   input: string | ParsedQs | string[] | ParsedQs[] | undefined
 ): string[] => {

package/src/lib/projectionSearchFilter.test.ts

@@ -127,6 +127,12 @@ describe('Search filter', () => {
     ).toBeTruthy()
   })
 
+  test('by price range - or', async () => {
+    expect(
+      match(`variants.price.centAmount:range (2 TO 1500 ), (1500 TO 3000), (3000 TO 6000)`).isMatch
+    ).toBeTruthy()
+  })
+
   test('by scopedPrice range', async () => {
     let result
     let products: Product[]

package/src/lib/projectionSearchFilter.ts

@@ -5,6 +5,7 @@
 import { Product, ProductVariant } from '@commercetools/platform-sdk'
 import perplex from 'perplex'
 import Parser from 'pratt'
+import { nestedLookup } from '../helpers'
 import { Writable } from '../types'
 
 type MatchFunc = (target: any) => boolean
@@ -14,6 +15,43 @@ type ProductFilter = (
   markMatchingVariants: boolean
 ) => boolean
 
+type Symbol = {
+  type: 'Symbol'
+  kind: 'int' | 'string' | 'any'
+  value: any
+}
+
+type RangeExpressionSet = {
+  source: string
+  type: 'RangeExpression'
+  children?: RangeExpression[]
+}
+
+type FilterExpressionSet = {
+  source: string
+  type: 'FilterExpression'
+  children?: FilterExpression[]
+}
+
+type TermExpressionSet = {
+  source: string
+  type: 'TermExpression'
+}
+
+type ExpressionSet = RangeExpressionSet | FilterExpressionSet | TermExpressionSet
+
+export type RangeExpression = {
+  type: 'RangeExpression'
+  start?: number
+  stop?: number
+  match: (obj: any) => boolean
+}
+
+export type FilterExpression = {
+  type: 'FilterExpression'
+  match: (obj: any) => boolean
+}
+
 /**
  * Returns a function (ProductFilter).
  * NOTE: The filter can alter the resources in-place (FIXME)
@@ -53,7 +91,7 @@ const getLexer = (value: string) => {
     .token('WS', /\s+/, true) // skip
 }
 
-const generateMatchFunc = (filter: string): MatchFunc => {
+const parseFilter = (filter: string): ExpressionSet => {
   const lexer = getLexer(filter)
   const parser = new Parser(lexer)
     .builder()
@@ -61,42 +99,81 @@ const generateMatchFunc = (filter: string): MatchFunc => {
       return t.token.match
     })
     .led(':', 100, ({ left, bp }) => {
-      const expr = parser.parse({ terminals: [bp - 1] })
+      let parsed: any = parser.parse({ terminals: [bp - 1] })
+      let expressions: RangeExpression[] | FilterExpression[] | Symbol[]
+      expressions = !Array.isArray(parsed) ? [parsed] : parsed
 
-      if (Array.isArray(expr)) {
-        return (obj: any): boolean => {
-          return expr.includes(obj)
-        }
+      // Make sure we only have one type of expression (cannot mix)
+      const unique = new Set(expressions.map(expr => expr.type))
+      if (unique.size > 1) {
+        throw new Error('Invalid expression')
       }
-      if (typeof expr === 'function') {
-        return (obj: any): boolean => {
-          return expr(obj)
+
+      // Convert plain symbols to a filter expression. For example
+      // variants.attribute.foobar:4 where 4 is a Symbol should result
+      // in a comparison
+      if (expressions.some(expr => expr.type == 'Symbol')) {
+        return {
+          source: left as string,
+          type: 'FilterExpression',
+          children: expressions.map((e): FilterExpression => {
+            if (e.type != 'Symbol') {
+              throw new Error('Invalid expression')
+            }
+
+            return {
+              type: 'FilterExpression',
+              match: (obj: any): boolean => {
+                return obj === e.value
+              },
+            }
+          })
         }
       }
-      return (obj: any): boolean => {
-        return obj === expr
+
+      return {
+        source: left,
+        type: expressions[0].type,
+        children: expressions,
       }
     })
     .nud('STRING', 20, t => {
-      // @ts-ignore
-      return t.token.groups[1]
+      return {
+        type: 'Symbol',
+        kind: 'string',
+        // @ts-ignore
+        value: t.token.groups[1],
+      } as Symbol
     })
     .nud('INT', 5, t => {
-      // @ts-ignore
-      return parseInt(t.token.match, 10)
+      return {
+        type: 'Symbol',
+        kind: 'int',
+        value: parseInt(t.token.match, 10),
+      } as Symbol
     })
     .nud('STAR', 5, t => {
-      return null
+      return {
+        type: 'Symbol',
+        kind: 'any',
+        value: null,
+      }
     })
     .nud('EXISTS', 10, ({ bp }) => {
-      return (val: any) => {
-        return val !== undefined
-      }
+      return {
+        type: 'FilterExpression',
+        match: (obj: any): boolean => {
+          return obj !== undefined
+        },
+      } as FilterExpression
     })
     .nud('MISSING', 10, ({ bp }) => {
-      return (val: any) => {
-        return val === undefined
-      }
+      return {
+        type: 'FilterExpression',
+        match: (obj: any): boolean => {
+          return obj === undefined
+        },
+      } as FilterExpression
     })
     .led('COMMA', 200, ({ left, token, bp }) => {
       const expr: any = parser.parse({ terminals: [bp - 1] })
@@ -106,52 +183,92 @@ const generateMatchFunc = (filter: string): MatchFunc => {
         return [left, expr]
       }
     })
+    .nud('(', 100, t => {
+      const expr: any = parser.parse({ terminals: [')'] })
+      lexer.expect(')')
+      return expr
+    })
     .bp(')', 0)
     .led('TO', 20, ({ left, bp }) => {
       const expr: any = parser.parse({ terminals: [bp - 1] })
-      return [left, expr]
+      return {
+        start: left.value,
+        stop: expr.value,
+      }
     })
     .nud('RANGE', 20, ({ bp }) => {
-      lexer.next() // Skip over opening parthensis
-      const [start, stop] = parser.parse()
-      console.log(start, stop)
-      if (start !== null && stop !== null ) {
-        return (obj: any): boolean => {
-          return obj >= start && obj <= stop
-        }
-      }
-      else if (start === null && stop !== null) {
-        return (obj: any): boolean => {
-          return obj <= stop
-        }
+      let ranges: any = parser.parse()
+
+      // If multiple ranges are defined we receive an array of ranges. So let's
+      // make sure we always have an array
+      if (!Array.isArray(ranges)) {
+        ranges = [ranges]
       }
-      else if (start !== null && stop === null) {
-        return (obj: any): boolean => {
-          return obj >= start
-        }
-      } else {
-        return (obj: any): boolean => {
-          return true
+
+      // Return a list of functions which matches the ranges. These functions
+      // are processed as an OR clause
+      return ranges.map((range: any) => {
+        let func = undefined
+
+        if (range.start !== null && range.stop !== null) {
+          func = (obj: any): boolean => {
+            return obj >= range.start && obj <= range.stop
+          }
+        } else if (range.start === null && range.stop !== null) {
+          func = (obj: any): boolean => {
+            return obj <= range.stop
+          }
+        } else if (range.start !== null && range.stop === null) {
+          func = (obj: any): boolean => {
+            return obj >= range.start
+          }
+        } else {
+          func = (obj: any): boolean => {
+            return true
+          }
         }
 
-      }
+        return {
+          type: 'RangeExpression',
+          start: range.start,
+          stop: range.stop,
+          match: func,
+        } as RangeExpression
+      })
     })
     .build()
 
-  const result = parser.parse()
+  return parser.parse()
+}
 
-  if (typeof result !== 'function') {
+const generateMatchFunc = (filter: string) => {
+  const result = parseFilter(filter)
+  if (!result) {
     const lines = filter.split('\n')
     const column = lines[lines.length - 1].length
     throw new Error(`Syntax error while parsing '${filter}'.`)
   }
-  return result
+  if (result.type == 'TermExpression') {
+    throw new Error(`Syntax error while parsing '${filter}'.`)
+  }
+
+  return (obj: any) => {
+    if (!result.children) return false
+    return result.children.some(c => c.match(obj))
+  }
 }
 
-const filterProduct = (
-  source: string,
-  exprFunc: MatchFunc
-): ProductFilter => {
+export const generateFacetFunc = (filter: string): ExpressionSet => {
+  if (!filter.includes(':')) {
+    return {
+      source: filter,
+      type: 'TermExpression',
+    }
+  }
+  return parseFilter(filter)
+}
+
+const filterProduct = (source: string, exprFunc: MatchFunc): ProductFilter => {
   return (p: Product, markMatchingVariants: boolean): boolean => {
     const value = nestedLookup(p, source)
     return exprFunc(value)
@@ -172,13 +289,12 @@ const filterVariants = (
       const value = resolveVariantValue(variant, path)
 
       if (exprFunc(value)) {
-
         // If markMatchingVariants parameter is true those ProductVariants that
         // match the search query have the additional field isMatchingVariant
         // set to true. For the other variants in the same product projection
         // this field is set to false.
         if (markMatchingVariants) {
-          variants.forEach(v => v.isMatchingVariant = false)
+          variants.forEach(v => (v.isMatchingVariant = false))
           variant.isMatchingVariant = true
         }
         return true
@@ -189,10 +305,13 @@ const filterVariants = (
   }
 }
 
-const resolveVariantValue = (obj: ProductVariant, path: string): any => {
+export const resolveVariantValue = (obj: ProductVariant, path: string): any => {
   if (path === undefined) {
     return obj
   }
+  if (path.startsWith('variants.')) {
+    path = path.substring(path.indexOf('.') + 1)
+  }
 
   if (path.startsWith('attributes.')) {
     const [, attrName, ...rest] = path.split('.')
@@ -216,27 +335,7 @@ const resolveVariantValue = (obj: ProductVariant, path: string): any => {
   return nestedLookup(obj, path)
 }
 
-const nestedLookup = (obj: any, path: string): any => {
-  if (!path || path === '') {
-    return obj
-  }
-
-  const parts = path.split('.')
-  let val = obj
-
-  for (let i = 0; i < parts.length; i++) {
-    const part = parts[i]
-    if (val == undefined) {
-      return undefined
-    }
-
-    val = val[part]
-  }
-
-  return val
-}
-
-const getVariants = (p: Product, staged: boolean): ProductVariant[] => {
+export const getVariants = (p: Product, staged: boolean): ProductVariant[] => {
   return [
     staged
       ? p.masterData.staged?.masterVariant

package/src/product-projection-search.ts

@@ -4,9 +4,25 @@ import {
   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 { parseFilterExpression } from './lib/projectionSearchFilter'
+import {
+  FilterExpression,
+  generateFacetFunc,
+  getVariants,
+  parseFilterExpression,
+  RangeExpression,
+  resolveVariantValue,
+} from './lib/projectionSearchFilter'
 import { applyPriceSelector } from './priceSelector'
 import { AbstractStorage } from './storage'
 
@@ -68,10 +84,9 @@ export class ProductProjectionSearch {
         )
 
         // Filters can modify the output. So clone the resources first.
-        resources = resources
-          .filter(resource =>
-            filters.every(f => f(resource, markMatchingVariant))
-          )
+        resources = resources.filter(resource =>
+          filters.every(f => f(resource, markMatchingVariant))
+        )
       } catch (err) {
         throw new CommercetoolsError<InvalidInputError>(
           {
@@ -84,6 +99,7 @@ export class ProductProjectionSearch {
     }
 
     // TODO: Calculate facets
+    const facets = this.getFacets(params, resources)
 
     // Apply filters post facetting
     if (params['filter.query']) {
@@ -91,10 +107,10 @@ export class ProductProjectionSearch {
         const filters = params['filter.query'].map(f =>
           parseFilterExpression(f, params.staged ?? false)
         )
-        resources = resources
-          .filter(resource =>
-            filters.every(f => f(resource, markMatchingVariant))
-          )
+        
+        resources = resources.filter(resource =>
+          filters.every(f => f(resource, markMatchingVariant))
+        )
       } catch (err) {
         throw new CommercetoolsError<InvalidInputError>(
           {
@@ -127,7 +143,7 @@ export class ProductProjectionSearch {
       offset: offset,
       limit: limit,
       results: resources.map(this.transform),
-      facets: {},
+      facets: facets,
     }
   }
 
@@ -139,6 +155,9 @@ export class ProductProjectionSearch {
       lastModifiedAt: product.lastModifiedAt,
       version: product.version,
       name: obj.name,
+      key: product.key,
+      description: obj.description,
+      metaDescription: obj.metaDescription,
       slug: obj.slug,
       categories: obj.categories,
       masterVariant: obj.masterVariant,
@@ -146,4 +165,185 @@ export class ProductProjectionSearch {
       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
 }