@labdigital/commercetools-mock 0.5.13 → 0.5.14

package/src/repositories/project.ts

@@ -0,0 +1,150 @@
+import {
+  Project,
+  ProjectChangeCartsConfigurationAction,
+  ProjectChangeCountriesAction,
+  ProjectChangeCountryTaxRateFallbackEnabledAction,
+  ProjectChangeCurrenciesAction,
+  ProjectChangeLanguagesAction,
+  ProjectChangeMessagesEnabledAction,
+  ProjectChangeNameAction,
+  ProjectChangeOrderSearchStatusAction,
+  ProjectChangeProductSearchIndexingEnabledAction,
+  ProjectSetExternalOAuthAction,
+  ProjectSetShippingRateInputTypeAction,
+  ProjectUpdateAction,
+} from '@commercetools/platform-sdk'
+import { InvalidOperationError } from '@commercetools/platform-sdk'
+import { Writable } from 'types'
+import { checkConcurrentModification } from './errors'
+import { CommercetoolsError } from '../exceptions'
+import { AbstractRepository } from './abstract'
+
+export class ProjectRepository extends AbstractRepository {
+  get(projectKey: string): Project | null {
+    const data = this._storage.getProject(projectKey)
+    return this._storage.getProject(projectKey)
+  }
+
+  save(projectKey: string, resource: Project) {
+    const current = this.get(projectKey)
+
+    if (current) {
+      checkConcurrentModification(current, resource.version)
+    } else {
+      if (resource.version !== 0) {
+        throw new CommercetoolsError<InvalidOperationError>(
+          {
+            code: 'InvalidOperation',
+            message: 'version on create must be 0',
+          },
+          400
+        )
+      }
+    }
+
+    // @ts-ignore
+    resource.version += 1
+    this._storage.saveProject(resource)
+  }
+
+  actions: Partial<
+    Record<
+      ProjectUpdateAction['action'],
+      (projectKey: string, resource: Writable<Project>, action: any) => void
+    >
+  > = {
+    changeName: (
+      projectKey: string,
+      resource: Writable<Project>,
+      { name }: ProjectChangeNameAction
+    ) => {
+      resource.name = name
+    },
+    changeCurrencies: (
+      projectKey: string,
+      resource: Writable<Project>,
+      { currencies }: ProjectChangeCurrenciesAction
+    ) => {
+      resource.currencies = currencies
+    },
+    changeCountries: (
+      projectKey: string,
+      resource: Writable<Project>,
+      { countries }: ProjectChangeCountriesAction
+    ) => {
+      resource.countries = countries
+    },
+    changeLanguages: (
+      projectKey: string,
+      resource: Writable<Project>,
+      { languages }: ProjectChangeLanguagesAction
+    ) => {
+      resource.languages = languages
+    },
+    changeMessagesEnabled: (
+      projectKey: string,
+      resource: Writable<Project>,
+      { messagesEnabled }: ProjectChangeMessagesEnabledAction
+    ) => {
+      resource.messages.enabled = messagesEnabled
+    },
+    changeProductSearchIndexingEnabled: (
+      projectKey: string,
+      resource: Writable<Project>,
+      { enabled }: ProjectChangeProductSearchIndexingEnabledAction
+    ) => {
+      if (!resource.searchIndexing?.products) {
+        throw new Error('Invalid project state')
+      }
+      resource.searchIndexing.products.status = enabled
+        ? 'Activated'
+        : 'Deactivated'
+      resource.searchIndexing.products.lastModifiedAt = new Date().toISOString()
+    },
+    changeOrderSearchStatus: (
+      projectKey: string,
+      resource: Writable<Project>,
+      { status }: ProjectChangeOrderSearchStatusAction
+    ) => {
+      if (!resource.searchIndexing?.orders) {
+        throw new Error('Invalid project state')
+      }
+      resource.searchIndexing.orders.status = status
+      resource.searchIndexing.orders.lastModifiedAt = new Date().toISOString()
+    },
+    setShippingRateInputType: (
+      projectKey: string,
+      resource: Writable<Project>,
+      { shippingRateInputType }: ProjectSetShippingRateInputTypeAction
+    ) => {
+      resource.shippingRateInputType = shippingRateInputType
+    },
+    setExternalOAuth: (
+      projectKey: string,
+      resource: Writable<Project>,
+      { externalOAuth }: ProjectSetExternalOAuthAction
+    ) => {
+      resource.externalOAuth = externalOAuth
+    },
+    changeCountryTaxRateFallbackEnabled: (
+      projectKey: string,
+      resource: Writable<Project>,
+      {
+        countryTaxRateFallbackEnabled,
+      }: ProjectChangeCountryTaxRateFallbackEnabledAction
+    ) => {
+      resource.carts.countryTaxRateFallbackEnabled = countryTaxRateFallbackEnabled
+    },
+    changeCartsConfiguration: (
+      projectKey: string,
+      resource: Writable<Project>,
+      { cartsConfiguration }: ProjectChangeCartsConfigurationAction
+    ) => {
+      console.log(cartsConfiguration)
+      resource.carts = cartsConfiguration || {
+        countryTaxRateFallbackEnabled: false,
+        deleteDaysAfterLastModification: 90,
+      }
+    },
+  }
+}

