@labdigital/commercetools-mock 0.9.0 → 0.10.0

package/src/lib/projectionSearchFilter.ts

@@ -2,7 +2,7 @@
  * This module implements the commercetools product projection filter expression.
  */
 
-import { Product, ProductVariant } from '@commercetools/platform-sdk'
+import { ProductProjection, ProductVariant } from '@commercetools/platform-sdk'
 import perplex from 'perplex'
 import Parser from 'pratt'
 import { nestedLookup } from '../helpers'
@@ -10,12 +10,12 @@ import { Writable } from '../types'
 
 type MatchFunc = (target: any) => boolean
 
-type ProductFilter = (
-  p: Writable<Product>,
+type ProductProjectionFilter = (
+  p: Writable<ProductProjection>,
   markMatchingVariants: boolean
 ) => boolean
 
-type Symbol = {
+type TypeSymbol = {
   type: 'Symbol'
   kind: 'int' | 'string' | 'any'
   value: any
@@ -38,7 +38,10 @@ type TermExpressionSet = {
   type: 'TermExpression'
 }
 
-type ExpressionSet = RangeExpressionSet | FilterExpressionSet | TermExpressionSet
+type ExpressionSet =
+  | RangeExpressionSet
+  | FilterExpressionSet
+  | TermExpressionSet
 
 export type RangeExpression = {
   type: 'RangeExpression'
@@ -53,29 +56,28 @@ export type FilterExpression = {
 }
 
 /**
- * Returns a function (ProductFilter).
+ * Returns a function (ProductProjectionFilter).
  * NOTE: The filter can alter the resources in-place (FIXME)
  */
 export const parseFilterExpression = (
-  filter: string,
-  staged: boolean
-): ProductFilter => {
+  filter: string
+): ProductProjectionFilter => {
   const exprFunc = generateMatchFunc(filter)
   const [source] = filter.split(':', 1)
 
   if (source.startsWith('variants.')) {
-    return filterVariants(source, staged, exprFunc)
+    return filterVariants(source, exprFunc)
   }
   return filterProduct(source, exprFunc)
 }
 
-const getLexer = (value: string) => {
-  return new perplex(value)
+const getLexer = (value: string) =>
+  new perplex(value)
     .token('MISSING', /missing(?![-_a-z0-9]+)/i)
     .token('EXISTS', /exists(?![-_a-z0-9]+)/i)
     .token('RANGE', /range(?![-_a-z0-9]+)/i)
     .token('TO', /to(?![-_a-z0-9]+)/i)
-    .token('IDENTIFIER', /[-_\.a-z]+/i)
+    .token('IDENTIFIER', /[-_.a-z]+/i)
 
     .token('FLOAT', /\d+\.\d+/)
     .token('INT', /\d+/)
@@ -89,22 +91,18 @@ const getLexer = (value: string) => {
     .token(')', ')')
     .token('"', '"')
     .token('WS', /\s+/, true) // skip
-}
 
 const parseFilter = (filter: string): ExpressionSet => {
   const lexer = getLexer(filter)
   const parser = new Parser(lexer)
     .builder()
-    .nud('IDENTIFIER', 100, t => {
-      return t.token.match
-    })
+    .nud('IDENTIFIER', 100, (t) => t.token.match)
     .led(':', 100, ({ left, bp }) => {
-      let parsed: any = parser.parse({ terminals: [bp - 1] })
-      let expressions: RangeExpression[] | FilterExpression[] | Symbol[]
-      expressions = !Array.isArray(parsed) ? [parsed] : parsed
+      const parsed: any = parser.parse({ terminals: [bp - 1] })
+      const expressions: RangeExpression[] | FilterExpression[] | TypeSymbol[] = !Array.isArray(parsed) ? [parsed] : parsed
 
       // Make sure we only have one type of expression (cannot mix)
-      const unique = new Set(expressions.map(expr => expr.type))
+      const unique = new Set(expressions.map((expr) => expr.type))
       if (unique.size > 1) {
         throw new Error('Invalid expression')
       }
@@ -112,7 +110,7 @@ const parseFilter = (filter: string): ExpressionSet => {
       // 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')) {
+      if (expressions.some((expr) => expr.type == 'Symbol')) {
         return {
           source: left as string,
           type: 'FilterExpression',
@@ -123,11 +121,9 @@ const parseFilter = (filter: string): ExpressionSet => {
 
             return {
               type: 'FilterExpression',
-              match: (obj: any): boolean => {
-                return obj === e.value
-              },
+              match: (obj: any): boolean => obj === e.value,
             }
-          })
+          }),
         }
       }
 
@@ -137,44 +133,50 @@ const parseFilter = (filter: string): ExpressionSet => {
         children: expressions,
       }
     })
-    .nud('STRING', 20, t => {
-      return {
-        type: 'Symbol',
-        kind: 'string',
-        // @ts-ignore
-        value: t.token.groups[1],
-      } as Symbol
-    })
-    .nud('INT', 5, t => {
-      return {
-        type: 'Symbol',
-        kind: 'int',
-        value: parseInt(t.token.match, 10),
-      } as Symbol
-    })
-    .nud('STAR', 5, t => {
-      return {
-        type: 'Symbol',
-        kind: 'any',
-        value: null,
-      }
-    })
-    .nud('EXISTS', 10, ({ bp }) => {
-      return {
-        type: 'FilterExpression',
-        match: (obj: any): boolean => {
-          return obj !== undefined
-        },
-      } as FilterExpression
-    })
-    .nud('MISSING', 10, ({ bp }) => {
-      return {
-        type: 'FilterExpression',
-        match: (obj: any): boolean => {
-          return obj === undefined
-        },
-      } as FilterExpression
-    })
+    .nud(
+      'STRING',
+      20,
+      (t) =>
+        ({
+          type: 'Symbol',
+          kind: 'string',
+          // @ts-ignore
+          value: t.token.groups[1],
+        } as TypeSymbol)
+    )
+    .nud(
+      'INT',
+      5,
+      (t) =>
+        ({
+          type: 'Symbol',
+          kind: 'int',
+          value: parseInt(t.token.match, 10),
+        } as TypeSymbol)
+    )
+    .nud('STAR', 5, (_) => ({
+      type: 'Symbol',
+      kind: 'any',
+      value: null,
+    }))
+    .nud(
+      'EXISTS',
+      10,
+      ({ bp }) =>
+        ({
+          type: 'FilterExpression',
+          match: (obj: any): boolean => obj !== undefined,
+        } as FilterExpression)
+    )
+    .nud(
+      'MISSING',
+      10,
+      ({ bp }) =>
+        ({
+          type: 'FilterExpression',
+          match: (obj: any): boolean => obj === undefined,
+        } as FilterExpression)
+    )
     .led('COMMA', 200, ({ left, token, bp }) => {
       const expr: any = parser.parse({ terminals: [bp - 1] })
       if (Array.isArray(expr)) {
@@ -183,7 +185,7 @@ const parseFilter = (filter: string): ExpressionSet => {
         return [left, expr]
       }
     })
-    .nud('(', 100, t => {
+    .nud('(', 100, (t) => {
       const expr: any = parser.parse({ terminals: [')'] })
       lexer.expect(')')
       return expr
@@ -211,21 +213,13 @@ const parseFilter = (filter: string): ExpressionSet => {
         let func = undefined
 
         if (range.start !== null && range.stop !== null) {
-          func = (obj: any): boolean => {
-            return obj >= range.start && obj <= range.stop
-          }
+          func = (obj: any): boolean => obj >= range.start && obj <= range.stop
         } else if (range.start === null && range.stop !== null) {
-          func = (obj: any): boolean => {
-            return obj <= range.stop
-          }
+          func = (obj: any): boolean => obj <= range.stop
         } else if (range.start !== null && range.stop === null) {
-          func = (obj: any): boolean => {
-            return obj >= range.start
-          }
+          func = (obj: any): boolean => obj >= range.start
         } else {
-          func = (obj: any): boolean => {
-            return true
-          }
+          func = (obj: any): boolean => true
         }
 
         return {
@@ -244,8 +238,8 @@ const parseFilter = (filter: string): ExpressionSet => {
 const generateMatchFunc = (filter: string) => {
   const result = parseFilter(filter)
   if (!result) {
-    const lines = filter.split('\n')
-    const column = lines[lines.length - 1].length
+    // const lines = filter.split('\n')
+    // const column = lines[lines.length - 1].length
     throw new Error(`Syntax error while parsing '${filter}'.`)
   }
   if (result.type == 'TermExpression') {
@@ -254,7 +248,7 @@ const generateMatchFunc = (filter: string) => {
 
   return (obj: any) => {
     if (!result.children) return false
-    return result.children.some(c => c.match(obj))
+    return result.children.some((c) => c.match(obj))
   }
 }
 
@@ -268,23 +262,20 @@ export const generateFacetFunc = (filter: string): ExpressionSet => {
   return parseFilter(filter)
 }
 
-const filterProduct = (source: string, exprFunc: MatchFunc): ProductFilter => {
-  return (p: Product, markMatchingVariants: boolean): boolean => {
+const filterProduct =
+  (source: string, exprFunc: MatchFunc): ProductProjectionFilter =>
+  (p: ProductProjection, markMatchingVariants: boolean): boolean => {
     const value = nestedLookup(p, source)
     return exprFunc(value)
   }
-}
 
-const filterVariants = (
-  source: string,
-  staged: boolean,
-  exprFunc: MatchFunc
-): ProductFilter => {
-  return (p: Product, markMatchingVariants: boolean): boolean => {
+const filterVariants =
+  (source: string, exprFunc: MatchFunc): ProductProjectionFilter =>
+  (p: ProductProjection, markMatchingVariants: boolean): boolean => {
     const [, ...paths] = source.split('.')
     const path = paths.join('.')
 
-    const variants = getVariants(p, staged) as Writable<ProductVariant>[]
+    const variants = getVariants(p) as Writable<ProductVariant>[]
     for (const variant of variants) {
       const value = resolveVariantValue(variant, path)
 
@@ -294,7 +285,7 @@ const filterVariants = (
         // 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
@@ -303,7 +294,6 @@ const filterVariants = (
 
     return false
   }
-}
 
 export const resolveVariantValue = (obj: ProductVariant, path: string): any => {
   if (path === undefined) {
@@ -335,13 +325,7 @@ export const resolveVariantValue = (obj: ProductVariant, path: string): any => {
   return nestedLookup(obj, path)
 }
 
-export const getVariants = (p: Product, staged: boolean): ProductVariant[] => {
-  return [
-    staged
-      ? p.masterData.staged?.masterVariant
-      : p.masterData.current?.masterVariant,
-    ...(staged
-      ? p.masterData.staged?.variants
-      : p.masterData.current?.variants),
-  ]
-}
+export const getVariants = (p: ProductProjection): ProductVariant[] => [
+  p.masterVariant,
+  ...(p.variants ?? []),
+]

package/src/oauth/store.ts

@@ -9,9 +9,9 @@ type Token = {
 
 export class OAuth2Store {
   tokens: Token[] = []
-  validate: Boolean = true
+  validate = true
 
-  constructor(validate: Boolean = true) {
+  constructor(validate = true) {
     this.validate = validate
   }
 
@@ -29,7 +29,7 @@ export class OAuth2Store {
   validateToken(token: string) {
     if (!this.validate) return true
 
-    const foundToken = this.tokens.find(t => t.access_token === token)
+    const foundToken = this.tokens.find((t) => t.access_token === token)
     if (foundToken) {
       return true
     }

package/src/priceSelector.test.ts

@@ -1,11 +1,21 @@
-import { ProductData, Product } from '@commercetools/platform-sdk'
+import {
+  ProductProjection,
+} from '@commercetools/platform-sdk'
 import { applyPriceSelector } from './priceSelector'
 
 describe('priceSelector', () => {
-  let product: Product
+  let product: ProductProjection
 
   beforeEach(() => {
-    const productData: ProductData = {
+    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',
+      },
       name: {
         'nl-NL': 'test',
       },
@@ -48,49 +58,22 @@ describe('priceSelector', () => {
         ],
       },
     }
-
-    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 } },
-          },
-        },
+      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()
+    expect(product.masterVariant.scopedPrice).toBeUndefined()
+    expect(product.masterVariant.scopedPrice).toBeUndefined()
   })
 })

package/src/priceSelector.ts

@@ -1,7 +1,7 @@
 import {
   InvalidInputError,
   Price,
-  Product,
+  ProductProjection,
   ProductVariant,
 } from '@commercetools/platform-sdk'
 import { CommercetoolsError } from './exceptions'
@@ -20,23 +20,20 @@ export type PriceSelector = {
  * the scopedPrice attribute
  */
 export const applyPriceSelector = (
-  products: Product[],
+  products: ProductProjection[],
   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)
+      product.masterVariant,
+      ...(product.variants ?? []),
+    ].filter((x) => x != undefined)
 
     for (const variant of variants) {
       const scopedPrices =
-        variant.prices?.filter(p => priceSelectorFilter(p, selector)) ?? []
+        variant.prices?.filter((p) => priceSelectorFilter(p, selector)) ?? []
 
       if (scopedPrices.length > 0) {
         const price = scopedPrices[0]