@labdigital/commercetools-mock 0.5.21 → 0.6.0

package/dist/commercetools-mock.cjs.development.js

@@ -926,8 +926,8 @@ class ProjectAPI {
     }
   }
 
-  get(typeId, id) {
-    return this._storage.get(this.projectKey, typeId, id, {});
+  get(typeId, id, params) {
+    return this._storage.get(this.projectKey, typeId, id, params);
   } // TODO: Not sure if we want to expose this...
 
 
@@ -1486,6 +1486,24 @@ class CartRepository extends AbstractResourceRepository {
       }) => {
         resource.billingAddress = address;
       },
+      setShippingMethod: (projectKey, resource, {
+        shippingMethod
+      }) => {
+        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, resource, {
         country
       }) => {
@@ -1539,6 +1557,81 @@ class CartRepository extends AbstractResourceRepository {
         resource.shippingAddress = address;
       }
     };
+
+    this.draftLineItemtoLineItem = (projectKey, draftLineItem) => {
+      var _variant$prices2;
+
+      const {
+        productId,
+        quantity
+      } = draftLineItem; // @ts-ignore
+
+      let variantId = draftLineItem.variant.id; // @ts-ignore
+
+      let sku = draftLineItem.variant.sku;
+      let product = null;
+      let variant;
+
+      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}")))`]
+        });
+
+        if (items.count === 1) {
+          product = items.results[0];
+        }
+      }
+
+      if (!product) {
+        // Check if product is found
+        throw new CommercetoolsError({
+          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$prices2 = variant.prices) == null ? void 0 : _variant$prices2[0];
+      const quant = quantity != null ? quantity : 1;
+
+      if (!price) {
+        throw new Error(`Price not set on ${productId}`);
+      }
+
+      return {
+        id: uuid.v4(),
+        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: []
+      };
+    };
   }
 
   getTypeId() {
@@ -1546,9 +1639,12 @@ class CartRepository extends AbstractResourceRepository {
   }
 
   create(projectKey, draft) {
+    var _draft$lineItems;
+
+    const lineItems = (_draft$lineItems = draft.lineItems) == null ? void 0 : _draft$lineItems.map(draftLineItem => this.draftLineItemtoLineItem(projectKey, draftLineItem));
     const resource = { ...getBaseResourceProperties(),
       cartState: 'Active',
-      lineItems: [],
+      lineItems: lineItems != null ? lineItems : [],
       customLineItems: [],
       totalPrice: {
         type: 'centPrecision',
@@ -1562,7 +1658,9 @@ class CartRepository extends AbstractResourceRepository {
       refusedGifts: [],
       origin: 'Customer',
       custom: createCustomFields(draft.custom, projectKey, this._storage)
-    };
+    }; // @ts-ignore
+
+    resource.totalPrice.centAmount = calculateCartTotalPrice(resource);
     this.save(projectKey, resource);
     return resource;
   }
@@ -1586,16 +1684,308 @@ const calculateLineItemTotalPrice = lineItem => lineItem.price.value.centAmount
 
 const calculateCartTotalPrice = cart => cart.lineItems.reduce((cur, item) => cur + item.totalPrice.centAmount, 0);
 
+class OrderRepository extends AbstractResourceRepository {
+  constructor() {
+    super(...arguments);
+    this.actions = {
+      addPayment: (projectKey, resource, {
+        payment
+      }) => {
+        const resolvedPayment = this._storage.getByResourceIdentifier(projectKey, payment);
+
+        if (!resolvedPayment) {
+          throw new Error(`Payment ${payment.id} not found`);
+        }
+
+        if (!resource.paymentInfo) {
+          resource.paymentInfo = {
+            payments: []
+          };
+        }
+
+        resource.paymentInfo.payments.push({
+          typeId: 'payment',
+          id: payment.id
+        });
+      },
+      changeOrderState: (projectKey, resource, {
+        orderState
+      }) => {
+        resource.orderState = orderState;
+      },
+      changePaymentState: (projectKey, resource, {
+        paymentState
+      }) => {
+        resource.paymentState = paymentState;
+      },
+      transitionState: (projectKey, resource, {
+        state
+      }) => {
+        const resolvedType = this._storage.getByResourceIdentifier(projectKey, state);
+
+        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, resource, {
+        address
+      }) => {
+        resource.billingAddress = address;
+      },
+      setCustomerEmail: (projectKey, resource, {
+        email
+      }) => {
+        resource.customerEmail = email;
+      },
+      setCustomField: (projectKey, resource, {
+        name,
+        value
+      }) => {
+        if (!resource.custom) {
+          throw new Error('Resource has no custom field');
+        }
+
+        resource.custom.fields[name] = value;
+      },
+      setCustomType: (projectKey, resource, {
+        type,
+        fields
+      }) => {
+        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, resource, {
+        locale
+      }) => {
+        resource.locale = locale;
+      },
+      setOrderNumber: (projectKey, resource, {
+        orderNumber
+      }) => {
+        resource.orderNumber = orderNumber;
+      },
+      setShippingAddress: (projectKey, resource, {
+        address
+      }) => {
+        resource.shippingAddress = address;
+      },
+      setStore: (projectKey, resource, {
+        store
+      }) => {
+        if (!store) return;
+
+        const resolvedType = this._storage.getByResourceIdentifier(projectKey, store);
+
+        if (!resolvedType) {
+          throw new Error(`No store found with key=${store.key}`);
+        }
+
+        const storeReference = resolvedType;
+        resource.store = {
+          typeId: 'store',
+          key: storeReference.key
+        };
+      }
+    };
+  }
+
+  getTypeId() {
+    return 'order';
+  }
+
+  create(projectKey, draft) {
+    assert(draft.cart, 'draft.cart is missing');
+
+    const cart = this._storage.getByResourceIdentifier(projectKey, draft.cart);
+
+    if (!cart) {
+      throw new Error('Cannot find cart');
+    }
+
+    const resource = { ...getBaseResourceProperties(),
+      orderNumber: draft.orderNumber,
+      orderState: 'Open',
+      lineItems: [],
+      customLineItems: [],
+      totalPrice: cart.totalPrice,
+      refusedGifts: [],
+      origin: 'Customer',
+      syncInfo: [],
+      lastMessageSequenceNumber: 0
+    };
+    this.save(projectKey, resource);
+    return resource;
+  }
+
+  import(projectKey, draft) {
+    var _draft$lineItems, _draft$customLineItem;
+
+    // TODO: Check if order with given orderNumber already exists
+    assert(this, 'OrderRepository not valid');
+    const resource = { ...getBaseResourceProperties(),
+      billingAddress: draft.billingAddress,
+      shippingAddress: draft.shippingAddress,
+      custom: createCustomFields(draft.custom, projectKey, this._storage),
+      customerEmail: draft.customerEmail,
+      lastMessageSequenceNumber: 0,
+      orderNumber: draft.orderNumber,
+      orderState: draft.orderState || 'Open',
+      origin: draft.origin || 'Customer',
+      paymentState: draft.paymentState,
+      refusedGifts: [],
+      store: resolveStoreReference(draft.store, projectKey, this._storage),
+      syncInfo: [],
+      lineItems: ((_draft$lineItems = draft.lineItems) == null ? void 0 : _draft$lineItems.map(item => this.lineItemFromImportDraft.bind(this)(projectKey, item))) || [],
+      customLineItems: ((_draft$customLineItem = draft.customLineItems) == null ? void 0 : _draft$customLineItem.map(item => this.customLineItemFromImportDraft.bind(this)(projectKey, item))) || [],
+      totalPrice: {
+        type: 'centPrecision',
+        ...draft.totalPrice,
+        fractionDigits: 2
+      }
+    };
+    this.save(projectKey, resource);
+    return resource;
+  }
+
+  lineItemFromImportDraft(projectKey, draft) {
+    let product;
+    let variant;
+
+    if (draft.variant.sku) {
+      variant = {
+        id: 0,
+        sku: draft.variant.sku
+      };
+
+      var items = this._storage.query(projectKey, 'product', {
+        where: [`masterData(current(masterVariant(sku="${draft.variant.sku}"))) or masterData(current(variants(sku="${draft.variant.sku}")))`]
+      });
+
+      if (items.count !== 1) {
+        throw new CommercetoolsError({
+          code: 'General',
+          message: `A product containing a variant with SKU '${draft.variant.sku}' not found.`
+        });
+      }
+
+      product = items.results[0];
+
+      if (product.masterData.current.masterVariant.sku === draft.variant.sku) {
+        variant = product.masterData.current.masterVariant;
+      } else {
+        variant = product.masterData.current.variants.find(v => v.sku === draft.variant.sku);
+      }
+
+      if (!variant) {
+        throw new Error('Internal state error');
+      }
+    } else {
+      throw new Error('No product found');
+    }
+
+    const lineItem = { ...getBaseResourceProperties(),
+      custom: createCustomFields(draft.custom, projectKey, this._storage),
+      discountedPricePerQuantity: [],
+      lineItemMode: 'Standard',
+      name: draft.name,
+      price: createPrice(draft.price),
+      priceMode: 'Platform',
+      productId: product.id,
+      productType: product.productType,
+      quantity: draft.quantity,
+      state: draft.state || [],
+      taxRate: draft.taxRate,
+      totalPrice: createTypedMoney(draft.price.value),
+      variant: {
+        id: variant.id,
+        sku: variant.sku,
+        price: createPrice(draft.price)
+      }
+    };
+    return lineItem;
+  }
+
+  customLineItemFromImportDraft(projectKey, draft) {
+    const lineItem = { ...getBaseResourceProperties(),
+      custom: createCustomFields(draft.custom, projectKey, this._storage),
+      discountedPricePerQuantity: [],
+      money: createTypedMoney(draft.money),
+      name: draft.name,
+      quantity: draft.quantity,
+      slug: draft.slug,
+      state: [],
+      totalPrice: createTypedMoney(draft.money)
+    };
+    return lineItem;
+  }
+
+  getWithOrderNumber(projectKey, orderNumber, params = {}) {
+    const result = this._storage.query(projectKey, this.getTypeId(), { ...params,
+      where: [`orderNumber="${orderNumber}"`]
+    });
+
+    if (result.count === 1) {
+      return result.results[0];
+    } // Catch this for now, should be checked when creating/updating
+
+
+    if (result.count > 1) {
+      throw new Error('Duplicate order numbers');
+    }
+
+    return;
+  }
+
+}
+
 class CartService extends AbstractService {
   constructor(parent, storage) {
     super(parent);
     this.repository = new CartRepository(storage);
+    this.orderRepository = new OrderRepository(storage);
   }
 
   getBasePath() {
     return 'carts';
   }
 
+  extraRoutes(parent) {
+    parent.post('/replicate', (request, response) => {
+      // @ts-ignore
+      const cartOrOrder = 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);
+    });
+  }
+
 }
 
 class CategoryRepository extends AbstractResourceRepository {
@@ -1825,7 +2215,7 @@ class CustomerRepository extends AbstractResourceRepository {
   create(projectKey, draft) {
     const resource = { ...getBaseResourceProperties(),
       email: draft.email,
-      password: Buffer.from(draft.password).toString('base64'),
+      password: draft.password ? Buffer.from(draft.password).toString('base64') : undefined,
       isEmailVerified: draft.isEmailVerified || false,
       addresses: []
     };
@@ -2264,155 +2654,13 @@ class PaymentRepository extends AbstractResourceRepository {
   constructor() {
     super(...arguments);
 
-    this.transactionFromTransactionDraft = (draft, projectKey) => ({ ...draft,
-      id: uuid.v4(),
-      amount: createTypedMoney(draft.amount),
-      custom: createCustomFields(draft.custom, projectKey, this._storage)
-    });
-
-    this.actions = {
-      setCustomField: (projectKey, resource, {
-        name,
-        value
-      }) => {
-        if (!resource.custom) {
-          throw new Error('Resource has no custom field');
-        }
-
-        resource.custom.fields[name] = value;
-      },
-      setCustomType: (projectKey, resource, {
-        type,
-        fields
-      }) => {
-        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 || []
-          };
-        }
-      },
-      addTransaction: (projectKey, resource, {
-        transaction
-      }) => {
-        resource.transactions = [...resource.transactions, this.transactionFromTransactionDraft(transaction, projectKey)];
-      },
-      changeTransactionState: (_projectKey, resource, {
-        transactionId,
-        state
-      }) => {
-        const index = resource.transactions.findIndex(e => e.id === transactionId);
-        const updatedTransaction = { ...resource.transactions[index],
-          state
-        };
-        resource.transactions[index] = updatedTransaction;
-      },
-      transitionState: (projectKey, resource, {
-        state
-      }) => {
-        const stateObj = this._storage.getByResourceIdentifier(projectKey, state);
-
-        if (!stateObj) {
-          throw new Error(`State ${state} not found`);
-        }
-
-        resource.paymentStatus.state = {
-          typeId: 'state',
-          id: stateObj.id,
-          obj: stateObj
-        };
-      }
-    };
-  }
-
-  getTypeId() {
-    return 'payment';
-  }
-
-  create(projectKey, draft) {
-    const resource = { ...getBaseResourceProperties(),
-      amountPlanned: createTypedMoney(draft.amountPlanned),
-      paymentMethodInfo: draft.paymentMethodInfo,
-      paymentStatus: draft.paymentStatus ? { ...draft.paymentStatus,
-        state: draft.paymentStatus.state ? getReferenceFromResourceIdentifier(draft.paymentStatus.state, projectKey, this._storage) : undefined
-      } : {},
-      transactions: (draft.transactions || []).map(t => this.transactionFromTransactionDraft(t, projectKey)),
-      interfaceInteractions: (draft.interfaceInteractions || []).map(interaction => createCustomFields(interaction, projectKey, this._storage)),
-      custom: createCustomFields(draft.custom, projectKey, this._storage)
-    };
-    this.save(projectKey, resource);
-    return resource;
-  }
-
-}
-
-class MyPaymentService extends AbstractService {
-  constructor(parent, storage) {
-    super(parent);
-    this.repository = new PaymentRepository(storage);
-  }
-
-  getBasePath() {
-    return 'me/payments';
-  }
-
-}
-
-class OrderRepository extends AbstractResourceRepository {
-  constructor() {
-    super(...arguments);
-    this.actions = {
-      addPayment: (projectKey, resource, {
-        payment
-      }) => {
-        const resolvedPayment = this._storage.getByResourceIdentifier(projectKey, payment);
-
-        if (!resolvedPayment) {
-          throw new Error(`Payment ${payment.id} not found`);
-        }
-
-        if (!resource.paymentInfo) {
-          resource.paymentInfo = {
-            payments: []
-          };
-        }
+    this.transactionFromTransactionDraft = (draft, projectKey) => ({ ...draft,
+      id: uuid.v4(),
+      amount: createTypedMoney(draft.amount),
+      custom: createCustomFields(draft.custom, projectKey, this._storage)
+    });
 
-        resource.paymentInfo.payments.push({
-          typeId: 'payment',
-          id: payment.id
-        });
-      },
-      changeOrderState: (projectKey, resource, {
-        orderState
-      }) => {
-        resource.orderState = orderState;
-      },
-      changePaymentState: (projectKey, resource, {
-        paymentState
-      }) => {
-        resource.paymentState = paymentState;
-      },
-      setBillingAddress: (projectKey, resource, {
-        address
-      }) => {
-        resource.billingAddress = address;
-      },
-      setCustomerEmail: (projectKey, resource, {
-        email
-      }) => {
-        resource.customerEmail = email;
-      },
+    this.actions = {
       setCustomField: (projectKey, resource, {
         name,
         value
@@ -2445,186 +2693,68 @@ class OrderRepository extends AbstractResourceRepository {
           };
         }
       },
-      setLocale: (projectKey, resource, {
-        locale
-      }) => {
-        resource.locale = locale;
-      },
-      setOrderNumber: (projectKey, resource, {
-        orderNumber
+      addTransaction: (projectKey, resource, {
+        transaction
       }) => {
-        resource.orderNumber = orderNumber;
+        resource.transactions = [...resource.transactions, this.transactionFromTransactionDraft(transaction, projectKey)];
       },
-      setShippingAddress: (projectKey, resource, {
-        address
+      changeTransactionState: (_projectKey, resource, {
+        transactionId,
+        state
       }) => {
-        resource.shippingAddress = address;
+        const index = resource.transactions.findIndex(e => e.id === transactionId);
+        const updatedTransaction = { ...resource.transactions[index],
+          state
+        };
+        resource.transactions[index] = updatedTransaction;
       },
-      setStore: (projectKey, resource, {
-        store
+      transitionState: (projectKey, resource, {
+        state
       }) => {
-        if (!store) return;
-
-        const resolvedType = this._storage.getByResourceIdentifier(projectKey, store);
+        const stateObj = this._storage.getByResourceIdentifier(projectKey, state);
 
-        if (!resolvedType) {
-          throw new Error(`No store found with key=${store.key}`);
+        if (!stateObj) {
+          throw new Error(`State ${state} not found`);
         }
 
-        const storeReference = resolvedType;
-        resource.store = {
-          typeId: 'store',
-          key: storeReference.key
+        resource.paymentStatus.state = {
+          typeId: 'state',
+          id: stateObj.id,
+          obj: stateObj
         };
       }
     };
   }
 
   getTypeId() {
-    return 'order';
+    return 'payment';
   }
 
   create(projectKey, draft) {
-    assert(draft.cart, 'draft.cart is missing');
-
-    const cart = this._storage.getByResourceIdentifier(projectKey, draft.cart);
-
-    if (!cart) {
-      throw new Error('Cannot find cart');
-    }
-
-    const resource = { ...getBaseResourceProperties(),
-      orderNumber: draft.orderNumber,
-      orderState: 'Open',
-      lineItems: [],
-      customLineItems: [],
-      totalPrice: cart.totalPrice,
-      refusedGifts: [],
-      origin: 'Customer',
-      syncInfo: [],
-      lastMessageSequenceNumber: 0
-    };
-    this.save(projectKey, resource);
-    return resource;
-  }
-
-  import(projectKey, draft) {
-    var _draft$lineItems, _draft$customLineItem;
-
-    // TODO: Check if order with given orderNumber already exists
-    assert(this, 'OrderRepository not valid');
     const resource = { ...getBaseResourceProperties(),
-      billingAddress: draft.billingAddress,
-      shippingAddress: draft.shippingAddress,
-      custom: createCustomFields(draft.custom, projectKey, this._storage),
-      customerEmail: draft.customerEmail,
-      lastMessageSequenceNumber: 0,
-      orderNumber: draft.orderNumber,
-      orderState: draft.orderState || 'Open',
-      origin: draft.origin || 'Customer',
-      paymentState: draft.paymentState,
-      refusedGifts: [],
-      store: resolveStoreReference(draft.store, projectKey, this._storage),
-      syncInfo: [],
-      lineItems: ((_draft$lineItems = draft.lineItems) == null ? void 0 : _draft$lineItems.map(item => this.lineItemFromImportDraft.bind(this)(projectKey, item))) || [],
-      customLineItems: ((_draft$customLineItem = draft.customLineItems) == null ? void 0 : _draft$customLineItem.map(item => this.customLineItemFromImportDraft.bind(this)(projectKey, item))) || [],
-      totalPrice: {
-        type: 'centPrecision',
-        ...draft.totalPrice,
-        fractionDigits: 2
-      }
+      amountPlanned: createTypedMoney(draft.amountPlanned),
+      paymentMethodInfo: draft.paymentMethodInfo,
+      paymentStatus: draft.paymentStatus ? { ...draft.paymentStatus,
+        state: draft.paymentStatus.state ? getReferenceFromResourceIdentifier(draft.paymentStatus.state, projectKey, this._storage) : undefined
+      } : {},
+      transactions: (draft.transactions || []).map(t => this.transactionFromTransactionDraft(t, projectKey)),
+      interfaceInteractions: (draft.interfaceInteractions || []).map(interaction => createCustomFields(interaction, projectKey, this._storage)),
+      custom: createCustomFields(draft.custom, projectKey, this._storage)
     };
     this.save(projectKey, resource);
     return resource;
   }
 
-  lineItemFromImportDraft(projectKey, draft) {
-    let product;
-    let variant;
-
-    if (draft.variant.sku) {
-      variant = {
-        id: 0,
-        sku: draft.variant.sku
-      };
-
-      var items = this._storage.query(projectKey, 'product', {
-        where: [`masterData(current(masterVariant(sku="${draft.variant.sku}"))) or masterData(current(variants(sku="${draft.variant.sku}")))`]
-      });
-
-      if (items.count !== 1) {
-        throw new CommercetoolsError({
-          code: 'General',
-          message: `A product containing a variant with SKU '${draft.variant.sku}' not found.`
-        });
-      }
-
-      product = items.results[0];
-
-      if (product.masterData.current.masterVariant.sku === draft.variant.sku) {
-        variant = product.masterData.current.masterVariant;
-      } else {
-        variant = product.masterData.current.variants.find(v => v.sku === draft.variant.sku);
-      }
-
-      if (!variant) {
-        throw new Error('Internal state error');
-      }
-    } else {
-      throw new Error('No product found');
-    }
-
-    const lineItem = { ...getBaseResourceProperties(),
-      custom: createCustomFields(draft.custom, projectKey, this._storage),
-      discountedPricePerQuantity: [],
-      lineItemMode: 'Standard',
-      name: draft.name,
-      price: createPrice(draft.price),
-      priceMode: 'Platform',
-      productId: product.id,
-      productType: product.productType,
-      quantity: draft.quantity,
-      state: draft.state || [],
-      taxRate: draft.taxRate,
-      totalPrice: createTypedMoney(draft.price.value),
-      variant: {
-        id: variant.id,
-        sku: variant.sku,
-        price: createPrice(draft.price)
-      }
-    };
-    return lineItem;
-  }
+}
 
-  customLineItemFromImportDraft(projectKey, draft) {
-    const lineItem = { ...getBaseResourceProperties(),
-      custom: createCustomFields(draft.custom, projectKey, this._storage),
-      discountedPricePerQuantity: [],
-      money: createTypedMoney(draft.money),
-      name: draft.name,
-      quantity: draft.quantity,
-      slug: draft.slug,
-      state: [],
-      totalPrice: createTypedMoney(draft.money)
-    };
-    return lineItem;
+class MyPaymentService extends AbstractService {
+  constructor(parent, storage) {
+    super(parent);
+    this.repository = new PaymentRepository(storage);
   }
 
-  getWithOrderNumber(projectKey, orderNumber, params = {}) {
-    const result = this._storage.query(projectKey, this.getTypeId(), { ...params,
-      where: [`orderNumber="${orderNumber}"`]
-    });
-
-    if (result.count === 1) {
-      return result.results[0];
-    } // Catch this for now, should be checked when creating/updating
-
-
-    if (result.count > 1) {
-      throw new Error('Duplicate order numbers');
-    }
-
-    return;
+  getBasePath() {
+    return 'me/payments';
   }
 
 }
@@ -3993,6 +4123,33 @@ class MyCustomerService extends AbstractService {
 
 }
 
+class MyOrderService extends AbstractService {
+  constructor(parent, storage) {
+    super(parent);
+    this.repository = new OrderRepository(storage);
+  }
+
+  getBasePath() {
+    return 'me';
+  }
+
+  registerRoutes(parent) {
+    // Overwrite this function to be able to handle /me/active-cart path.
+    const basePath = this.getBasePath();
+    const router = express.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);
+  }
+
+}
+
 const DEFAULT_OPTIONS = {
   enableAuthentication: false,
   validateCredentials: false,
@@ -4091,6 +4248,7 @@ 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(projectRouter, this._storage),