package/src/repositories/shipping-method.ts

@@ -6,14 +6,30 @@ import {
 import {
   ReferenceTypeId,
   ShippingMethod,
+  ShippingMethodAddShippingRateAction,
+  ShippingMethodAddZoneAction,
+  ShippingMethodChangeIsDefaultAction,
+  ShippingMethodChangeNameAction,
   ShippingMethodDraft,
+  ShippingMethodRemoveZoneAction,
+  ShippingMethodSetDescriptionAction,
+  ShippingMethodSetKeyAction,
+  ShippingMethodSetLocalizedDescriptionAction,
+  ShippingMethodSetPredicateAction,
+  ShippingMethodUpdateAction,
+  ShippingRate,
+  ShippingRateDraft,
   ZoneRate,
   ZoneRateDraft,
+  ZoneReference,
 } from '@commercetools/platform-sdk'
 import { getBaseResourceProperties } from '../helpers'
-import AbstractRepository from './abstract'
+import { AbstractResourceRepository } from './abstract'
+import { Writable } from 'types'
+import { _ } from 'ajv'
+import deepEqual from 'deep-equal'
 
-export class ShippingMethodRepository extends AbstractRepository {
+export class ShippingMethodRepository extends AbstractResourceRepository {
   getTypeId(): ReferenceTypeId {
     return 'shipping-method'
   }
@@ -27,8 +43,8 @@ export class ShippingMethodRepository extends AbstractRepository {
         projectKey,
         this._storage
       ),
-      zoneRates: draft.zoneRates.map(z =>
-        this.zoneRateFromZoneRateDraft(projectKey, z)
+      zoneRates: draft.zoneRates?.map(z =>
+        this._transformZoneRateDraft(projectKey, z)
       ),
       custom: createCustomFields(draft.custom, projectKey, this._storage),
     }
@@ -36,23 +52,143 @@ export class ShippingMethodRepository extends AbstractRepository {
     return resource
   }
 
-  zoneRateFromZoneRateDraft = (
+  private _transformZoneRateDraft = (
     projectKey: string,
     draft: ZoneRateDraft
   ): ZoneRate => ({
     ...draft,
-    zone: getReferenceFromResourceIdentifier(
+    zone: getReferenceFromResourceIdentifier<ZoneReference>(
       draft.zone,
       projectKey,
       this._storage
     ),
-    shippingRates: draft.shippingRates.map(s => ({
-      ...s,
-      price: createTypedMoney(s.price),
-      freeAbove: s.freeAbove && createTypedMoney(s.freeAbove),
-      tiers: s.tiers || [],
-    })),
+    shippingRates: draft.shippingRates?.map(this._transformShippingRate),
   })
 
-  actions = {}
+  private _transformShippingRate = (rate: ShippingRateDraft): ShippingRate => {
+    return {
+      price: createTypedMoney(rate.price),
+      freeAbove: rate.freeAbove && createTypedMoney(rate.freeAbove),
+      tiers: rate.tiers || [],
+    }
+  }
+
+  actions: Partial<
+    Record<
+      ShippingMethodUpdateAction['action'],
+      (
+        projectKey: string,
+        resource: Writable<ShippingMethod>,
+        action: any
+      ) => void
+    >
+  > = {
+    addShippingRate: (
+      projectKey: string,
+      resource: Writable<ShippingMethod>,
+      { shippingRate, zone }: ShippingMethodAddShippingRateAction
+    ) => {
+      const rate = this._transformShippingRate(shippingRate)
+
+      resource.zoneRates.forEach(zoneRate => {
+        if (zoneRate.zone.id == zone.id) {
+          zoneRate.shippingRates.push(rate)
+          return
+        }
+      })
+      resource.zoneRates.push({
+        zone: {
+          typeId: 'zone',
+          id: zone.id!,
+        },
+        shippingRates: [rate],
+      })
+    },
+    removeShippingRate: (
+      projectKey: string,
+      resource: Writable<ShippingMethod>,
+      { shippingRate, zone }: ShippingMethodAddShippingRateAction
+    ) => {
+      const rate = this._transformShippingRate(shippingRate)
+
+      resource.zoneRates.forEach(zoneRate => {
+        if (zoneRate.zone.id == zone.id) {
+          zoneRate.shippingRates = zoneRate.shippingRates.filter(otherRate => {
+            return !deepEqual(rate, otherRate)
+          })
+        }
+      })
+    },
+    addZone: (
+      projectKey: string,
+      resource: Writable<ShippingMethod>,
+      { zone }: ShippingMethodAddZoneAction
+    ) => {
+      const zoneReference = getReferenceFromResourceIdentifier<ZoneReference>(
+        zone,
+        projectKey,
+        this._storage
+      )
+
+      if (resource.zoneRates === undefined) {
+        resource.zoneRates = []
+      }
+
+      resource.zoneRates.push({
+        zone: zoneReference,
+        shippingRates: [],
+      })
+    },
+    removeZone: (
+      projectKey: string,
+      resource: Writable<ShippingMethod>,
+      { zone }: ShippingMethodRemoveZoneAction
+    ) => {
+      resource.zoneRates = resource.zoneRates.filter(zoneRate => {
+        return zoneRate.zone.id !== zone.id
+      })
+    },
+    setKey: (
+      projectKey: string,
+      resource: Writable<ShippingMethod>,
+      { key }: ShippingMethodSetKeyAction
+    ) => {
+      resource.key = key
+    },
+    setDescription: (
+      projectKey: string,
+      resource: Writable<ShippingMethod>,
+      { description }: ShippingMethodSetDescriptionAction
+    ) => {
+      resource.description = description
+    },
+    setLocalizedDescription: (
+      projectKey: string,
+      resource: Writable<ShippingMethod>,
+      { localizedDescription }: ShippingMethodSetLocalizedDescriptionAction
+    ) => {
+      resource.localizedDescription = localizedDescription
+    },
+    setPredicate: (
+      projectKey: string,
+      resource: Writable<ShippingMethod>,
+      { predicate }: ShippingMethodSetPredicateAction
+    ) => {
+      resource.predicate = predicate
+    },
+    changeIsDefault: (
+      projectKey: string,
+      resource: Writable<ShippingMethod>,
+      { isDefault }: ShippingMethodChangeIsDefaultAction
+    ) => {
+      resource.isDefault = isDefault
+    },
+    changeName: (
+      projectKey: string,
+      resource: Writable<ShippingMethod>,
+      { name }: ShippingMethodChangeNameAction
+    ) => {
+      resource.name = name
+    },
+  }
 }

package/src/repositories/shopping-list.ts

@@ -5,13 +5,13 @@ import {
   ShoppingListDraft,
 } from '@commercetools/platform-sdk'
 import { getBaseResourceProperties } from '../helpers'
-import AbstractRepository from './abstract'
+import { AbstractResourceRepository } from './abstract'
 import {
   createCustomFields,
   getReferenceFromResourceIdentifier,
 } from './helpers'
 
-export class ShoppingListRepository extends AbstractRepository {
+export class ShoppingListRepository extends AbstractResourceRepository {
   getTypeId(): ReferenceTypeId {
     return 'shopping-list'
   }

package/src/repositories/state.ts

@@ -1,9 +1,19 @@
 import { getBaseResourceProperties } from '../helpers'
 import { getReferenceFromResourceIdentifier } from './helpers'
-import { ReferenceTypeId, State, StateDraft } from '@commercetools/platform-sdk'
-import AbstractRepository from './abstract'
+import {
+  ReferenceTypeId,
+  State,
+  StateChangeKeyAction,
+  StateDraft,
+  StateSetDescriptionAction,
+  StateSetNameAction,
+  StateSetRolesAction,
+  StateUpdateAction,
+} from '@commercetools/platform-sdk'
+import { AbstractResourceRepository } from './abstract'
+import { Writable } from 'types'
 
-export class StateRepository extends AbstractRepository {
+export class StateRepository extends AbstractResourceRepository {
   getTypeId(): ReferenceTypeId {
     return 'state'
   }
@@ -23,5 +33,39 @@ export class StateRepository extends AbstractRepository {
     return resource
   }
 
-  actions = {}
+  actions: Partial<
+    Record<
+      StateUpdateAction['action'],
+      (projectKey: string, resource: Writable<State>, action: any) => void
+    >
+  > = {
+    changeKey: (
+      projectKey: string,
+      resource: Writable<State>,
+      { key }: StateChangeKeyAction
+    ) => {
+      resource.key = key
+    },
+    setDescription: (
+      projectKey: string,
+      resource: Writable<State>,
+      { description }: StateSetDescriptionAction
+    ) => {
+      resource.description = description
+    },
+    setName: (
+      projectKey: string,
+      resource: Writable<State>,
+      { name }: StateSetNameAction
+    ) => {
+      resource.name = name
+    },
+    setRoles: (
+      projectKey: string,
+      resource: Writable<State>,
+      { roles }: StateSetRolesAction
+    ) => {
+      resource.roles = roles
+    },
+  }
 }

package/src/repositories/store.ts

@@ -1,8 +1,20 @@
-import { Store, StoreDraft, ReferenceTypeId } from '@commercetools/platform-sdk'
+import {
+  Store,
+  StoreDraft,
+  ReferenceTypeId,
+  StoreUpdateAction,
+  StoreSetNameAction,
+  ChannelReference,
+  StoreSetDistributionChannelsAction,
+  ChannelResourceIdentifier,
+  StoreSetLanguagesAction,
+} from '@commercetools/platform-sdk'
+import { Writable } from 'types'
 import { getBaseResourceProperties } from '../helpers'
-import AbstractRepository from './abstract'
+import { AbstractResourceRepository } from './abstract'
+import { getReferenceFromResourceIdentifier } from './helpers'
 
-export class StoreRepository extends AbstractRepository {
+export class StoreRepository extends AbstractResourceRepository {
   getTypeId(): ReferenceTypeId {
     return 'store'
   }
@@ -11,9 +23,62 @@ export class StoreRepository extends AbstractRepository {
     const resource: Store = {
       ...getBaseResourceProperties(),
       key: draft.key,
-      distributionChannels: [],
+      name: draft.name,
+      languages: draft.languages,
+      distributionChannels: this.transformChannels(
+        projectKey,
+        draft.distributionChannels
+      ),
+      supplyChannels: this.transformChannels(projectKey, draft.supplyChannels),
     }
     this.save(projectKey, resource)
     return resource
   }
+
+  private transformChannels(
+    projectKey: string,
+    channels?: ChannelResourceIdentifier[]
+  ) {
+    if (!channels) return []
+
+    return channels.map(ref =>
+      getReferenceFromResourceIdentifier<ChannelReference>(
+        ref,
+        projectKey,
+        this._storage
+      )
+    )
+  }
+
+  actions: Partial<
+    Record<
+      StoreUpdateAction['action'],
+      (projectKey: string, resource: Writable<Store>, action: any) => void
+    >
+  > = {
+    setName: (
+      projectKey: string,
+      resource: Writable<Store>,
+      { name }: StoreSetNameAction
+    ) => {
+      resource.name = name
+    },
+    setDistributionChannels: (
+      projectKey: string,
+      resource: Writable<Store>,
+      { distributionChannels }: StoreSetDistributionChannelsAction
+    ) => {
+      resource.distributionChannels = this.transformChannels(
+        projectKey,
+        distributionChannels
+      )
+    },
+    setLanguages: (
+      projectKey: string,
+      resource: Writable<Store>,
+      { languages }: StoreSetLanguagesAction
+    ) => {
+      resource.languages = languages
+    },
+  }
 }

package/src/repositories/subscription.ts

@@ -0,0 +1,50 @@
+import {
+  InvalidInputError,
+  ReferenceTypeId,
+  Subscription,
+  SubscriptionDraft,
+} from '@commercetools/platform-sdk'
+import { CommercetoolsError } from '../exceptions'
+import { getBaseResourceProperties } from '../helpers'
+import { AbstractResourceRepository } from './abstract'
+
+export class SubscriptionRepository extends AbstractResourceRepository {
+  getTypeId(): ReferenceTypeId {
+    return 'subscription'
+  }
+  create(projectKey: string, draft: SubscriptionDraft): Subscription {
+    // TODO: We could actually test this here by using the aws sdk. For now
+    // hardcode a failed check when account id is 0000000000
+    if (draft.destination.type == 'SQS') {
+      const queueURL = new URL(draft.destination.queueUrl)
+      const accountId = queueURL.pathname.split('/')[1]
+      if (accountId == '0000000000') {
+        const dest = draft.destination
+        throw new CommercetoolsError<InvalidInputError>(
+          {
+            code: 'InvalidInput',
+            message:
+              'A test message could not be delivered to this destination: ' +
+              `SQS ${dest.queueUrl} in ${dest.region} for ${dest.accessKey}. ` +
+              'Please make sure your destination is correctly configured.',
+          },
+          400
+        )
+      }
+    }
+
+    const resource: Subscription = {
+      ...getBaseResourceProperties(),
+      changes: draft.changes || [],
+      destination: draft.destination,
+      format: draft.format || {
+        type: 'Platform',
+      },
+      key: draft.key,
+      messages: draft.messages || [],
+      status: 'Healthy',
+    }
+    this.save(projectKey, resource)
+    return resource
+  }
+}

package/src/repositories/tax-category.ts

@@ -1,15 +1,23 @@
 import {
   ReferenceTypeId,
   TaxCategory,
+  TaxCategoryAddTaxRateAction,
+  TaxCategoryChangeNameAction,
   TaxCategoryDraft,
+  TaxCategoryRemoveTaxRateAction,
+  TaxCategoryReplaceTaxRateAction,
+  TaxCategorySetDescriptionAction,
+  TaxCategorySetKeyAction,
+  TaxCategoryUpdateAction,
   TaxRate,
   TaxRateDraft,
 } from '@commercetools/platform-sdk'
 import { getBaseResourceProperties } from '../helpers'
-import AbstractRepository from './abstract'
+import { AbstractResourceRepository } from './abstract'
 import { v4 as uuidv4 } from 'uuid'
+import { Writable } from 'types'
 
-export class TaxCategoryRepository extends AbstractRepository {
+export class TaxCategoryRepository extends AbstractResourceRepository {
   getTypeId(): ReferenceTypeId {
     return 'tax-category'
   }
@@ -18,13 +26,13 @@ export class TaxCategoryRepository extends AbstractRepository {
     const resource: TaxCategory = {
       ...getBaseResourceProperties(),
       ...draft,
-      rates: draft.rates.map(this.taxRateFromTaxRateDraft),
+      rates: draft.rates?.map(this.taxRateFromTaxRateDraft) || [],
     }
     this.save(projectKey, resource)
     return resource
   }
 
-  taxRateFromTaxRateDraft = (draft: TaxRateDraft): TaxRate => ({
+  private taxRateFromTaxRateDraft = (draft: TaxRateDraft): TaxRate => ({
     ...draft,
     id: uuidv4(),
     amount: draft.amount || 0,
@@ -40,11 +48,77 @@ export class TaxCategoryRepository extends AbstractRepository {
 
     // Catch this for now, should be checked when creating/updating
     if (result.count > 1) {
-      throw new Error('Duplicate tax categorie key')
+      throw new Error('Duplicate tax category key')
     }
 
     return
   }
 
-  actions = {}
+  actions: Partial<
+    Record<
+      TaxCategoryUpdateAction['action'],
+      (projectKey: string, resource: Writable<TaxCategory>, action: any) => void
+    >
+  > = {
+    addTaxRate: (
+      projectKey: string,
+      resource: Writable<TaxCategory>,
+      { taxRate }: TaxCategoryAddTaxRateAction
+    ) => {
+      if (resource.rates === undefined) {
+        resource.rates = []
+      }
+      resource.rates.push(this.taxRateFromTaxRateDraft(taxRate))
+    },
+    removeTaxRate: (
+      projectKey: string,
+      resource: Writable<TaxCategory>,
+      { taxRateId }: TaxCategoryRemoveTaxRateAction
+    ) => {
+      if (resource.rates === undefined) {
+        resource.rates = []
+      }
+      resource.rates = resource.rates.filter(taxRate => {
+        return taxRate.id !== taxRateId
+      })
+    },
+    replaceTaxRate: (
+      projectKey: string,
+      resource: Writable<TaxCategory>,
+      { taxRateId, taxRate }: TaxCategoryReplaceTaxRateAction
+    ) => {
+      if (resource.rates === undefined) {
+        resource.rates = []
+      }
+
+      const taxRateObj = this.taxRateFromTaxRateDraft(taxRate)
+      for (let i = 0; i < resource.rates.length; i++) {
+        const rate = resource.rates[i]
+        if (rate.id == taxRateId) {
+          resource.rates[i] = taxRateObj
+        }
+      }
+    },
+    setDescription: (
+      projectKey: string,
+      resource: Writable<TaxCategory>,
+      { description }: TaxCategorySetDescriptionAction
+    ) => {
+      resource.description = description
+    },
+    setKey: (
+      projectKey: string,
+      resource: Writable<TaxCategory>,
+      { key }: TaxCategorySetKeyAction
+    ) => {
+      resource.key = key
+    },
+    changeName: (
+      projectKey: string,
+      resource: Writable<TaxCategory>,
+      { name }: TaxCategoryChangeNameAction
+    ) => {
+      resource.name = name
+    },
+  }
 }