@labdigital/commercetools-mock 0.9.0 → 0.10.0

package/src/lib/predicateParser.ts

@@ -31,7 +31,7 @@ export const matchesPredicate = (
   }
 
   if (Array.isArray(predicate)) {
-    return predicate.every(item => {
+    return predicate.every((item) => {
       const func = generateMatchFunc(item)
       return func(target, variables || {})
     })
@@ -45,22 +45,21 @@ export const parseQueryExpression = (
   predicate: string | string[]
 ): MatchFunc => {
   if (Array.isArray(predicate)) {
-    const callbacks = predicate.map(item => generateMatchFunc(item))
-    return (target: any, variables: VariableMap) => {
-      return callbacks.every(callback => callback(target, variables))
-    }
+    const callbacks = predicate.map((item) => generateMatchFunc(item))
+    return (target: any, variables: VariableMap) =>
+      callbacks.every((callback) => callback(target, variables))
   } else {
     return generateMatchFunc(predicate)
   }
 }
 
-type Symbol = {
+type TypeSymbol = {
   type: 'var' | 'boolean' | 'string' | 'float' | 'int' | 'identifier'
   value: any
   pos?: ITokenPosition
 }
 
-const validateSymbol = (val: Symbol) => {
+const validateSymbol = (val: TypeSymbol) => {
   if (!val.type) {
     throw new PredicateError('Internal error')
   }
@@ -76,7 +75,7 @@ const validateSymbol = (val: Symbol) => {
   }
 }
 
-const resolveSymbol = (val: Symbol, vars: VariableMap): any => {
+const resolveSymbol = (val: TypeSymbol, vars: VariableMap): any => {
   if (val.type === 'var') {
     if (!(val.value in vars)) {
       throw new PredicateError(`Missing parameter value for ${val.value}`)
@@ -87,7 +86,7 @@ const resolveSymbol = (val: Symbol, vars: VariableMap): any => {
   return val.value
 }
 
-const resolveValue = (obj: any, val: Symbol): any => {
+const resolveValue = (obj: any, val: TypeSymbol): any => {
   if (val.type !== 'identifier') {
     throw new PredicateError('Internal error')
   }
@@ -95,8 +94,8 @@ const resolveValue = (obj: any, val: Symbol): any => {
   if (!(val.value in obj)) {
     if (Array.isArray(obj)) {
       return Object.values(obj)
-        .filter(v => val.value in v)
-        .map(v => v[val.value])
+        .filter((v) => val.value in v)
+        .map((v) => v[val.value])
     }
     throw new PredicateError(`The field '${val.value}' does not exist.`)
   }
@@ -104,8 +103,8 @@ const resolveValue = (obj: any, val: Symbol): any => {
   return obj[val.value]
 }
 
-const getLexer = (value: string) => {
-  return new perplex(value)
+const getLexer = (value: string) =>
+  new perplex(value)
 
     .token('AND', /and(?![-_a-z0-9]+)/i)
     .token('OR', /or(?![-_a-z0-9]+)/i)
@@ -124,6 +123,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', /'((?:\\.|[^'\\])*)'/)
@@ -139,7 +139,6 @@ const getLexer = (value: string) => {
     .token('=', '=')
     .token('"', '"')
     .token('WS', /\s+/, true) // skip
-}
 
 /**
  * This function converts a query expression in to a callable which returns a
@@ -152,67 +151,82 @@ const generateMatchFunc = (predicate: string): MatchFunc => {
   const lexer = getLexer(predicate)
   const parser = new Parser(lexer)
     .builder()
-    .nud('IDENTIFIER', 100, t => {
-      return {
-        type: 'identifier',
-        value: t.token.match,
-        pos: t.token.strpos(),
-      } as Symbol
-    })
-    .nud('VARIABLE', 100, t => {
-      return {
-        type: 'var',
-        // @ts-ignore
-        value: t.token.groups[1],
-        pos: t.token.strpos(),
-      } as Symbol
-    })
-    .nud('STRING', 100, t => {
-      return {
-        type: 'string',
-        // @ts-ignore
-        value: t.token.groups[1],
-        pos: t.token.strpos(),
-      } as Symbol
-    })
-    .nud('INT', 1, t => {
-      return {
-        type: 'int',
-        value: parseInt(t.token.match, 10),
-        pos: t.token.strpos(),
-      } as Symbol
-    })
-    .nud('FLOAT', 1, t => {
-      return {
-        type: 'float',
-        value: parseFloat(t.token.match),
-        pos: t.token.strpos(),
-      } as Symbol
-    })
+    .nud(
+      'IDENTIFIER',
+      100,
+      (t) =>
+        ({
+          type: 'identifier',
+          value: t.token.match,
+          pos: t.token.strpos(),
+        } as TypeSymbol)
+    )
+    .nud(
+      'BOOLEAN',
+      1,
+      (t) =>
+        ({
+          type: 'boolean',
+          value: t.token.match === 'true' ? true : false,
+          pos: t.token.strpos(),
+        } as TypeSymbol)
+    )
+    .nud(
+      'VARIABLE',
+      100,
+      (t) =>
+        ({
+          type: 'var',
+          // @ts-ignore
+          value: t.token.groups[1],
+          pos: t.token.strpos(),
+        } as TypeSymbol)
+    )
+    .nud(
+      'STRING',
+      100,
+      (t) =>
+        ({
+          type: 'string',
+          // @ts-ignore
+          value: t.token.groups[1],
+          pos: t.token.strpos(),
+        } as TypeSymbol)
+    )
+    .nud(
+      'INT',
+      1,
+      (t) =>
+        ({
+          type: 'int',
+          value: parseInt(t.token.match, 10),
+          pos: t.token.strpos(),
+        } as TypeSymbol)
+    )
+    .nud(
+      'FLOAT',
+      1,
+      (t) =>
+        ({
+          type: 'float',
+          value: parseFloat(t.token.match),
+          pos: t.token.strpos(),
+        } as TypeSymbol)
+    )
     .nud('NOT', 100, ({ bp }) => {
       const expr = parser.parse({ terminals: [bp - 1] })
-      return (obj: any) => {
-        return !expr(obj)
-      }
-    })
-    .nud('EMPTY', 10, ({ bp }) => {
-      return 'empty'
-    })
-    .nud('DEFINED', 10, ({ bp }) => {
-      return 'defined'
+      return (obj: any) => !expr(obj)
     })
+    .nud('EMPTY', 10, ({ bp }) => 'empty')
+    .nud('DEFINED', 10, ({ bp }) => 'defined')
 
     .led('AND', 5, ({ left, bp }) => {
       const expr = parser.parse({ terminals: [bp - 1] })
-      return (obj: any) => {
-        return left(obj) && expr(obj)
-      }
+      return (obj: any) => left(obj) && expr(obj)
     })
     .led('OR', 5, ({ left, token, bp }) => {
       const expr = parser.parse({ terminals: [bp - 1] })
-      return (obj: any, vars: object) => {
-        return left(obj, vars) || expr(obj, vars)
-      }
+      return (obj: any, vars: object) => left(obj, vars) || expr(obj, vars)
     })
     .led('COMMA', 1, ({ left, token, bp }) => {
       const expr: any = parser.parse({ terminals: [bp - 1] })
@@ -222,7 +236,7 @@ const generateMatchFunc = (predicate: string): MatchFunc => {
         return [left, expr]
       }
     })
-    .nud('(', 100, t => {
+    .nud('(', 100, (t) => {
       const expr: any = parser.parse({ terminals: [')'] })
       return expr
     })
@@ -246,7 +260,7 @@ const generateMatchFunc = (predicate: string): MatchFunc => {
         const resolvedValue = resolveValue(obj, left)
         const resolvedSymbol = resolveSymbol(expr, vars)
         if (Array.isArray(resolvedValue)) {
-          return !!resolvedValue.some(elem => elem === resolvedSymbol)
+          return !!resolvedValue.some((elem) => elem === resolvedSymbol)
         }
         return resolvedValue === resolvedSymbol
       }
@@ -254,42 +268,36 @@ 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)
-      }
+      return (obj: any, vars: VariableMap) =>
+        resolveValue(obj, left) !== resolveSymbol(expr, vars)
     })
     .led('>', 20, ({ left, bp }) => {
       const expr = parser.parse({ terminals: [bp - 1] })
       validateSymbol(expr)
 
-      return (obj: any, vars: object) => {
-        return resolveValue(obj, left) > resolveSymbol(expr, vars)
-      }
+      return (obj: any, vars: object) =>
+        resolveValue(obj, left) > resolveSymbol(expr, vars)
     })
     .led('>=', 20, ({ left, bp }) => {
       const expr = parser.parse({ terminals: [bp - 1] })
       validateSymbol(expr)
 
-      return (obj: any, vars: object) => {
-        return resolveValue(obj, left) >= resolveSymbol(expr, vars)
-      }
+      return (obj: any, vars: object) =>
+        resolveValue(obj, left) >= resolveSymbol(expr, vars)
     })
     .led('<', 20, ({ left, bp }) => {
       const expr = parser.parse({ terminals: [bp - 1] })
       validateSymbol(expr)
 
-      return (obj: any, vars: object) => {
-        return resolveValue(obj, left) < resolveSymbol(expr, vars)
-      }
+      return (obj: any, vars: object) =>
+        resolveValue(obj, left) < resolveSymbol(expr, vars)
     })
     .led('<=', 20, ({ left, bp }) => {
       const expr = parser.parse({ terminals: [bp - 1] })
       validateSymbol(expr)
 
-      return (obj: any, vars: object) => {
-        return resolveValue(obj, left) <= resolveSymbol(expr, vars)
-      }
+      return (obj: any, vars: object) =>
+        resolveValue(obj, left) <= resolveSymbol(expr, vars)
     })
     .led('IS', 20, ({ left, bp }) => {
       let invert = false
@@ -343,7 +351,7 @@ const generateMatchFunc = (predicate: string): MatchFunc => {
           symbols = [expr]
         }
 
-        const inValues = symbols.map((item: Symbol) =>
+        const inValues = symbols.map((item: TypeSymbol) =>
           resolveSymbol(item, vars)
         )
         return inValues.includes(resolveValue(obj, left))
@@ -412,7 +420,7 @@ const generateMatchFunc = (predicate: string): MatchFunc => {
           )
         }
 
-        const array = expr.map((item: Symbol) => resolveSymbol(item, vars))
+        const array = expr.map((item: TypeSymbol) => resolveSymbol(item, vars))
         if (keyword.type === 'ALL') {
           return array.every((item: any) => value.includes(item))
         } else {

package/src/lib/projectionSearchFilter.test.ts

@@ -1,9 +1,19 @@
-import { Product, ProductData } from '@commercetools/platform-sdk'
+import { ProductProjection } from '@commercetools/platform-sdk'
+import { cloneObject } from '../helpers'
 import { applyPriceSelector } from '../priceSelector'
 import { parseFilterExpression } from './projectionSearchFilter'
 
 describe('Search filter', () => {
-  const productData: ProductData = {
+  const exampleProduct: ProductProjection = {
+    id: '7401d82f-1378-47ba-996a-85beeb87ac87',
+    version: 2,
+    createdAt: '2022-07-22T10:02:40.851Z',
+    lastModifiedAt: '2022-07-22T10:02:44.427Z',
+    key: 'test-product',
+    productType: {
+      typeId: 'product-type',
+      id: 'b9b4b426-938b-4ccb-9f36-c6f933e8446e',
+    },
     name: {
       'nl-NL': 'test',
     },
@@ -47,27 +57,9 @@ describe('Search filter', () => {
     },
   }
 
-  const exampleProduct: Product = {
-    id: '7401d82f-1378-47ba-996a-85beeb87ac87',
-    version: 2,
-    createdAt: '2022-07-22T10:02:40.851Z',
-    lastModifiedAt: '2022-07-22T10:02:44.427Z',
-    key: 'test-product',
-    productType: {
-      typeId: 'product-type',
-      id: 'b9b4b426-938b-4ccb-9f36-c6f933e8446e',
-    },
-    masterData: {
-      current: productData,
-      staged: productData,
-      published: true,
-      hasStagedChanges: false,
-    },
-  }
-
-  const match = (pattern: string, product?: Product) => {
-    const matchFunc = parseFilterExpression(pattern, false)
-    const clone = JSON.parse(JSON.stringify(product ?? exampleProduct))
+  const match = (pattern: string, product?: ProductProjection) => {
+    const matchFunc = parseFilterExpression(pattern)
+    const clone = cloneObject(product ?? exampleProduct)
     return {
       isMatch: matchFunc(clone, false),
       product: clone,
@@ -81,7 +73,9 @@ describe('Search filter', () => {
   })
 
   test('by product type id', async () => {
-    expect(match(`productType.id:"b9b4b426-938b-4ccb-9f36-c6f933e8446e"`).isMatch).toBeTruthy()
+    expect(
+      match(`productType.id:"b9b4b426-938b-4ccb-9f36-c6f933e8446e"`).isMatch
+    ).toBeTruthy()
   })
 
   test('by SKU', async () => {
@@ -129,20 +123,22 @@ describe('Search filter', () => {
 
   test('by price range - or', async () => {
     expect(
-      match(`variants.price.centAmount:range (2 TO 1500 ), (1500 TO 3000), (3000 TO 6000)`).isMatch
+      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[]
+    let products: ProductProjection[]
 
     // No currency given
     result = match(`variants.scopedPrice.value.centAmount:range (1500 TO 2000)`)
     expect(result.isMatch).toBeFalsy()
 
     // Currency match
-    products = [JSON.parse(JSON.stringify(exampleProduct))]
+    products = [cloneObject(exampleProduct)]
     applyPriceSelector(products, { currency: 'EUR' })
 
     result = match(
@@ -151,18 +147,14 @@ describe('Search filter', () => {
     )
     expect(result.isMatch).toBeTruthy()
     expect(result.product).toMatchObject({
-      masterData: {
-        current: {
-          masterVariant: {
-            sku: 'MYSKU',
-            scopedPrice: { value: { centAmount: 1789 } },
-          },
-        },
+      masterVariant: {
+        sku: 'MYSKU',
+        scopedPrice: { value: { centAmount: 1789 } },
       },
     })
 
     // Currency mismatch
-    products = [JSON.parse(JSON.stringify(exampleProduct))]
+    products = [cloneObject(exampleProduct)]
     applyPriceSelector(products, { currency: 'USD' })
 
     result = match(
@@ -172,7 +164,7 @@ describe('Search filter', () => {
     expect(result.isMatch).toBeFalsy()
 
     // Price has no country so mismatch
-    products = [JSON.parse(JSON.stringify(exampleProduct))]
+    products = [cloneObject(exampleProduct)]
     applyPriceSelector(products, { currency: 'EUR', country: 'NL' })
     result = match(
       `variants.scopedPrice.value.centAmount:range (1500 TO 2000)`,