@labdigital/commercetools-mock 0.6.0 → 0.6.3

package/src/repositories/abstract.ts

@@ -22,20 +22,30 @@ export type GetParams = {
   expand?: string[]
 }
 
+export type RepositoryContext = {
+  projectKey: string
+  storeKey?: string
+}
 export abstract class AbstractRepository {
   protected _storage: AbstractStorage
   protected actions: Partial<
-    Record<any, (projectKey: string, resource: any, action: any) => void>
+    Record<
+      any,
+      (context: RepositoryContext, resource: any, action: any) => void
+    >
   > = {}
 
   constructor(storage: AbstractStorage) {
     this._storage = storage
   }
 
-  abstract save(projectKey: string, resource: BaseResource | Project): void
+  abstract save(
+    { projectKey }: RepositoryContext,
+    resource: BaseResource | Project
+  ): void
 
   processUpdateActions(
-    projectKey: string,
+    context: RepositoryContext,
     resource: BaseResource | Project,
     actions: UpdateAction[]
   ): BaseResource {
@@ -49,18 +59,18 @@ export abstract class AbstractRepository {
         console.error(`No mock implemented for update action ${action.action}`)
         return
       }
-      updateFunc(projectKey, modifiedResource, action)
+      updateFunc(context, modifiedResource, action)
     })
 
     if (!deepEqual(modifiedResource, resource)) {
-      this.save(projectKey, modifiedResource)
+      this.save(context, modifiedResource)
     }
     return modifiedResource
   }
 }
 
 export abstract class AbstractResourceRepository extends AbstractRepository {
-  abstract create(projectKey: string, draft: any): BaseResource
+  abstract create(context: RepositoryContext, draft: any): BaseResource
   abstract getTypeId(): RepositoryTypes
 
   constructor(storage: AbstractStorage) {
@@ -68,8 +78,8 @@ export abstract class AbstractResourceRepository extends AbstractRepository {
     this._storage.assertStorage(this.getTypeId())
   }
 
-  query(projectKey: string, params: QueryParams = {}) {
-    return this._storage.query(projectKey, this.getTypeId(), {
+  query(context: RepositoryContext, params: QueryParams = {}) {
+    return this._storage.query(context.projectKey, this.getTypeId(), {
       expand: params.expand,
       where: params.where,
       offset: params.offset,
@@ -78,31 +88,41 @@ export abstract class AbstractResourceRepository extends AbstractRepository {
   }
 
   get(
-    projectKey: string,
+    context: RepositoryContext,
     id: string,
     params: GetParams = {}
   ): BaseResource | null {
-    return this._storage.get(projectKey, this.getTypeId(), id, params)
+    return this._storage.get(context.projectKey, this.getTypeId(), id, params)
   }
 
   getByKey(
-    projectKey: string,
+    context: RepositoryContext,
     key: string,
     params: GetParams = {}
   ): BaseResource | null {
-    return this._storage.getByKey(projectKey, this.getTypeId(), key, params)
+    return this._storage.getByKey(
+      context.projectKey,
+      this.getTypeId(),
+      key,
+      params
+    )
   }
 
   delete(
-    projectKey: string,
+    context: RepositoryContext,
     id: string,
     params: GetParams = {}
   ): BaseResource | null {
-    return this._storage.delete(projectKey, this.getTypeId(), id, params)
+    return this._storage.delete(
+      context.projectKey,
+      this.getTypeId(),
+      id,
+      params
+    )
   }
 
-  save(projectKey: string, resource: BaseResource) {
-    const current = this.get(projectKey, resource.id)
+  save(context: RepositoryContext, resource: BaseResource) {
+    const current = this.get(context, resource.id)
 
     if (current) {
       checkConcurrentModification(current, resource.version)
@@ -120,6 +140,6 @@ export abstract class AbstractResourceRepository extends AbstractRepository {
 
     // @ts-ignore
     resource.version += 1
-    this._storage.add(projectKey, this.getTypeId(), resource as any)
+    this._storage.add(context.projectKey, this.getTypeId(), resource as any)
   }
 }

package/src/repositories/cart-discount.ts

@@ -18,7 +18,7 @@ import {
 } from '@commercetools/platform-sdk'
 import { Writable } from 'types'
 import { getBaseResourceProperties } from '../helpers'
-import { AbstractResourceRepository } from './abstract'
+import { AbstractResourceRepository, RepositoryContext } from './abstract'
 import { createTypedMoney } from './helpers'
 
 export class CartDiscountRepository extends AbstractResourceRepository {
@@ -26,7 +26,7 @@ export class CartDiscountRepository extends AbstractResourceRepository {
     return 'cart-discount'
   }
 
-  create(projectKey: string, draft: CartDiscountDraft): CartDiscount {
+  create(context: RepositoryContext, draft: CartDiscountDraft): CartDiscount {
     const resource: CartDiscount = {
       ...getBaseResourceProperties(),
       key: draft.key,
@@ -43,7 +43,7 @@ export class CartDiscountRepository extends AbstractResourceRepository {
       validUntil: draft.validUntil,
       value: this.transformValueDraft(draft.value),
     }
-    this.save(projectKey, resource)
+    this.save(context, resource)
     return resource
   }
 
@@ -80,42 +80,42 @@ export class CartDiscountRepository extends AbstractResourceRepository {
     Record<
       CartDiscountUpdateAction['action'],
       (
-        projectKey: string,
+        context: RepositoryContext,
         resource: Writable<CartDiscount>,
         action: any
       ) => void
     >
   > = {
     setKey: (
-      projectKey: string,
+      context: RepositoryContext,
       resource: Writable<CartDiscount>,
       { key }: CartDiscountSetKeyAction
     ) => {
       resource.key = key
     },
     setDescription: (
-      projectKey: string,
+      context: RepositoryContext,
       resource: Writable<CartDiscount>,
       { description }: CartDiscountSetDescriptionAction
     ) => {
       resource.description = description
     },
     setValidFrom: (
-      projectKey: string,
+      context: RepositoryContext,
       resource: Writable<CartDiscount>,
       { validFrom }: CartDiscountSetValidFromAction
     ) => {
       resource.validFrom = validFrom
     },
     setValidUntil: (
-      projectKey: string,
+      context: RepositoryContext,
       resource: Writable<CartDiscount>,
       { validUntil }: CartDiscountSetValidUntilAction
     ) => {
       resource.validUntil = validUntil
     },
     setValidFromAndUntil: (
-      projectKey: string,
+      context: RepositoryContext,
       resource: Writable<CartDiscount>,
       { validFrom, validUntil }: CartDiscountSetValidFromAndUntilAction
     ) => {
@@ -123,14 +123,14 @@ export class CartDiscountRepository extends AbstractResourceRepository {
       resource.validUntil = validUntil
     },
     changeSortOrder: (
-      projectKey: string,
+      context: RepositoryContext,
       resource: Writable<CartDiscount>,
       { sortOrder }: CartDiscountChangeSortOrderAction
     ) => {
       resource.sortOrder = sortOrder
     },
     changeIsActive: (
-      projectKey: string,
+      context: RepositoryContext,
       resource: Writable<CartDiscount>,
       { isActive }: CartDiscountChangeIsActiveAction
     ) => {

package/src/repositories/cart.ts

@@ -14,6 +14,7 @@ import {
   GeneralError,
   LineItem,
   LineItemDraft,
+  Price,
   Product,
   ProductPagedQueryResponse,
   ProductVariant,
@@ -21,7 +22,7 @@ import {
 } from '@commercetools/platform-sdk'
 import { v4 as uuidv4 } from 'uuid'
 import { getBaseResourceProperties } from '../helpers'
-import { AbstractResourceRepository } from './abstract'
+import { AbstractResourceRepository, RepositoryContext } from './abstract'
 import { createCustomFields } from './helpers'
 import { Writable } from '../types'
 import { CommercetoolsError } from '../exceptions'
@@ -31,15 +32,21 @@ export class CartRepository extends AbstractResourceRepository {
     return 'cart'
   }
 
-  create(projectKey: string, draft: CartDraft): Cart {
-    const lineItems = draft.lineItems?.map(draftLineItem =>
-      this.draftLineItemtoLineItem(projectKey, draftLineItem)
-    )
+  create(context: RepositoryContext, draft: CartDraft): Cart {
+    const lineItems =
+      draft.lineItems?.map(draftLineItem =>
+        this.draftLineItemtoLineItem(
+          context.projectKey,
+          draftLineItem,
+          draft.currency,
+          draft.country
+        )
+      ) ?? []
 
     const resource: Cart = {
       ...getBaseResourceProperties(),
       cartState: 'Active',
-      lineItems: lineItems ?? [],
+      lineItems,
       customLineItems: [],
       totalPrice: {
         type: 'centPrecision',
@@ -47,18 +54,24 @@ export class CartRepository extends AbstractResourceRepository {
         currencyCode: draft.currency,
         fractionDigits: 0,
       },
-      taxMode: 'Platform',
-      taxRoundingMode: 'HalfEven',
-      taxCalculationMode: 'LineItemLevel',
+      taxMode: draft.taxMode ?? 'Platform',
+      taxRoundingMode: draft.taxRoundingMode ?? 'HalfEven',
+      taxCalculationMode: draft.taxCalculationMode ?? 'LineItemLevel',
       refusedGifts: [],
-      origin: 'Customer',
-      custom: createCustomFields(draft.custom, projectKey, this._storage),
+      locale: draft.locale,
+      country: draft.country,
+      origin: draft.origin ?? 'Customer',
+      custom: createCustomFields(
+        draft.custom,
+        context.projectKey,
+        this._storage
+      ),
     }
 
     // @ts-ignore
     resource.totalPrice.centAmount = calculateCartTotalPrice(resource)
 
-    this.save(projectKey, resource)
+    this.save(context, resource)
     return resource
   }
 
@@ -76,7 +89,7 @@ export class CartRepository extends AbstractResourceRepository {
 
   actions = {
     addLineItem: (
-      projectKey: string,
+      context: RepositoryContext,
       resource: Writable<Cart>,
       { productId, variantId, sku, quantity = 1 }: CartAddLineItemAction
     ) => {
@@ -85,10 +98,15 @@ export class CartRepository extends AbstractResourceRepository {
 
       if (productId && variantId) {
         // Fetch product and variant by ID
-        product = this._storage.get(projectKey, 'product', productId, {})
+        product = this._storage.get(
+          context.projectKey,
+          'product',
+          productId,
+          {}
+        )
       } else if (sku) {
         // Fetch product and variant by SKU
-        const items = this._storage.query(projectKey, 'product', {
+        const items = this._storage.query(context.projectKey, 'product', {
           where: [
             `masterData(current(masterVariant(sku="${sku}"))) or masterData(current(variants(sku="${sku}")))`,
           ],
@@ -150,7 +168,18 @@ export class CartRepository extends AbstractResourceRepository {
           })
         }
 
-        const price = variant.prices[0]
+        const currency = resource.totalPrice.currencyCode
+
+        const price = selectPrice({
+          prices: variant.prices,
+          currency,
+          country: resource.country,
+        })
+        if (!price) {
+          throw new Error(
+            `No valid price found for ${productId} for country ${resource.country} and currency ${currency}`
+          )
+        }
         resource.lineItems.push({
           id: uuidv4(),
           productId: product.id,
@@ -176,7 +205,7 @@ export class CartRepository extends AbstractResourceRepository {
       resource.totalPrice.centAmount = calculateCartTotalPrice(resource)
     },
     removeLineItem: (
-      projectKey: string,
+      context: RepositoryContext,
       resource: Writable<Cart>,
       { lineItemId, quantity }: CartRemoveLineItemAction
     ) => {
@@ -208,19 +237,19 @@ export class CartRepository extends AbstractResourceRepository {
       resource.totalPrice.centAmount = calculateCartTotalPrice(resource)
     },
     setBillingAddress: (
-      projectKey: string,
+      context: RepositoryContext,
       resource: Writable<Cart>,
       { address }: CartSetBillingAddressAction
     ) => {
       resource.billingAddress = address
     },
     setShippingMethod: (
-      projectKey: string,
+      context: RepositoryContext,
       resource: Writable<Cart>,
       { shippingMethod }: CartSetShippingMethodAction
     ) => {
       const resolvedType = this._storage.getByResourceIdentifier(
-        projectKey,
+        context.projectKey,
         //@ts-ignore
         shippingMethod
       )
@@ -237,21 +266,21 @@ export class CartRepository extends AbstractResourceRepository {
       }
     },
     setCountry: (
-      projectKey: string,
+      context: RepositoryContext,
       resource: Writable<Cart>,
       { country }: CartSetCountryAction
     ) => {
       resource.country = country
     },
     setCustomerEmail: (
-      projectKey: string,
+      context: RepositoryContext,
       resource: Writable<Cart>,
       { email }: CartSetCustomerEmailAction
     ) => {
       resource.customerEmail = email
     },
     setCustomField: (
-      projectKey: string,
+      context: RepositoryContext,
       resource: Cart,
       { name, value }: CartSetCustomFieldAction
     ) => {
@@ -261,7 +290,7 @@ export class CartRepository extends AbstractResourceRepository {
       resource.custom.fields[name] = value
     },
     setCustomType: (
-      projectKey: string,
+      context: RepositoryContext,
       resource: Writable<Cart>,
       { type, fields }: CartSetCustomTypeAction
     ) => {
@@ -269,7 +298,7 @@ export class CartRepository extends AbstractResourceRepository {
         resource.custom = undefined
       } else {
         const resolvedType = this._storage.getByResourceIdentifier(
-          projectKey,
+          context.projectKey,
           type
         )
         if (!resolvedType) {
@@ -286,14 +315,14 @@ export class CartRepository extends AbstractResourceRepository {
       }
     },
     setLocale: (
-      projectKey: string,
+      context: RepositoryContext,
       resource: Writable<Cart>,
       { locale }: CartSetLocaleAction
     ) => {
       resource.locale = locale
     },
     setShippingAddress: (
-      projectKey: string,
+      context: RepositoryContext,
       resource: Writable<Cart>,
       { address }: CartSetShippingAddressAction
     ) => {
@@ -302,13 +331,12 @@ export class CartRepository extends AbstractResourceRepository {
   }
   draftLineItemtoLineItem = (
     projectKey: string,
-    draftLineItem: LineItemDraft
+    draftLineItem: LineItemDraft,
+    currency: string,
+    country: string | undefined
   ): LineItem => {
-    const { productId, quantity } = draftLineItem
-    // @ts-ignore
-    let variantId = draftLineItem.variant.id
-    // @ts-ignore
-    let sku = draftLineItem.variant.sku
+    const { productId, quantity, variantId, sku } = draftLineItem
+
     let product: Product | null = null
     let variant: ProductVariant | undefined
 
@@ -357,12 +385,13 @@ export class CartRepository extends AbstractResourceRepository {
       )
     }
 
-    const price = variant.prices?.[0]
-
     const quant = quantity ?? 1
 
+    const price = selectPrice({ prices: variant.prices, currency, country })
     if (!price) {
-      throw new Error(`Price not set on ${productId}`)
+      throw new Error(
+        `No valid price found for ${productId} for country ${country} and currency ${currency}`
+      )
     }
 
     return {
@@ -387,6 +416,29 @@ export class CartRepository extends AbstractResourceRepository {
   }
 }
 
+const selectPrice = ({
+  prices,
+  currency,
+  country,
+}: {
+  prices: Price[] | undefined
+  currency: string
+  country: string | undefined
+}) => {
+  if (!prices) {
+    return undefined
+  }
+
+  // Quick-and-dirty way of selecting price based on the given currency and country.
+  // Can be improved later to give more priority to exact matches over
+  // 'all country' matches, and include customer groups in the mix as well
+  return prices.find(price => {
+    const countryMatch = !price.country || price.country === country
+    const currencyMatch = price.value.currencyCode === currency
+    return countryMatch && currencyMatch
+  })
+}
+
 const calculateLineItemTotalPrice = (lineItem: LineItem): number =>
   lineItem.price!.value.centAmount * lineItem.quantity
 

package/src/repositories/category.ts

@@ -16,14 +16,14 @@ import {
 import { Writable } from 'types'
 import { getBaseResourceProperties } from '../helpers'
 import { createCustomFields } from './helpers'
-import { AbstractResourceRepository } from './abstract'
+import { AbstractResourceRepository, RepositoryContext } from './abstract'
 
 export class CategoryRepository extends AbstractResourceRepository {
   getTypeId(): ReferenceTypeId {
     return 'category'
   }
 
-  create(projectKey: string, draft: CategoryDraft): Category {
+  create(context: RepositoryContext, draft: CategoryDraft): Category {
     const resource: Category = {
       ...getBaseResourceProperties(),
       key: draft.key,
@@ -44,17 +44,21 @@ export class CategoryRepository extends AbstractResourceRepository {
             sources: d.sources,
             tags: d.tags,
             key: d.key,
-            custom: createCustomFields(draft.custom, projectKey, this._storage),
+            custom: createCustomFields(
+              draft.custom,
+              context.projectKey,
+              this._storage
+            ),
           }
         }) || [],
     }
-    this.save(projectKey, resource)
+    this.save(context, resource)
     return resource
   }
 
   actions = {
     changeAssetName: (
-      projectKey: string,
+      context: RepositoryContext,
       resource: Writable<Category>,
       { assetId, assetKey, name }: CategoryChangeAssetNameAction
     ) => {
@@ -68,21 +72,21 @@ export class CategoryRepository extends AbstractResourceRepository {
       })
     },
     changeSlug: (
-      projectKey: string,
+      context: RepositoryContext,
       resource: Writable<Category>,
       { slug }: CategoryChangeSlugAction
     ) => {
       resource.slug = slug
     },
     setKey: (
-      projectKey: string,
+      context: RepositoryContext,
       resource: Writable<Category>,
       { key }: CategorySetKeyAction
     ) => {
       resource.key = key
     },
     setAssetDescription: (
-      projectKey: string,
+      context: RepositoryContext,
       resource: Writable<Category>,
       { assetId, assetKey, description }: CategorySetAssetDescriptionAction
     ) => {
@@ -96,7 +100,7 @@ export class CategoryRepository extends AbstractResourceRepository {
       })
     },
     setAssetSources: (
-      projectKey: string,
+      context: RepositoryContext,
       resource: Writable<Category>,
       { assetId, assetKey, sources }: CategorySetAssetSourcesAction
     ) => {
@@ -110,28 +114,28 @@ export class CategoryRepository extends AbstractResourceRepository {
       })
     },
     setDescription: (
-      projectKey: string,
+      context: RepositoryContext,
       resource: Writable<Category>,
       { description }: CategorySetDescriptionAction
     ) => {
       resource.description = description
     },
     setMetaDescription: (
-      projectKey: string,
+      context: RepositoryContext,
       resource: Writable<Category>,
       { metaDescription }: CategorySetMetaDescriptionAction
     ) => {
       resource.metaDescription = metaDescription
     },
     setMetaKeywords: (
-      projectKey: string,
+      context: RepositoryContext,
       resource: Writable<Category>,
       { metaKeywords }: CategorySetMetaKeywordsAction
     ) => {
       resource.metaKeywords = metaKeywords
     },
     setMetaTitle: (
-      projectKey: string,
+      context: RepositoryContext,
       resource: Writable<Category>,
       { metaTitle }: CategorySetMetaTitleAction
     ) => {

package/src/repositories/channel.ts

@@ -4,20 +4,20 @@ import {
   ReferenceTypeId,
 } from '@commercetools/platform-sdk'
 import { getBaseResourceProperties } from '../helpers'
-import { AbstractResourceRepository } from './abstract'
+import { AbstractResourceRepository, RepositoryContext } from './abstract'
 
 export class ChannelRepository extends AbstractResourceRepository {
   getTypeId(): ReferenceTypeId {
     return 'channel'
   }
 
-  create(projectKey: string, draft: ChannelDraft): Channel {
+  create(context: RepositoryContext, draft: ChannelDraft): Channel {
     const resource: Channel = {
       ...getBaseResourceProperties(),
       key: draft.key,
       roles: draft.roles || [],
     }
-    this.save(projectKey, resource)
+    this.save(context, resource)
     return resource
   }
 }

package/src/repositories/custom-object.ts

@@ -4,7 +4,7 @@ import {
   ReferenceTypeId,
 } from '@commercetools/platform-sdk'
 import { checkConcurrentModification } from './errors'
-import { AbstractResourceRepository } from './abstract'
+import { AbstractResourceRepository, RepositoryContext } from './abstract'
 import { Writable } from '../types'
 import { getBaseResourceProperties } from '../helpers'
 
@@ -13,9 +13,12 @@ export class CustomObjectRepository extends AbstractResourceRepository {
     return 'key-value-document'
   }
 
-  create(projectKey: string, draft: Writable<CustomObjectDraft>): CustomObject {
+  create(
+    context: RepositoryContext,
+    draft: Writable<CustomObjectDraft>
+  ): CustomObject {
     const current = this.getWithContainerAndKey(
-      projectKey,
+      context,
       draft.container,
       draft.key
     )
@@ -47,14 +50,19 @@ export class CustomObjectRepository extends AbstractResourceRepository {
       value: draft.value,
     }
 
-    this.save(projectKey, resource)
+    this.save(context, resource)
     return resource
   }
 
-  getWithContainerAndKey(projectKey: string, container: string, key: string) {
-    const items = this._storage.all(projectKey, this.getTypeId()) as Array<
-      CustomObject
-    >
+  getWithContainerAndKey(
+    context: RepositoryContext,
+    container: string,
+    key: string
+  ) {
+    const items = this._storage.all(
+      context.projectKey,
+      this.getTypeId()
+    ) as Array<CustomObject>
     return items.find(item => item.container === container && item.key === key)
   }
 }