@labdigital/commercetools-mock 0.6.5 → 0.8.0

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.6.5",
+  "version": "0.8.0",
   "license": "MIT",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -7,17 +7,14 @@
     "dist",
     "src"
   ],
-  "engines": {
-    "node": ">=10"
+  "exports": {
+    ".": {
+      "require": "./dist/index.js",
+      "import": "./dist/index.mjs"
+    }
   },
-  "scripts": {
-    "start": "tsdx watch",
-    "server": "nodemon --watch src --exec 'node -r esbuild-register' src/server.ts",
-    "generate": "node -r esbuild-register generate-validation.ts",
-    "build": "tsdx build --target=node",
-    "test": "tsdx test",
-    "lint": "tsdx lint",
-    "prepare": "tsdx build"
+  "engines": {
+    "node": ">=14"
   },
   "prettier": {
     "printWidth": 80,
@@ -29,36 +26,58 @@
   "author": "Michael van Tellingen",
   "module": "dist/commercetools--mock.esm.js",
   "devDependencies": {
-    "@babel/preset-typescript": "^7.16.7",
-    "@commercetools/platform-sdk": "^2.4.1",
+    "@babel/preset-env": "^7.18.9",
+    "@babel/preset-typescript": "^7.18.6",
+    "@commercetools/platform-sdk": "2.8.0",
     "@types/basic-auth": "^1.1.3",
+    "@types/body-parser": "^1.19.2",
     "@types/deep-equal": "^1.0.1",
     "@types/express": "^4.17.13",
+    "@types/express-serve-static-core": "^4.17.29",
+    "@types/jest": "^28.1.6",
     "@types/morgan": "^1.9.3",
+    "@types/node": "*",
+    "@types/qs": "^6.9.7",
     "@types/supertest": "^2.0.11",
     "@types/uuid": "^8.3.4",
+    "esbuild": "^0.14.50",
     "esbuild-register": "^3.3.1",
+    "eslint": "^8.20.0",
     "got": "^11.8.3",
     "husky": "^7.0.4",
+    "jest": "^28.1.3",
     "nodemon": "^2.0.15",
+    "timekeeper": "^2.2.0",
     "ts-node": "^10.4.0",
-    "tsdx": "^0.14.1",
+    "tsc": "^2.0.4",
     "tslib": "^2.3.1",
-    "typescript": "^4.5.4"
+    "tsup": "^6.2.0",
+    "typescript": "^4.7.4"
   },
   "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",
     "express": "^4.17.2",
+    "lodash": "^4.17.21",
     "morgan": "^1.10.0",
     "nock": "^13.2.1",
     "perplex": "^0.11.0",
     "pratt": "^0.7.0",
-    "supertest": "^6.1.6"
+    "supertest": "^6.1.6",
+    "uuid": "^8.3.2"
   },
   "peerDependencies": {
     "@commercetools/platform-sdk": "^2.4.1"
+  },
+  "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/ctMock.ts

@@ -25,6 +25,7 @@ import { MyCartService } from './services/my-cart'
 import { MyPaymentService } from './services/my-payment'
 import { OrderService } from './services/order'
 import { PaymentService } from './services/payment'
+import { ProductDiscountService } from './services/product-discount'
 import { ProductProjectionService } from './services/product-projection'
 import { ProductService } from './services/product'
 import { ProductTypeService } from './services/product-type'
@@ -180,6 +181,10 @@ export class CommercetoolsMock {
       ),
       'product-type': new ProductTypeService(projectRouter, this._storage),
       product: new ProductService(projectRouter, this._storage),
+      'product-discount': new ProductDiscountService(
+        projectRouter,
+        this._storage
+      ),
       'product-projection': new ProductProjectionService(
         projectRouter,
         this._storage

package/src/helpers.ts

@@ -1,4 +1,6 @@
 import { v4 as uuidv4 } from 'uuid'
+import { ParsedQs } from 'qs'
+import { Price } from '@commercetools/platform-sdk'
 
 export const getBaseResourceProperties = () => {
   return {
@@ -8,3 +10,40 @@ export const getBaseResourceProperties = () => {
     version: 0,
   }
 }
+
+/**
+ * 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[] => {
+  if (input == undefined) {
+    return []
+  }
+
+  if (Array.isArray(input)) {
+    return input as string[]
+  }
+  return [input] as string[]
+}

package/src/lib/projectionSearchFilter.test.ts

@@ -0,0 +1,183 @@
+import { Product, ProductData } from '@commercetools/platform-sdk'
+import { applyPriceSelector } from '../priceSelector'
+import { parseFilterExpression } from './projectionSearchFilter'
+
+describe('Search filter', () => {
+  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,
+          },
+        },
+      ],
+    },
+  }
+
+  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))
+    return {
+      isMatch: matchFunc(clone, false),
+      product: clone,
+    }
+  }
+
+  test('by product key', async () => {
+    expect(match(`key:exists`).isMatch).toBeTruthy()
+    expect(match(`key:missing`).isMatch).toBeFalsy()
+    expect(match(`key:"test-product"`).isMatch).toBeTruthy()
+  })
+
+  test('by product type id', async () => {
+    expect(match(`productType.id:"b9b4b426-938b-4ccb-9f36-c6f933e8446e"`).isMatch).toBeTruthy()
+  })
+
+  test('by SKU', async () => {
+    expect(match(`variants.sku:exists`).isMatch).toBeTruthy()
+    expect(match(`variants.sku:missing`).isMatch).toBeFalsy()
+    expect(match(`variants.sku:"MYSKU"`).isMatch).toBeTruthy()
+  })
+
+  test('by attribute value', async () => {
+    expect(match(`variants.attributes.number:4`).isMatch).toBeTruthy()
+    expect(match(`variants.attributes.number:3,4`).isMatch).toBeTruthy()
+    expect(match(`variants.attributes.number:3,4,5`).isMatch).toBeTruthy()
+    expect(match(`variants.attributes.number:1,2,3,5`).isMatch).toBeFalsy()
+  })
+
+  test('by attribute range', async () => {
+    expect(
+      match(`variants.attributes.number:range (0 TO 5)`).isMatch
+    ).toBeTruthy()
+
+    expect(
+      match(`variants.attributes.number:range (* TO 5)`).isMatch
+    ).toBeTruthy()
+
+    expect(
+      match(`variants.attributes.number:range (* TO *)`).isMatch
+    ).toBeTruthy()
+  })
+
+  test('by attribute enum key', async () => {
+    expect(match(`variants.attributes.Country.key:"NL"`).isMatch).toBeTruthy()
+    expect(match(`variants.attributes.Country.key:"DE"`).isMatch).toBeFalsy()
+  })
+
+  test('by attribute enum key', async () => {
+    expect(match(`variants.attributes.Country.key:"NL"`).isMatch).toBeTruthy()
+    expect(match(`variants.attributes.Country.key:"DE"`).isMatch).toBeFalsy()
+  })
+
+  test('by price range', async () => {
+    expect(
+      match(`variants.price.centAmount:range (1500 TO 2000)`).isMatch
+    ).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[]
+
+    // 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))]
+    applyPriceSelector(products, { currency: 'EUR' })
+
+    result = match(
+      `variants.scopedPrice.value.centAmount:range (1500 TO 2000)`,
+      products[0]
+    )
+    expect(result.isMatch).toBeTruthy()
+    expect(result.product).toMatchObject({
+      masterData: {
+        current: {
+          masterVariant: {
+            sku: 'MYSKU',
+            scopedPrice: { value: { centAmount: 1789 } },
+          },
+        },
+      },
+    })
+
+    // Currency mismatch
+    products = [JSON.parse(JSON.stringify(exampleProduct))]
+    applyPriceSelector(products, { currency: 'USD' })
+
+    result = match(
+      `variants.scopedPrice.value.centAmount:range (1500 TO 2000)`,
+      products[0]
+    )
+    expect(result.isMatch).toBeFalsy()
+
+    // Price has no country so mismatch
+    products = [JSON.parse(JSON.stringify(exampleProduct))]
+    applyPriceSelector(products, { currency: 'EUR', country: 'NL' })
+    result = match(
+      `variants.scopedPrice.value.centAmount:range (1500 TO 2000)`,
+      products[0]
+    )
+    expect(result.isMatch).toBeFalsy()
+  })
+})

package/src/lib/projectionSearchFilter.ts

@@ -0,0 +1,347 @@
+/**
+ * This module implements the commercetools product projection filter expression.
+ */
+
+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
+
+type ProductFilter = (
+  p: Writable<Product>,
+  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)
+ */
+export const parseFilterExpression = (
+  filter: string,
+  staged: boolean
+): ProductFilter => {
+  const exprFunc = generateMatchFunc(filter)
+  const [source] = filter.split(':', 1)
+
+  if (source.startsWith('variants.')) {
+    return filterVariants(source, staged, exprFunc)
+  }
+  return filterProduct(source, exprFunc)
+}
+
+const getLexer = (value: string) => {
+  return 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('FLOAT', /\d+\.\d+/)
+    .token('INT', /\d+/)
+    .token('STRING', /"((?:\\.|[^"\\])*)"/)
+    .token('STRING', /'((?:\\.|[^'\\])*)'/)
+
+    .token('COMMA', ',')
+    .token('STAR', '*')
+    .token('(', '(')
+    .token(':', ':')
+    .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
+    })
+    .led(':', 100, ({ left, bp }) => {
+      let parsed: any = parser.parse({ terminals: [bp - 1] })
+      let expressions: RangeExpression[] | FilterExpression[] | Symbol[]
+      expressions = !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))
+      if (unique.size > 1) {
+        throw new Error('Invalid expression')
+      }
+
+      // 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 {
+        source: left,
+        type: expressions[0].type,
+        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
+    })
+    .led('COMMA', 200, ({ left, token, bp }) => {
+      const expr: any = parser.parse({ terminals: [bp - 1] })
+      if (Array.isArray(expr)) {
+        return [left, ...expr]
+      } else {
+        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 {
+        start: left.value,
+        stop: expr.value,
+      }
+    })
+    .nud('RANGE', 20, ({ bp }) => {
+      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]
+      }
+
+      // 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()
+
+  return parser.parse()
+}
+
+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}'.`)
+  }
+  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))
+  }
+}
+
+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)
+  }
+}
+
+const filterVariants = (
+  source: string,
+  staged: boolean,
+  exprFunc: MatchFunc
+): ProductFilter => {
+  return (p: Product, markMatchingVariants: boolean): boolean => {
+    const [, ...paths] = source.split('.')
+    const path = paths.join('.')
+
+    const variants = getVariants(p, staged) as Writable<ProductVariant>[]
+    for (const variant of variants) {
+      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))
+          variant.isMatchingVariant = true
+        }
+        return true
+      }
+    }
+
+    return false
+  }
+}
+
+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('.')
+    if (!obj.attributes) {
+      return undefined
+    }
+
+    for (const attr of obj.attributes) {
+      if (attr.name === attrName) {
+        return nestedLookup(attr.value, rest.join('.'))
+      }
+    }
+  }
+
+  if (path === 'price.centAmount') {
+    return obj.prices && obj.prices.length > 0
+      ? obj.prices[0].value.centAmount
+      : undefined
+  }
+
+  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),
+  ]
+}