@labdigital/commercetools-mock 0.9.1 → 0.10.1

package/package.json

@@ -1,7 +1,10 @@
 {
-  "version": "0.9.1",
+  "name": "@labdigital/commercetools-mock",
+  "author": "Michael van Tellingen",
+  "version": "0.10.1",
   "license": "MIT",
   "main": "dist/index.js",
+  "module": "dist/commercetools--mock.esm.js",
   "typings": "dist/index.d.ts",
   "files": [
     "dist",
@@ -14,21 +17,35 @@
     }
   },
   "engines": {
-    "node": ">=14"
+    "node": ">=14",
+    "pnpm": ">=7.13.2"
   },
+  "packageManager": "pnpm@7.13.2",
   "prettier": {
     "printWidth": 80,
     "semi": false,
     "singleQuote": true,
     "trailingComma": "es5"
   },
-  "name": "@labdigital/commercetools-mock",
-  "author": "Michael van Tellingen",
-  "module": "dist/commercetools--mock.esm.js",
+  "dependencies": {
+    "@types/lodash": "^4.14.182",
+    "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",
+    "type-fest": "^3.1.0",
+    "uuid": "^8.3.2"
+  },
   "devDependencies": {
     "@babel/preset-env": "^7.18.9",
     "@babel/preset-typescript": "^7.18.6",
-    "@commercetools/platform-sdk": "2.8.0",
+    "@commercetools/platform-sdk": "4.0.0",
     "@types/basic-auth": "^1.1.3",
     "@types/body-parser": "^1.19.2",
     "@types/deep-equal": "^1.0.1",
@@ -40,13 +57,17 @@
     "@types/qs": "^6.9.7",
     "@types/supertest": "^2.0.11",
     "@types/uuid": "^8.3.4",
+    "@typescript-eslint/eslint-plugin": "^5.39.0",
+    "@typescript-eslint/parser": "^5.39.0",
     "esbuild": "^0.14.50",
     "esbuild-register": "^3.3.1",
     "eslint": "^8.20.0",
+    "eslint-plugin-unused-imports": "^2.0.0",
     "got": "^11.8.3",
     "husky": "^7.0.4",
     "jest": "^28.1.3",
     "nodemon": "^2.0.15",
+    "prettier": "^2.7.1",
     "timekeeper": "^2.2.0",
     "ts-node": "^10.4.0",
     "tsc": "^2.0.4",
@@ -54,27 +75,15 @@
     "tsup": "^6.2.0",
     "typescript": "^4.7.4"
   },
-  "dependencies": {
-    "@types/lodash": "^4.14.182",
-    "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",
-    "uuid": "^8.3.2"
-  },
   "peerDependencies": {
     "@commercetools/platform-sdk": "^2.4.1"
   },
   "scripts": {
     "start": "nodemon --watch src --exec 'node -r esbuild-register' src/server.ts",
     "build": "tsup",
+    "build:server": "esbuild src/server.ts --bundle --outfile=dist/server.js --platform=node",
+    "check": "eslint src && tsc",
     "test": "jest test --coverage",
-    "lint": "eslint"
+    "lint": "eslint src"
   }
 }

package/src/constants.ts

@@ -1,2 +1,4 @@
-export const DEFAULT_API_HOSTNAME = /^https:\/\/api\..*?\.commercetools.com:443$/
-export const DEFAULT_AUTH_HOSTNAME = /^https:\/\/auth\..*?\.commercetools.com:443$/
+export const DEFAULT_API_HOSTNAME =
+  /^https:\/\/api\..*?\.commercetools.com:443$/
+export const DEFAULT_AUTH_HOSTNAME =
+  /^https:\/\/auth\..*?\.commercetools.com:443$/

package/src/ctMock.ts

@@ -11,35 +11,10 @@ import { copyHeaders } from './lib/proxy'
 import { DEFAULT_API_HOSTNAME, DEFAULT_AUTH_HOSTNAME } from './constants'
 
 // Services
-import { CartDiscountService } from './services/cart-discount'
-import { CartService } from './services/cart'
-import { CategoryServices } from './services/category'
-import { ChannelService } from './services/channel'
-import { CustomerGroupService } from './services/customer-group'
-import { CustomerService } from './services/customer'
-import { CustomObjectService } from './services/custom-object'
-import { DiscountCodeService } from './services/discount-code'
-import { ExtensionServices } from './services/extension'
-import { InventoryEntryService } from './services/inventory-entry'
-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'
 import { ProjectService } from './services/project'
