@labdigital/commercetools-mock 0.5.11 → 0.5.14

package/dist/types.d.ts

@@ -1,3 +1,5 @@
+import { ProductProjectionRepository } from './repositories/product-projection';
+import { ShoppingListRepository } from './repositories/shopping-list';
 import * as ctp from '@commercetools/platform-sdk';
 import { ReferenceTypeId } from '@commercetools/platform-sdk';
 import AbstractService from './services/abstract';
@@ -15,9 +17,10 @@ import { TaxCategoryRepository } from './repositories/tax-category';
 export declare type Writable<T> = {
     -readonly [P in keyof T]: Writable<T[P]>;
 };
-declare type serviceTypes = ReferenceTypeId | 'my-payment';
+export declare type RepositoryTypes = ReferenceTypeId | 'product-projection';
+export declare type ServiceTypes = RepositoryTypes | 'my-cart' | 'my-payment';
 export declare type Services = Partial<{
-    [index in serviceTypes]: AbstractService;
+    [index in ServiceTypes]: AbstractService;
 }>;
 export declare type ResourceMap = {
     cart: ctp.Cart;
@@ -35,6 +38,8 @@ export declare type ResourceMap = {
     payment: ctp.Payment;
     product: ctp.Product;
     'product-discount': ctp.ProductDiscount;
+    'product-projection': ctp.ProductProjection;
+    'product-selection': ctp.ProductSelection;
     'product-type': ctp.ProductType;
     review: ctp.Review;
     'shipping-method': ctp.ShippingMethod;
@@ -69,11 +74,12 @@ export declare type RepositoryMap = {
     'order-edit': never;
     payment: PaymentRepository;
     product: ProductRepository;
+    'product-projection': ProductProjectionRepository;
     'product-discount': never;
     'product-type': ProductTypeRepository;
     review: never;
     'shipping-method': ShippingMethodRepository;
-    'shopping-list': never;
+    'shopping-list': ShoppingListRepository;
     state: StateRepository;
     store: never;
     subscription: never;
@@ -81,4 +87,3 @@ export declare type RepositoryMap = {
     type: ctp.Type;
     zone: ctp.Zone;
 };
-export {};

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.5.11",
+  "version": "0.5.14",
   "license": "MIT",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -41,35 +41,35 @@
     }
   ],
   "devDependencies": {
-    "@babel/preset-typescript": "^7.13.0",
-    "@size-limit/preset-small-lib": "^4.10.2",
+    "@babel/preset-typescript": "^7.16.7",
+    "@size-limit/preset-small-lib": "^7.0.5",
     "@types/basic-auth": "^1.1.3",
     "@types/deep-equal": "^1.0.1",
-    "@types/express": "^4.17.11",
-    "@types/morgan": "^1.9.2",
+    "@types/express": "^4.17.13",
+    "@types/morgan": "^1.9.3",
     "@types/supertest": "^2.0.11",
-    "@types/uuid": "^8.3.0",
-    "esbuild-register": "^2.4.0",
-    "got": "^11.8.2",
-    "husky": "^6.0.0",
-    "nodemon": "^2.0.7",
-    "size-limit": "^4.10.2",
-    "ts-node": "^9.1.1",
+    "@types/uuid": "^8.3.4",
+    "esbuild-register": "^3.3.1",
+    "got": "^11.8.3",
+    "husky": "^7.0.4",
+    "nodemon": "^2.0.15",
+    "size-limit": "^7.0.5",
+    "ts-node": "^10.4.0",
     "tsdx": "^0.14.1",
-    "tslib": "^2.2.0",
-    "typescript": "^4.2.4"
+    "tslib": "^2.3.1",
+    "typescript": "^4.5.4"
   },
   "dependencies": {
-    "@commercetools/platform-sdk": "1.16.0",
-    "ajv": "^8.1.0",
-    "ajv-formats": "^2.0.2",
+    "@commercetools/platform-sdk": "2.4.1",
+    "ajv": "^8.8.2",
+    "ajv-formats": "^2.1.1",
     "basic-auth": "^2.0.1",
     "deep-equal": "^2.0.5",
-    "express": "^4.17.1",
+    "express": "^4.17.2",
     "morgan": "^1.10.0",
-    "nock": "^13.0.11",
+    "nock": "^13.2.1",
     "perplex": "^0.11.0",
     "pratt": "^0.7.0",
-    "supertest": "^6.1.3"
+    "supertest": "^6.1.6"
   }
 }

package/src/ctMock.ts

