@labdigital/commercetools-mock 0.6.3 → 0.7.0

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.6.3",
+  "version": "0.7.0",
   "license": "MIT",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -8,16 +8,14 @@
     "src"
   ],
   "engines": {
-    "node": ">=10"
+    "node": ">=14"
   },
   "scripts": {
-    "start": "tsdx watch",
-    "server": "nodemon --watch src --exec 'node -r esbuild-register' src/server.ts",
+    "start": "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"
+    "build": "tsup",
+    "test": "jest test --coverage",
+    "lint": "eslint"
   },
   "prettier": {
     "printWidth": 80,
@@ -29,34 +27,49 @@
   "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"

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,16 @@ export const getBaseResourceProperties = () => {
     version: 0,
   }
 }
+
+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,177 @@
+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 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,248 @@
+/**
+ * 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 { Writable } from '../types'
+
+type MatchFunc = (target: any) => boolean
+
+type ProductFilter = (
+  p: Writable<Product>,
+  markMatchingVariants: boolean
+) => 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 generateMatchFunc = (filter: string): MatchFunc => {
+  const lexer = getLexer(filter)
+  const parser = new Parser(lexer)
+    .builder()
+    .nud('IDENTIFIER', 100, t => {
+      return t.token.match
+    })
+    .led(':', 100, ({ left, bp }) => {
+      const expr = parser.parse({ terminals: [bp - 1] })
+
+      if (Array.isArray(expr)) {
+        return (obj: any): boolean => {
+          return expr.includes(obj)
+        }
+      }
+      if (typeof expr === 'function') {
+        return (obj: any): boolean => {
+          return expr(obj)
+        }
+      }
+      return (obj: any): boolean => {
+        return obj === expr
+      }
+    })
+    .nud('STRING', 20, t => {
+      // @ts-ignore
+      return t.token.groups[1]
+    })
+    .nud('INT', 5, t => {
+      // @ts-ignore
+      return parseInt(t.token.match, 10)
+    })
+    .nud('STAR', 5, t => {
+      return null
+    })
+    .nud('EXISTS', 10, ({ bp }) => {
+      return (val: any) => {
+        return val !== undefined
+      }
+    })
+    .nud('MISSING', 10, ({ bp }) => {
+      return (val: any) => {
+        return val === undefined
+      }
+    })
+    .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]
+      }
+    })
+    .bp(')', 0)
+    .led('TO', 20, ({ left, bp }) => {
+      const expr: any = parser.parse({ terminals: [bp - 1] })
+      return [left, expr]
+    })
+    .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
+        }
+      }
+      else if (start !== null && stop === null) {
+        return (obj: any): boolean => {
+          return obj >= start
+        }
+      } else {
+        return (obj: any): boolean => {
+          return true
+        }
+
+      }
+    })
+    .build()
+
+  const result = parser.parse()
+
+  if (typeof result !== 'function') {
+    const lines = filter.split('\n')
+    const column = lines[lines.length - 1].length
+    throw new Error(`Syntax error while parsing '${filter}'.`)
+  }
+  return result
+}
+
+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
+  }
+}
+
+const resolveVariantValue = (obj: ProductVariant, path: string): any => {
+  if (path === undefined) {
+    return obj
+  }
+
+  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)
+}
+
+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[] => {
+  return [
+    staged
+      ? p.masterData.staged?.masterVariant
+      : p.masterData.current?.masterVariant,
+    ...(staged
+      ? p.masterData.staged?.variants
+      : p.masterData.current?.variants),
+  ]
+}

package/src/priceSelector.test.ts

@@ -0,0 +1,96 @@
+import { ProductData, Product } from '@commercetools/platform-sdk'
+import { applyPriceSelector } from './priceSelector'
+
+describe('priceSelector', () => {
+  let product: Product
+
+  beforeEach(() => {
+    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,
+            },
+          },
+        ],
+      },
+    }
+
+    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 } },
+          },
+        },
+      },
+    })
+  })
+
+  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()
+  })
+})