-import { ShippingMethodService } from './services/shipping-method'
-import { ShoppingListService } from './services/shopping-list'
-import { StateService } from './services/state'
-import { StoreService } from './services/store'
-import { SubscriptionService } from './services/subscription'
-import { TaxCategoryService } from './services/tax-category'
-import { TypeService } from './services/type'
-import { ZoneService } from './services/zone'
-import { MyCustomerService } from './services/my-customer'
-import { MyOrderService } from './services/my-order'
+import { createRepositories, RepositoryMap } from './repositories'
+import { createServices } from './services'
+import { ProjectRepository } from 'repositories/project'
 
 export type CommercetoolsMockOptions = {
   validateCredentials: boolean
@@ -71,12 +46,14 @@ export class CommercetoolsMock {
     auth: nock.Scope | undefined
     api: nock.Scope | undefined
   } = { auth: undefined, api: undefined }
-  private _services: Services
+  private _services: Services | null
+  private _repositories: RepositoryMap | null
   private _projectService?: ProjectService
 
   constructor(options: Partial<CommercetoolsMockOptions> = {}) {
     this.options = { ...DEFAULT_OPTIONS, ...options }
-    this._services = {}
+    this._services = null
+    this._repositories = null
     this._projectService = undefined
 
     this._storage = new InMemoryStorage()
@@ -111,22 +88,27 @@ export class CommercetoolsMock {
       throw new Error('No projectKey passed and no default set')
     }
 
+    if (this._repositories === null) {
+      throw new Error('repositories not initialized yet')
+    }
+
     return new ProjectAPI(
       projectKey || this.options.defaultProjectKey!,
-      this._services,
+      this._repositories,
       this._storage
     )
   }
 
-  runServer(port: number = 3000, options?: AppOptions) {
-    const app = this.createApp(options)
-    const server = app.listen(port, () => {
-      console.log(`Mock server listening at http://localhost:${port}`)
+  runServer(port = 3000, options?: AppOptions) {
+    const server = this.app.listen(port, () => {
+      console.info(`Mock server listening at http://localhost:${port}`)
     })
     server.keepAliveTimeout = 60 * 1000
   }
 
   private createApp(options?: AppOptions): express.Express {
+    this._repositories = createRepositories(this._storage)
+
     const app = express()
 
     const projectRouter = express.Router({ mergeParams: true })
@@ -150,53 +132,12 @@ export class CommercetoolsMock {
       app.use('/:projectKey/in-store/key=:storeKey', projectRouter)
     }
 
-    this._projectService = new ProjectService(projectRouter, this._storage)
-
-    this._services = {
-      category: new CategoryServices(projectRouter, this._storage),
-      cart: new CartService(projectRouter, this._storage),
-      'cart-discount': new CartDiscountService(projectRouter, this._storage),
-      customer: new CustomerService(projectRouter, this._storage),
-      channel: new ChannelService(projectRouter, this._storage),
-      'customer-group': new CustomerGroupService(projectRouter, this._storage),
-      'discount-code': new DiscountCodeService(projectRouter, this._storage),
-      extension: new ExtensionServices(projectRouter, this._storage),
-      'inventory-entry': new InventoryEntryService(
-        projectRouter,
-        this._storage
-      ),
-      'key-value-document': new CustomObjectService(
-        projectRouter,
-        this._storage
-      ),
-      order: new OrderService(projectRouter, this._storage),
-      payment: new PaymentService(projectRouter, this._storage),
-      'my-cart': new MyCartService(projectRouter, this._storage),
-      'my-order': new MyOrderService(projectRouter, this._storage),
-      'my-customer': new MyCustomerService(projectRouter, this._storage),
-      'my-payment': new MyPaymentService(projectRouter, this._storage),
-      'shipping-method': new ShippingMethodService(
-        projectRouter,
-        this._storage
-      ),
-      '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
-      ),
-      'shopping-list': new ShoppingListService(projectRouter, this._storage),
-      state: new StateService(projectRouter, this._storage),
-      store: new StoreService(projectRouter, this._storage),
-      subscription: new SubscriptionService(projectRouter, this._storage),
-      'tax-category': new TaxCategoryService(projectRouter, this._storage),
-      type: new TypeService(projectRouter, this._storage),
-      zone: new ZoneService(projectRouter, this._storage),
-    }
+    // Register the rest api services in the router
+    this._services = createServices(projectRouter, this._repositories)
+    this._projectService = new ProjectService(
+      projectRouter,
+      this._repositories.project as ProjectRepository
+    )
 
     app.use((err: Error, req: Request, resp: Response, next: NextFunction) => {
       if (err instanceof CommercetoolsError) {
@@ -222,14 +163,14 @@ export class CommercetoolsMock {
     this._nockScopes.api = nock(this.options.apiHost)
       .persist()
       .get(/.*/)
-      .reply(async function(uri) {
+      .reply(async function (uri) {
         const response = await supertest(app)
           .get(uri)
           .set(copyHeaders(this.req.headers))
         return [response.status, response.body]
       })
       .post(/.*/)
-      .reply(async function(uri, body) {
+      .reply(async function (uri, body) {
         const response = await supertest(app)
           .post(uri)
           .set(copyHeaders(this.req.headers))
@@ -237,7 +178,7 @@ export class CommercetoolsMock {
         return [response.status, response.body]
       })
       .delete(/.*/)
-      .reply(async function(uri, body) {
+      .reply(async function (uri, body) {
         const response = await supertest(app)
           .delete(uri)
           .set(copyHeaders(this.req.headers))
@@ -252,7 +193,7 @@ export class CommercetoolsMock {
     this._nockScopes.auth = nock(this.options.authHost)
       .persist()
       .post(/^\/oauth\/.*/)
-      .reply(async function(uri, body) {
+      .reply(async function (uri, body) {
         const response = await supertest(app)
           .post(uri + '?' + body)
           .set(copyHeaders(this.req.headers))

package/src/helpers.ts

@@ -1,15 +1,12 @@
-import { v4 as uuidv4 } from 'uuid'
 import { ParsedQs } from 'qs'
-import { Price } from '@commercetools/platform-sdk'
-
-export const getBaseResourceProperties = () => {
-  return {
-    id: uuidv4(),
-    createdAt: new Date().toISOString(),
-    lastModifiedAt: new Date().toISOString(),
-    version: 0,
-  }
-}
+import { v4 as uuidv4 } from 'uuid'
+
+export const getBaseResourceProperties = () => ({
+  id: uuidv4(),
+  createdAt: new Date().toISOString(),
+  lastModifiedAt: new Date().toISOString(),
+  version: 0,
+})
 
 /**
  * Do a nested lookup by using a path. For example `foo.bar.value` will
@@ -47,3 +44,5 @@ export const QueryParamsAsArray = (
   }
   return [input] as string[]
 }
+
+export const cloneObject = <T>(o: T): T => JSON.parse(JSON.stringify(o))

package/src/index.test.ts

@@ -158,7 +158,7 @@ test('Options.authHost: is set', async () => {
   })
   ctMock.start()
 
-  let response = await got.post<{ access_token: string }>(
+  const response = await got.post<{ access_token: string }>(
     'http://auth.localhost/oauth/token',
     {
       searchParams: {

package/src/lib/haversine.ts

@@ -13,12 +13,12 @@ export const haversineDistance = (src: Location, dst: Location) => {
   const dLat = toRadian(dst.latitude - src.latitude)
   const dLon = toRadian(dst.longitude - src.longitude)
 
-  var a =
+  const a =
     Math.sin(dLat / 2) * Math.sin(dLat / 2) +
     Math.cos(toRadian(src.latitude)) *
       Math.cos(toRadian(dst.latitude)) *
       Math.sin(dLon / 2) *
       Math.sin(dLon / 2)
-  var c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a))
+  const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a))
   return RADIUS_OF_EARTH_IN_KM * c * 1000
 }

package/src/lib/masking.ts

@@ -1,6 +1,8 @@
+import { cloneObject } from '../helpers'
+
 export const maskSecretValue = <T>(resource: T, path: string): T => {
   const parts = path.split('.')
-  const clone = JSON.parse(JSON.stringify(resource))
+  const clone = cloneObject(resource) as any
   let val = clone
 
   const target = parts.pop()

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)
@@ -140,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
@@ -153,74 +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('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',
-        // @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] })
@@ -230,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
     })
@@ -254,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
       }
@@ -262,41 +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
@@ -350,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))
@@ -419,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 {