@@ -1,28 +1,42 @@
-import { ProductTypeService } from './services/product-type'
-import { ShippingMethodService } from './services/shipping-method'
-import { StateService } from './services/state'
-import { TaxCategoryService } from './services/tax-category'
-import { PaymentService } from './services/payment'
 import nock from 'nock'
 import express, { NextFunction, Request, Response } from 'express'
 import supertest from 'supertest'
 import morgan from 'morgan'
 import { AbstractStorage, InMemoryStorage } from './storage'
-import { TypeService } from './services/type'
-import { CustomObjectService } from './services/custom-object'
-import { CustomerService } from './services/customer'
-import { CartService } from './services/cart'
-import { InventoryEntryService } from './services/inventory-entry'
-import { OrderService } from './services/order'
 import { Services } from './types'
-import { StoreService } from './services/store'
 import { CommercetoolsError } from './exceptions'
 import { OAuth2Server } from './oauth/server'
-import { DEFAULT_API_HOSTNAME, DEFAULT_AUTH_HOSTNAME } from './constants'
 import { ProjectAPI } from './projectAPI'
 import { copyHeaders } from './lib/proxy'
-import { ProductService } from './services/product'
+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 { 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'
 
 export type CommercetoolsMockOptions = {
   validateCredentials: boolean
@@ -55,10 +69,12 @@ export class CommercetoolsMock {
     api: nock.Scope | undefined
   } = { auth: undefined, api: undefined }
   private _services: Services
+  private _projectService?: ProjectService
 
   constructor(options: Partial<CommercetoolsMockOptions> = {}) {
     this.options = { ...DEFAULT_OPTIONS, ...options }
     this._services = {}
+    this._projectService = undefined
 
     this._storage = new InMemoryStorage()
     this._oauth2 = new OAuth2Server({
@@ -101,9 +117,10 @@ export class CommercetoolsMock {
 
   runServer(port: number = 3000, options?: AppOptions) {
     const app = this.createApp(options)
-    app.listen(port, () => {
+    const server = app.listen(port, () => {
       console.log(`Mock server listening at http://localhost:${port}`)
     })
+    server.keepAliveTimeout = 60 * 1000
   }
 
   private createApp(options?: AppOptions): express.Express {
@@ -124,9 +141,17 @@ export class CommercetoolsMock {
       app.use('/:projectKey', 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
@@ -137,6 +162,7 @@ export class CommercetoolsMock {
       ),
       order: new OrderService(projectRouter, this._storage),
       payment: new PaymentService(projectRouter, this._storage),
+      'my-cart': new MyCartService(projectRouter, this._storage),
       'my-payment': new MyPaymentService(projectRouter, this._storage),
       'shipping-method': new ShippingMethodService(
         projectRouter,
@@ -144,10 +170,17 @@ export class CommercetoolsMock {
       ),
       'product-type': new ProductTypeService(projectRouter, this._storage),
       product: new ProductService(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),
     }
 
     app.use((err: Error, req: Request, resp: Response, next: NextFunction) => {
@@ -158,6 +191,7 @@ export class CommercetoolsMock {
           errors: [err.info],
         })
       } else {
+        console.error(err)
         return resp.status(500).send({
           error: err.message,
         })

package/src/lib/filterParser.test.ts

@@ -0,0 +1,15 @@
+import { parseFilterExpression } from './filterParser'
+
+describe('filter parser', () => {
+  test('parses array', () => {
+    expect(
+      parseFilterExpression(['variant.sku:"123"', `variant.version="312"`])
+    ).toEqual('variant(sku="123") and variant(version="312")')
+  })
+
+  test('parses string', () => {
+    expect(parseFilterExpression('variant.something.sku:"123"')).toEqual(
+      'variant(something(sku="123"))'
+    )
+  })
+})

package/src/lib/filterParser.ts

@@ -0,0 +1,17 @@
+export const parseFilterExpression = (filter: string | string[]) => {
+  if (typeof filter === 'object') {
+    const filters = filter.map(parse)
+    return filters.join(' and ')
+  }
+  return parse(filter)
+}
+
+const parse = (filter: string) => {
+  let parsed = filter.replace(/:/g, '=')
+
+  do {
+    parsed = parsed.replace(/(.*)\.(.*)=(.*)$/g, '$1($2=$3)')
+  } while (parsed.includes('.'))
+
+  return parsed
+}

package/src/oauth/server.ts

@@ -1,4 +1,5 @@
 import auth from 'basic-auth'
+import bodyParser from 'body-parser'
 import express, { NextFunction, Request, Response } from 'express'
 import {
   AccessDeniedError,
@@ -18,6 +19,7 @@ export class OAuth2Server {
 
   createRouter() {
     const router = express.Router()
+    router.use(bodyParser.urlencoded({ extended: true }))
     router.post('/token', this.tokenHandler.bind(this))
     return router
   }
@@ -81,7 +83,7 @@ export class OAuth2Server {
       )
     }
 
-    const grantType = request.query.grant_type
+    const grantType = request.query.grant_type || request.body.grant_type
     if (!grantType) {
       return next(
         new CommercetoolsError<InvalidRequestError>(

package/src/repositories/abstract.ts

@@ -1,9 +1,10 @@
+import { RepositoryTypes } from './../types'
 import deepEqual from 'deep-equal'
 
 import {
   BaseResource,
   InvalidOperationError,
-  ReferenceTypeId,
+  Project,
   UpdateAction,
 } from '@commercetools/platform-sdk'
 import { AbstractStorage } from '../storage'
@@ -19,20 +20,50 @@ export type GetParams = {
   expand?: string[]
 }
 
-export default abstract class AbstractRepository {
+export abstract class AbstractRepository {
   protected _storage: AbstractStorage
-
-  protected actions: {
-    [key: string]: (projectKey: string, resource: any, actions: any) => void
-  } = {}
+  protected actions: Partial<
+    Record<any, (projectKey: string, resource: any, action: any) => void>
+  > = {}
 
   constructor(storage: AbstractStorage) {
     this._storage = storage
-    this._storage.assertStorage(this.getTypeId())
   }
 
-  abstract getTypeId(): ReferenceTypeId
+  abstract save(projectKey: string, resource: BaseResource | Project): void
+
+  processUpdateActions(
+    projectKey: string,
+    resource: BaseResource | Project,
+    actions: UpdateAction[]
+  ): BaseResource {
+    // Deep-copy
+    const modifiedResource = JSON.parse(JSON.stringify(resource))
+
+    actions.forEach(action => {
+      const updateFunc = this.actions[action.action]
+      if (!updateFunc) {
+        console.error(`No mock implemented for update action ${action.action}`)
+        return
+      }
+      updateFunc(projectKey, modifiedResource, action)
+    })
+
+    if (!deepEqual(modifiedResource, resource)) {
+      this.save(projectKey, modifiedResource)
+    }
+    return modifiedResource
+  }
+}
+
+export abstract class AbstractResourceRepository extends AbstractRepository {
   abstract create(projectKey: string, draft: any): BaseResource
+  abstract getTypeId(): RepositoryTypes
+
+  constructor(storage: AbstractStorage) {
+    super(storage)
+    this._storage.assertStorage(this.getTypeId())
+  }
 
   query(projectKey: string, params: QueryParams = {}) {
     return this._storage.query(projectKey, this.getTypeId(), {
@@ -49,6 +80,14 @@ export default abstract class AbstractRepository {
     return this._storage.get(projectKey, this.getTypeId(), id, params)
   }
 
+  getByKey(
+    projectKey: string,
+    key: string,
+    params: GetParams = {}
+  ): BaseResource | null {
+    return this._storage.getByKey(projectKey, this.getTypeId(), key, params)
+  }
+
   delete(
     projectKey: string,
     id: string,
@@ -58,9 +97,8 @@ export default abstract class AbstractRepository {
   }
 
   save(projectKey: string, resource: BaseResource) {
-    const typeId = this.getTypeId()
-
     const current = this.get(projectKey, resource.id)
+
     if (current) {
       checkConcurrentModification(current, resource.version)
     } else {
@@ -77,29 +115,6 @@ export default abstract class AbstractRepository {
 
     // @ts-ignore
     resource.version += 1
-    this._storage.add(projectKey, typeId, resource as any)
-  }
-
-  processUpdateActions(
-    projectKey: string,
-    resource: BaseResource,
-    actions: UpdateAction[]
-  ): BaseResource {
-    // Deep-copy
-    const modifiedResource = JSON.parse(JSON.stringify(resource))
-
-    actions.forEach(action => {
-      const updateFunc = this.actions[action.action]
-      if (!updateFunc) {
-        console.error(`No mock implemented for update action ${action.action}`)
-        return
-      }
-      updateFunc(projectKey, modifiedResource, action)
-    })
-
-    if (!deepEqual(modifiedResource, resource)) {
-      this.save(projectKey, modifiedResource)
-    }
-    return modifiedResource
+    this._storage.add(projectKey, this.getTypeId(), resource as any)
   }
 }

package/src/repositories/cart-discount.ts

@@ -0,0 +1,140 @@
+import {
+  CartDiscount,
+  CartDiscountChangeIsActiveAction,
+  CartDiscountChangeSortOrderAction,
+  CartDiscountDraft,
+  CartDiscountSetDescriptionAction,
+  CartDiscountSetKeyAction,
+  CartDiscountSetValidFromAction,
+  CartDiscountSetValidFromAndUntilAction,
+  CartDiscountSetValidUntilAction,
+  CartDiscountUpdateAction,
+  CartDiscountValueAbsolute,
+  CartDiscountValueDraft,
+  CartDiscountValueFixed,
+  CartDiscountValueGiftLineItem,
+  CartDiscountValueRelative,
+  ReferenceTypeId,
+} from '@commercetools/platform-sdk'
+import { Writable } from 'types'
+import { getBaseResourceProperties } from '../helpers'
+import { AbstractResourceRepository } from './abstract'
+import { createTypedMoney } from './helpers'
+
+export class CartDiscountRepository extends AbstractResourceRepository {
+  getTypeId(): ReferenceTypeId {
+    return 'cart-discount'
+  }
+
+  create(projectKey: string, draft: CartDiscountDraft): CartDiscount {
+    const resource: CartDiscount = {
+      ...getBaseResourceProperties(),
+      key: draft.key,
+      description: draft.description,
+      cartPredicate: draft.cartPredicate,
+      isActive: draft.isActive || false,
+      name: draft.name,
+      references: [],
+      target: draft.target,
+      requiresDiscountCode: draft.requiresDiscountCode || false,
+      sortOrder: draft.sortOrder,
+      stackingMode: draft.stackingMode || 'Stacking',
+      validFrom: draft.validFrom,
+      validUntil: draft.validUntil,
+      value: this.transformValueDraft(draft.value),
+    }
+    this.save(projectKey, resource)
+    return resource
+  }
+
+  private transformValueDraft(value: CartDiscountValueDraft) {
+    switch (value.type) {
+      case 'absolute': {
+        return {
+          type: 'absolute',
+          money: value.money.map(createTypedMoney),
+        } as CartDiscountValueAbsolute
+      }
+      case 'fixed': {
+        return {
+          type: 'fixed',
+          money: value.money.map(createTypedMoney),
+        } as CartDiscountValueFixed
+      }
+      case 'giftLineItem': {
+        return {
+          ...value,
+        } as CartDiscountValueGiftLineItem
+      }
+      case 'relative': {
+        return {
+          ...value,
+        } as CartDiscountValueRelative
+      }
+    }
+
+    return value
+  }
+
+  actions: Partial<
+    Record<
+      CartDiscountUpdateAction['action'],
+      (
+        projectKey: string,
+        resource: Writable<CartDiscount>,
+        action: any
+      ) => void
+    >
+  > = {
+    setKey: (
+      projectKey: string,
+      resource: Writable<CartDiscount>,
+      { key }: CartDiscountSetKeyAction
+    ) => {
+      resource.key = key
+    },
+    setDescription: (
+      projectKey: string,
+      resource: Writable<CartDiscount>,
+      { description }: CartDiscountSetDescriptionAction
+    ) => {
+      resource.description = description
+    },
+    setValidFrom: (
+      projectKey: string,
+      resource: Writable<CartDiscount>,
+      { validFrom }: CartDiscountSetValidFromAction
+    ) => {
+      resource.validFrom = validFrom
+    },
+    setValidUntil: (
+      projectKey: string,
+      resource: Writable<CartDiscount>,
+      { validUntil }: CartDiscountSetValidUntilAction
+    ) => {
+      resource.validUntil = validUntil
+    },
+    setValidFromAndUntil: (
+      projectKey: string,
+      resource: Writable<CartDiscount>,
+      { validFrom, validUntil }: CartDiscountSetValidFromAndUntilAction
+    ) => {
+      resource.validFrom = validFrom
+      resource.validUntil = validUntil
+    },
+    changeSortOrder: (
+      projectKey: string,
+      resource: Writable<CartDiscount>,
+      { sortOrder }: CartDiscountChangeSortOrderAction
+    ) => {
+      resource.sortOrder = sortOrder
+    },
+    changeIsActive: (
+      projectKey: string,
+      resource: Writable<CartDiscount>,
+      { isActive }: CartDiscountChangeIsActiveAction
+    ) => {
+      resource.isActive = isActive
+    },
+  }
+}