@labdigital/commercetools-mock 0.5.20 → 0.5.23

package/dist/projectAPI.d.ts

@@ -1,3 +1,4 @@
+import { GetParams } from 'repositories/abstract';
 import { AbstractStorage } from './storage';
 import { RepositoryMap, ResourceMap, Services } from './types';
 export declare class ProjectAPI {
@@ -6,6 +7,6 @@ export declare class ProjectAPI {
     private _services;
     constructor(projectKey: string, services: Services, storage: AbstractStorage);
     add<ReferenceTypeId extends keyof ResourceMap>(typeId: ReferenceTypeId | 'custom-object', resource: ResourceMap[ReferenceTypeId]): void;
-    get<ReferenceTypeId extends keyof ResourceMap>(typeId: ReferenceTypeId, id: string): ResourceMap[ReferenceTypeId];
+    get<ReferenceTypeId extends keyof ResourceMap>(typeId: ReferenceTypeId, id: string, params: GetParams): ResourceMap[ReferenceTypeId];
     getRepository<ReferenceTypeId extends keyof RepositoryMap>(typeId: ReferenceTypeId): RepositoryMap[ReferenceTypeId];
 }

package/dist/repositories/cart.d.ts

@@ -1,4 +1,4 @@
-import { Cart, CartAddLineItemAction, CartDraft, CartRemoveLineItemAction, CartSetBillingAddressAction, CartSetCountryAction, CartSetCustomerEmailAction, CartSetCustomFieldAction, CartSetCustomTypeAction, CartSetLocaleAction, CartSetShippingAddressAction, ReferenceTypeId } from '@commercetools/platform-sdk';
+import { Cart, CartAddLineItemAction, CartDraft, CartRemoveLineItemAction, CartSetBillingAddressAction, CartSetCountryAction, CartSetCustomerEmailAction, CartSetCustomFieldAction, CartSetCustomTypeAction, CartSetLocaleAction, CartSetShippingAddressAction, CartSetShippingMethodAction, LineItem, LineItemDraft, ReferenceTypeId } from '@commercetools/platform-sdk';
 import { AbstractResourceRepository } from './abstract';
 import { Writable } from '../types';
 export declare class CartRepository extends AbstractResourceRepository {
@@ -9,6 +9,7 @@ export declare class CartRepository extends AbstractResourceRepository {
         addLineItem: (projectKey: string, resource: Writable<Cart>, { productId, variantId, sku, quantity }: CartAddLineItemAction) => void;
         removeLineItem: (projectKey: string, resource: Writable<Cart>, { lineItemId, quantity }: CartRemoveLineItemAction) => void;
         setBillingAddress: (projectKey: string, resource: Writable<Cart>, { address }: CartSetBillingAddressAction) => void;
+        setShippingMethod: (projectKey: string, resource: Writable<Cart>, { shippingMethod }: CartSetShippingMethodAction) => void;
         setCountry: (projectKey: string, resource: Writable<Cart>, { country }: CartSetCountryAction) => void;
         setCustomerEmail: (projectKey: string, resource: Writable<Cart>, { email }: CartSetCustomerEmailAction) => void;
         setCustomField: (projectKey: string, resource: Cart, { name, value }: CartSetCustomFieldAction) => void;
@@ -16,4 +17,5 @@ export declare class CartRepository extends AbstractResourceRepository {
         setLocale: (projectKey: string, resource: Writable<Cart>, { locale }: CartSetLocaleAction) => void;
         setShippingAddress: (projectKey: string, resource: Writable<Cart>, { address }: CartSetShippingAddressAction) => void;
     };
+    draftLineItemtoLineItem: (projectKey: string, draftLineItem: LineItemDraft) => LineItem;
 }

package/dist/repositories/order.d.ts

@@ -1,4 +1,4 @@
-import { Order, OrderAddPaymentAction, OrderChangeOrderStateAction, OrderChangePaymentStateAction, OrderFromCartDraft, OrderImportDraft, OrderSetBillingAddressAction, OrderSetCustomerEmailAction, OrderSetCustomFieldAction, OrderSetCustomTypeAction, OrderSetLocaleAction, OrderSetOrderNumberAction, OrderSetShippingAddressAction, OrderSetStoreAction, ReferenceTypeId } from '@commercetools/platform-sdk';
+import { Order, OrderAddPaymentAction, OrderChangeOrderStateAction, OrderChangePaymentStateAction, OrderFromCartDraft, OrderImportDraft, OrderSetBillingAddressAction, OrderSetCustomerEmailAction, OrderSetCustomFieldAction, OrderSetCustomTypeAction, OrderSetLocaleAction, OrderSetOrderNumberAction, OrderSetShippingAddressAction, OrderSetStoreAction, OrderTransitionStateAction, ReferenceTypeId } from '@commercetools/platform-sdk';
 import { AbstractResourceRepository, QueryParams } from './abstract';
 import { Writable } from '../types';
 export declare class OrderRepository extends AbstractResourceRepository {
@@ -12,6 +12,7 @@ export declare class OrderRepository extends AbstractResourceRepository {
         addPayment: (projectKey: string, resource: Writable<Order>, { payment }: OrderAddPaymentAction) => void;
         changeOrderState: (projectKey: string, resource: Writable<Order>, { orderState }: OrderChangeOrderStateAction) => void;
         changePaymentState: (projectKey: string, resource: Writable<Order>, { paymentState }: OrderChangePaymentStateAction) => void;
+        transitionState: (projectKey: string, resource: Writable<Order>, { state }: OrderTransitionStateAction) => void;
         setBillingAddress: (projectKey: string, resource: Writable<Order>, { address }: OrderSetBillingAddressAction) => void;
         setCustomerEmail: (projectKey: string, resource: Writable<Order>, { email }: OrderSetCustomerEmailAction) => void;
         setCustomField: (projectKey: string, resource: Order, { name, value }: OrderSetCustomFieldAction) => void;

package/dist/services/cart.d.ts

@@ -2,8 +2,11 @@ import AbstractService from './abstract';
 import { Router } from 'express';
 import { CartRepository } from '../repositories/cart';
 import { AbstractStorage } from '../storage';
+import { OrderRepository } from '../repositories/order';
 export declare class CartService extends AbstractService {
     repository: CartRepository;
+    orderRepository: OrderRepository;
     constructor(parent: Router, storage: AbstractStorage);
     getBasePath(): string;
+    extraRoutes(parent: Router): void;
 }

package/dist/services/my-customer.d.ts

@@ -9,4 +9,5 @@ export declare class MyCustomerService extends AbstractService {
     registerRoutes(parent: Router): void;
     getMe(request: Request, response: Response): Response<any, Record<string, any>>;
     signUp(request: Request, response: Response): Response<any, Record<string, any>>;
+    signIn(request: Request, response: Response): Response<any, Record<string, any>>;
 }

package/dist/services/my-order.d.ts

@@ -0,0 +1,10 @@
+import AbstractService from './abstract';
+import { Router } from 'express';
+import { AbstractStorage } from '../storage';
+import { OrderRepository } from '../repositories/order';
+export declare class MyOrderService extends AbstractService {
+    repository: OrderRepository;
+    constructor(parent: Router, storage: AbstractStorage);
+    getBasePath(): string;
+    registerRoutes(parent: Router): void;
+}

package/dist/types.d.ts

@@ -18,7 +18,7 @@ export declare type Writable<T> = {
     -readonly [P in keyof T]: Writable<T[P]>;
 };
 export declare type RepositoryTypes = ReferenceTypeId | 'product-projection';
-export declare type ServiceTypes = RepositoryTypes | 'my-cart' | 'my-payment' | 'my-customer';
+export declare type ServiceTypes = RepositoryTypes | 'my-cart' | 'my-order' | 'my-payment' | 'my-customer';
 export declare type Services = Partial<{
     [index in ServiceTypes]: AbstractService;
 }>;

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.5.20",
+  "version": "0.5.23",
   "license": "MIT",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",

package/src/ctMock.ts

@@ -38,6 +38,7 @@ 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'
 
 export type CommercetoolsMockOptions = {
   validateCredentials: boolean
@@ -164,6 +165,7 @@ export class CommercetoolsMock {
       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(

package/src/projectAPI.ts

@@ -1,3 +1,4 @@
+import { GetParams } from 'repositories/abstract'
 import { getBaseResourceProperties } from './helpers'
 import { AbstractStorage } from './storage'
 import { RepositoryMap, ResourceMap, Services } from './types'
@@ -39,13 +40,14 @@ export class ProjectAPI {
 
   get<ReferenceTypeId extends keyof ResourceMap>(
     typeId: ReferenceTypeId,
-    id: string
+    id: string,
+    params: GetParams
   ): ResourceMap[ReferenceTypeId] {
     return this._storage.get(
       this.projectKey,
       typeId,
       id,
-      {}
+      params
     ) as ResourceMap[ReferenceTypeId]
   }
 

package/src/repositories/abstract.ts

@@ -44,6 +44,7 @@ export abstract class AbstractRepository {
 
     actions.forEach(action => {
       const updateFunc = this.actions[action.action]
+
       if (!updateFunc) {
         console.error(`No mock implemented for update action ${action.action}`)
         return

package/src/repositories/cart.ts

@@ -10,8 +10,10 @@ import {
   CartSetCustomTypeAction,
   CartSetLocaleAction,
   CartSetShippingAddressAction,
+  CartSetShippingMethodAction,
   GeneralError,
   LineItem,
+  LineItemDraft,
   Product,
   ProductPagedQueryResponse,
   ProductVariant,
@@ -30,10 +32,14 @@ export class CartRepository extends AbstractResourceRepository {
   }
 
   create(projectKey: string, draft: CartDraft): Cart {
+    const lineItems = draft.lineItems?.map(draftLineItem =>
+      this.draftLineItemtoLineItem(projectKey, draftLineItem)
+    )
+
     const resource: Cart = {
       ...getBaseResourceProperties(),
       cartState: 'Active',
-      lineItems: [],
+      lineItems: lineItems ?? [],
       customLineItems: [],
       totalPrice: {
         type: 'centPrecision',
@@ -48,6 +54,10 @@ export class CartRepository extends AbstractResourceRepository {
       origin: 'Customer',
       custom: createCustomFields(draft.custom, projectKey, this._storage),
     }
+
+    // @ts-ignore
+    resource.totalPrice.centAmount = calculateCartTotalPrice(resource)
+
     this.save(projectKey, resource)
     return resource
   }
@@ -204,6 +214,28 @@ export class CartRepository extends AbstractResourceRepository {
     ) => {
       resource.billingAddress = address
     },
+    setShippingMethod: (
+      projectKey: string,
+      resource: Writable<Cart>,
+      { shippingMethod }: CartSetShippingMethodAction
+    ) => {
+      const resolvedType = this._storage.getByResourceIdentifier(
+        projectKey,
+        //@ts-ignore
+        shippingMethod
+      )
+
+      if (!resolvedType) {
+        throw new Error(`Type ${shippingMethod} not found`)
+      }
+      //@ts-ignore
+      resource.shippingInfo = {
+        shippingMethod: {
+          typeId: 'shipping-method',
+          id: resolvedType.id,
+        },
+      }
+    },
     setCountry: (
       projectKey: string,
       resource: Writable<Cart>,
@@ -268,6 +300,91 @@ export class CartRepository extends AbstractResourceRepository {
       resource.shippingAddress = address
     },
   }
+  draftLineItemtoLineItem = (
+    projectKey: string,
+    draftLineItem: LineItemDraft
+  ): LineItem => {
+    const { productId, quantity } = draftLineItem
+    // @ts-ignore
+    let variantId = draftLineItem.variant.id
+    // @ts-ignore
+    let sku = draftLineItem.variant.sku
+    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 Error(
+        sku
+          ? `A variant with SKU '${sku}' for product '${product.id}' not found.`
+          : `A variant with ID '${variantId}' for product '${product.id}' not found.`
+      )
+    }
+
+    const price = variant.prices?.[0]
+
+    const quant = quantity ?? 1
+
+    if (!price) {
+      throw new Error(`Price not set on ${productId}`)
+    }
+
+    return {
+      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 * quant,
+      },
+      quantity: quant,
+      discountedPricePerQuantity: [],
+      lineItemMode: 'Standard',
+      priceMode: 'Platform',
+      state: [],
+    }
+  }
 }
 
 const calculateLineItemTotalPrice = (lineItem: LineItem): number =>

package/src/repositories/customer.ts

@@ -12,6 +12,7 @@ export class CustomerRepository extends AbstractResourceRepository {
   getTypeId(): ReferenceTypeId {
     return 'customer'
   }
+
   create(projectKey: string, draft: CustomerDraft): Customer {
     const resource: Customer = {
       ...getBaseResourceProperties(),
@@ -23,6 +24,7 @@ export class CustomerRepository extends AbstractResourceRepository {
     this.save(projectKey, resource)
     return resource
   }
+
   getMe(projectKey: string): Customer | undefined {
     const results = this._storage.query(projectKey, this.getTypeId(), {}) // grab the first customer you can find
     if (results.count > 0) {

package/src/repositories/helpers.ts

@@ -24,7 +24,6 @@ export const createCustomFields = (
   if (!draft.type) return undefined
   if (!draft.type.typeId) return undefined
   if (!draft.fields) return undefined
-
   const typeResource = storage.getByResourceIdentifier(
     projectKey,
     draft.type

package/src/repositories/order.ts

@@ -20,10 +20,14 @@ import {
   OrderSetOrderNumberAction,
   OrderSetShippingAddressAction,
   OrderSetStoreAction,
+  OrderState,
+  OrderStateTransitionMessage,
+  OrderTransitionStateAction,
   Product,
   ProductPagedQueryResponse,
   ProductVariant,
   ReferenceTypeId,
+  State,
   Store,
 } from '@commercetools/platform-sdk'
 import { AbstractResourceRepository, QueryParams } from './abstract'
@@ -252,6 +256,24 @@ export class OrderRepository extends AbstractResourceRepository {
     ) => {
       resource.paymentState = paymentState
     },
+    transitionState: (
+      projectKey: string,
+      resource: Writable<Order>,
+      { state }: OrderTransitionStateAction
+    ) => {
+      const resolvedType = this._storage.getByResourceIdentifier(
+        projectKey,
+        state
+      ) as State | null
+
+      if (!resolvedType) {
+        throw new Error(
+          `No state found with key=${state.key} or id=${state.key}`
+        )
+      }
+
+      resource.state = { typeId: 'state', id: resolvedType.id }
+    },
     setBillingAddress: (
       projectKey: string,
       resource: Writable<Order>,

package/src/services/cart.ts

@@ -2,16 +2,48 @@ import AbstractService from './abstract'
 import { Router } from 'express'
 import { CartRepository } from '../repositories/cart'
 import { AbstractStorage } from '../storage'
+import { Cart, Order } from '@commercetools/platform-sdk'
+import { OrderRepository } from '../repositories/order'
 
 export class CartService extends AbstractService {
   public repository: CartRepository
+  public orderRepository: OrderRepository
 
   constructor(parent: Router, storage: AbstractStorage) {
     super(parent)
     this.repository = new CartRepository(storage)
+    this.orderRepository = new OrderRepository(storage)
   }
 
   getBasePath() {
     return 'carts'
   }
+
+  extraRoutes(parent: Router) {
+    parent.post('/replicate', (request, response) => {
+      // @ts-ignore
+      const cartOrOrder: Cart | Order | null =
+        request.body.reference.typeId === 'order'
+          ? this.orderRepository.get(
+              request.params.projectKey,
+              request.body.reference.id
+            )
+          : this.repository.get(
+              request.params.projectKey,
+              request.body.reference.id
+            )
+
+      if (!cartOrOrder) {
+        return response.status(400).send()
+      }
+
+      const newCart = this.repository.create(request.params.projectKey, {
+        ...cartOrOrder,
+        currency: cartOrOrder.totalPrice.currencyCode,
+        discountCodes: [],
+      })
+
+      return response.status(200).send(newCart)
+    })
+  }
 }

package/src/services/my-customer.ts

@@ -26,6 +26,8 @@ export class MyCustomerService extends AbstractService {
 
     router.post('/signup', this.signUp.bind(this))
 
+    router.post('/login', this.signIn.bind(this))
+
     parent.use(`/${basePath}`, router)
   }
 
@@ -43,4 +45,27 @@ export class MyCustomerService extends AbstractService {
     const result = this._expandWithId(request, resource.id)
     return response.status(this.createStatusCode).send({ customer: result })
   }
+
+  signIn(request: Request, response: Response) {
+    const { email, password } = request.body
+    const encodedPassword = Buffer.from(password).toString('base64')
+
+    const result = this.repository.query(request.params.projectKey, {
+      where: [`email = "${email}"`, `password = "${encodedPassword}"`],
+    })
+
+    if (result.count === 0) {
+      return response.status(400).send({
+        message: 'Account with the given credentials not found.',
+        errors: [
+          {
+            code: 'InvalidCredentials',
+            message: 'Account with the given credentials not found.',
+          },
+        ],
+      })
+    }
+
+    return response.status(200).send({ customer: result.results[0] })
+  }
 }

package/src/services/my-order.ts

@@ -0,0 +1,35 @@
+import AbstractService from './abstract'
+import { Router } from 'express'
+import { AbstractStorage } from '../storage'
+import { OrderRepository } from '../repositories/order'
+
+export class MyOrderService extends AbstractService {
+  public repository: OrderRepository
+
+  constructor(parent: Router, storage: AbstractStorage) {
+    super(parent)
+    this.repository = new OrderRepository(storage)
+  }
+
+  getBasePath() {
+    return 'me'
+  }
+
+  registerRoutes(parent: Router) {
+    // Overwrite this function to be able to handle /me/active-cart path.
+    const basePath = this.getBasePath()
+    const router = Router({ mergeParams: true })
+
+    this.extraRoutes(router)
+
+    router.get('/orders/', this.get.bind(this))
+    router.get('/orders/:id', this.getWithId.bind(this))
+
+    router.delete('/orders/:id', this.deletewithId.bind(this))
+
+    router.post('/orders/', this.post.bind(this))
+    router.post('/orders/:id', this.postWithId.bind(this))
+
+    parent.use(`/${basePath}`, router)
+  }
+}

package/src/types.ts

@@ -21,6 +21,7 @@ export type RepositoryTypes = ReferenceTypeId | 'product-projection'
 export type ServiceTypes =
   | RepositoryTypes
   | 'my-cart'
+  | 'my-order'
   | 'my-payment'
   | 'my-customer'