@labdigital/commercetools-mock 0.5.13 → 0.5.14

package/src/ctMock.ts

@@ -1,30 +1,42 @@
-import { ShoppingListService } from './services/shopping-list'
-import { ProductProjectionService } from './services/product-projection'
-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
@@ -57,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({
@@ -103,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 {
@@ -126,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
@@ -139,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,
@@ -153,8 +177,10 @@ export class CommercetoolsMock {
       '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) => {
@@ -165,6 +191,7 @@ export class CommercetoolsMock {
           errors: [err.info],
         })
       } else {
+        console.error(err)
         return resp.status(500).send({
           error: err.message,
         })

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

@@ -4,6 +4,7 @@ import deepEqual from 'deep-equal'
 import {
   BaseResource,
   InvalidOperationError,
+  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(): RepositoryTypes
+  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(), {
@@ -66,8 +97,6 @@ export default abstract class AbstractRepository {
   }
 
   save(projectKey: string, resource: BaseResource) {
-    const typeId = this.getTypeId()
-
     const current = this.get(projectKey, resource.id)
 
     if (current) {
@@ -86,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
+    },
+  }
+}

package/src/repositories/cart.ts

@@ -1,9 +1,30 @@
-import { Cart, CartDraft, ReferenceTypeId } from '@commercetools/platform-sdk'
+import {
+  Cart,
+  CartAddLineItemAction,
+  CartDraft,
+  CartRemoveLineItemAction,
+  CartSetBillingAddressAction,
+  CartSetCountryAction,
+  CartSetCustomerEmailAction,
+  CartSetCustomFieldAction,
+  CartSetCustomTypeAction,
+  CartSetLocaleAction,
+  CartSetShippingAddressAction,
+  GeneralError,
+  LineItem,
+  Product,
+  ProductPagedQueryResponse,
+  ProductVariant,
+  ReferenceTypeId,
+} from '@commercetools/platform-sdk'
+import { v4 as uuidv4 } from 'uuid'
 import { getBaseResourceProperties } from '../helpers'
-import AbstractRepository from './abstract'
+import { AbstractResourceRepository } from './abstract'
 import { createCustomFields } from './helpers'
+import { Writable } from '../types'
+import { CommercetoolsError } from '../exceptions'
 
-export class CartRepository extends AbstractRepository {
+export class CartRepository extends AbstractResourceRepository {
   getTypeId(): ReferenceTypeId {
     return 'cart'
   }
@@ -30,4 +51,227 @@ export class CartRepository extends AbstractRepository {
     this.save(projectKey, resource)
     return resource
   }
+
+  getActiveCart(projectKey: string): Cart | undefined {
+    // Get first active cart
+    const results = this._storage.query(projectKey, this.getTypeId(), {
+      where: [`cartState="Active"`],
+    })
+    if (results.count > 0) {
+      return results.results[0] as Cart
+    }
+
+    return
+  }
+
+  actions = {
+    addLineItem: (
+      projectKey: string,
+      resource: Writable<Cart>,
+      { productId, variantId, sku, quantity = 1 }: CartAddLineItemAction
+    ) => {
+      let product: Product | null = null
+      let variant: ProductVariant | undefined
+
+      if (productId && variantId) {
+        // Fetch product and variant by ID
+        product = this._storage.get(projectKey, 'product', productId, {})
+      } else if (sku) {
+        // Fetch product and variant by SKU
+        const items = this._storage.query(projectKey, 'product', {
+          where: [
+            `masterData(current(masterVariant(sku="${sku}"))) or masterData(current(variants(sku="${sku}")))`,
+          ],
+        }) as ProductPagedQueryResponse
+
+        if (items.count === 1) {
+          product = items.results[0]
+        }
+      }
+
+      if (!product) {
+        // Check if product is found
+        throw new CommercetoolsError<GeneralError>({
+          code: 'General',
+          message: sku
+            ? `A product containing a variant with SKU '${sku}' not found.`
+            : `A product with ID '${productId}' not found.`,
+        })
+      }
+
+      // Find matching variant
+      variant = [
+        product.masterData.current.masterVariant,
+        ...product.masterData.current.variants,
+      ].find(x => {
+        if (sku) return x.sku === sku
+        if (variantId) return x.id === variantId
+        return false
+      })
+
+      if (!variant) {
+        // Check if variant is found
+        throw new CommercetoolsError<GeneralError>({
+          code: 'General',
+          message: sku
+            ? `A variant with SKU '${sku}' for product '${product.id}' not found.`
+            : `A variant with ID '${variantId}' for product '${product.id}' not found.`,
+        })
+      }
+
+      const alreadyAdded = resource.lineItems.some(
+        x => x.productId === product?.id && x.variant.id === variant?.id
+      )
+      if (alreadyAdded) {
+        // increase quantity and update total price
+        resource.lineItems.map(x => {
+          if (x.productId === product?.id && x.variant.id === variant?.id) {
+            x.quantity += quantity
+            x.totalPrice.centAmount = calculateLineItemTotalPrice(x)
+          }
+          return x
+        })
+      } else {
+        // add line item
+        if (!variant.prices?.length) {
+          throw new CommercetoolsError<GeneralError>({
+            code: 'General',
+            message: `A product with ID '${productId}' doesn't have any prices.`,
+          })
+        }
+
+        const price = variant.prices[0]
+        resource.lineItems.push({
+          id: uuidv4(),
+          productId: product.id,
+          productKey: product.key,
+          name: product.masterData.current.name,
+          productSlug: product.masterData.current.slug,
+          productType: product.productType,
+          variant,
+          price: price,
+          totalPrice: {
+            ...price.value,
+            centAmount: price.value.centAmount * quantity,
+          },
+          quantity,
+          discountedPricePerQuantity: [],
+          lineItemMode: 'Standard',
+          priceMode: 'Platform',
+          state: [],
+        })
+      }
+
+      // Update cart total price
+      resource.totalPrice.centAmount = calculateCartTotalPrice(resource)
+    },
+    removeLineItem: (
+      projectKey: string,
+      resource: Writable<Cart>,
+      { lineItemId, quantity }: CartRemoveLineItemAction
+    ) => {
+      const lineItem = resource.lineItems.find(x => x.id === lineItemId)
+      if (!lineItem) {
+        // Check if product is found
+        throw new CommercetoolsError<GeneralError>({
+          code: 'General',
+          message: `A line item with ID '${lineItemId}' not found.`,
+        })
+      }
+
+      const shouldDelete = !quantity || quantity >= lineItem.quantity
+      if (shouldDelete) {
+        // delete line item
+        resource.lineItems = resource.lineItems.filter(x => x.id !== lineItemId)
+      } else {
+        // decrease quantity and update total price
+        resource.lineItems.map(x => {
+          if (x.id === lineItemId && quantity) {
+            x.quantity -= quantity
+            x.totalPrice.centAmount = calculateLineItemTotalPrice(x)
+          }
+          return x
+        })
+      }
+
+      // Update cart total price
+      resource.totalPrice.centAmount = calculateCartTotalPrice(resource)
+    },
+    setBillingAddress: (
+      projectKey: string,
+      resource: Writable<Cart>,
+      { address }: CartSetBillingAddressAction
+    ) => {
+      resource.billingAddress = address
+    },
+    setCountry: (
+      projectKey: string,
+      resource: Writable<Cart>,
+      { country }: CartSetCountryAction
+    ) => {
+      resource.country = country
+    },
+    setCustomerEmail: (
+      projectKey: string,
+      resource: Writable<Cart>,
+      { email }: CartSetCustomerEmailAction
+    ) => {
+      resource.customerEmail = email
+    },
+    setCustomField: (
+      projectKey: string,
+      resource: Cart,
+      { name, value }: CartSetCustomFieldAction
+    ) => {
+      if (!resource.custom) {
+        throw new Error('Resource has no custom field')
+      }
+      resource.custom.fields[name] = value
+    },
+    setCustomType: (
+      projectKey: string,
+      resource: Writable<Cart>,
+      { type, fields }: CartSetCustomTypeAction
+    ) => {
+      if (!type) {
+        resource.custom = undefined
+      } else {
+        const resolvedType = this._storage.getByResourceIdentifier(
+          projectKey,
+          type
+        )
+        if (!resolvedType) {
+          throw new Error(`Type ${type} not found`)
+        }
+
+        resource.custom = {
+          type: {
+            typeId: 'type',
+            id: resolvedType.id,
+          },
+          fields: fields || [],
+        }
+      }
+    },
+    setLocale: (
+      projectKey: string,
+      resource: Writable<Cart>,
+      { locale }: CartSetLocaleAction
+    ) => {
+      resource.locale = locale
+    },
+    setShippingAddress: (
+      projectKey: string,
+      resource: Writable<Cart>,
+      { address }: CartSetShippingAddressAction
+    ) => {
+      resource.shippingAddress = address
+    },
+  }
 }
+
+const calculateLineItemTotalPrice = (lineItem: LineItem): number =>
+  lineItem.price!.value.centAmount * lineItem.quantity
+
+const calculateCartTotalPrice = (cart: Cart): number =>
+  cart.lineItems.reduce((cur, item) => cur + item.totalPrice.centAmount, 0)