@labdigital/commercetools-mock 0.7.1 → 0.9.1

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.7.1",
+  "version": "0.9.1",
   "license": "MIT",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -7,6 +7,12 @@
     "dist",
     "src"
   ],
+  "exports": {
+    ".": {
+      "require": "./dist/index.js",
+      "import": "./dist/index.mjs"
+    }
+  },
   "engines": {
     "node": ">=14"
   },
@@ -50,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",
@@ -69,7 +73,6 @@
   },
   "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"

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/predicateParser.test.ts

@@ -8,10 +8,12 @@ describe('Predicate filter', () => {
     arrayProperty: ['foo', 'bar', 'nar'],
     notDefined: undefined,
     emptyArrayProperty: [],
+    booleanProperty: true,
     nested: {
       numberProperty: 1234,
       objectProperty: {
         stringProperty: 'foobar',
+        booleanProperty: true,
       },
     },
 
@@ -31,6 +33,13 @@ describe('Predicate filter', () => {
     expect(match(`stringProperty=:val`, { val: 'foobar' })).toBeTruthy()
   })
 
+  test('booleanProperty = true', async () => {
+    expect(match(`booleanProperty != true`)).toBeFalsy()
+    expect(match(`booleanProperty = true`)).toBeTruthy()
+
+    expect(match(`booleanProperty=:val`, { val: true })).toBeTruthy()
+  })
+
   test('stringProperty matches ignore case "foobar"', async () => {
     expect(match(`stringProperty="FOObar"`)).toBeFalsy()
     expect(match(`stringProperty matches ignore case "FOObar"`)).toBeTruthy()
@@ -168,6 +177,13 @@ describe('Predicate filter', () => {
     ).toBeTruthy()
   })
 
+  test('nested attribute access', async () => {
+    expect(match(`nested(objectProperty(booleanProperty != true))`)).toBeFalsy()
+    expect(
+      match(`nested(objectProperty(booleanProperty != false))`)
+    ).toBeTruthy()
+  })
+
   test('lexer confusion', async () => {
     expect(() => match(`orSomething="foobar"`)).toThrow(PredicateError)
     expect(() => match(`orSomething="foobar"`)).toThrow(

package/src/lib/predicateParser.ts

@@ -124,6 +124,7 @@ const getLexer = (value: string) => {
     .token('FLOAT', /\d+\.\d+/)
     .token('INT', /\d+/)
     .token('VARIABLE', /:([-_A-Za-z0-9]+)/)
+    .token('BOOLEAN', /(true|false)/)
     .token('IDENTIFIER', /[-_A-Za-z0-9]+/)
     .token('STRING', /"((?:\\.|[^"\\])*)"/)
     .token('STRING', /'((?:\\.|[^'\\])*)'/)
@@ -159,6 +160,13 @@ const generateMatchFunc = (predicate: string): MatchFunc => {
         pos: t.token.strpos(),
       } as Symbol
     })
+    .nud('BOOLEAN', 1, t => {
+      return {
+        type: 'boolean',
+        value: t.token.match === 'true' ? true : false,
+        pos: t.token.strpos(),
+      } as Symbol
+    })
     .nud('VARIABLE', 100, t => {
       return {
         type: 'var',
@@ -254,7 +262,6 @@ const generateMatchFunc = (predicate: string): MatchFunc => {
     .led('!=', 20, ({ left, bp }) => {
       const expr = parser.parse({ terminals: [bp - 1] })
       validateSymbol(expr)
-
       return (obj: any, vars: VariableMap) => {
         return resolveValue(obj, left) !== resolveSymbol(expr, vars)
       }

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