@labdigital/commercetools-mock 0.5.11 → 0.5.14

package/src/repositories/extension.ts

@@ -0,0 +1,65 @@
+import {
+  Extension,
+  ExtensionChangeDestinationAction,
+  ExtensionChangeTriggersAction,
+  ExtensionDraft,
+  ExtensionSetKeyAction,
+  ExtensionSetTimeoutInMsAction,
+  ExtensionUpdateAction,
+  ReferenceTypeId,
+} from '@commercetools/platform-sdk'
+import { Writable } from '../types'
+import { getBaseResourceProperties } from '../helpers'
+import { AbstractResourceRepository } from './abstract'
+
+export class ExtensionRepository extends AbstractResourceRepository {
+  getTypeId(): ReferenceTypeId {
+    return 'extension'
+  }
+
+  create(projectKey: string, draft: ExtensionDraft): Extension {
+    const resource: Extension = {
+      ...getBaseResourceProperties(),
+      key: draft.key,
+      timeoutInMs: draft.timeoutInMs,
+      destination: draft.destination,
+      triggers: draft.triggers,
+    }
+    this.save(projectKey, resource)
+    return resource
+  }
+
+  actions: Record<
+    ExtensionUpdateAction['action'],
+    (projectKey: string, resource: Writable<Extension>, action: any) => void
+  > = {
+    setKey: (
+      projectKey: string,
+      resource: Writable<Extension>,
+      { key }: ExtensionSetKeyAction
+    ) => {
+      resource.key = key
+    },
+    setTimeoutInMs: (
+      projectKey: string,
+      resource: Writable<Extension>,
+      { timeoutInMs }: ExtensionSetTimeoutInMsAction
+    ) => {
+      resource.timeoutInMs = timeoutInMs
+    },
+    changeTriggers: (
+      projectKey: string,
+      resource: Writable<Extension>,
+      { triggers }: ExtensionChangeTriggersAction
+    ) => {
+      resource.triggers = triggers
+    },
+    changeDestination: (
+      projectKey: string,
+      resource: Writable<Extension>,
+      { destination }: ExtensionChangeDestinationAction
+    ) => {
+      resource.destination = destination
+    },
+  }
+}

package/src/repositories/inventory-entry.ts

@@ -9,11 +9,11 @@ import {
   ReferenceTypeId,
 } from '@commercetools/platform-sdk'
 import { getBaseResourceProperties } from '../helpers'
-import AbstractRepository from './abstract'
+import { AbstractResourceRepository } from './abstract'
 import { createCustomFields } from './helpers'
 import { Writable } from '../types'
 
-export class InventoryEntryRepository extends AbstractRepository {
+export class InventoryEntryRepository extends AbstractResourceRepository {
   getTypeId(): ReferenceTypeId {
     return 'inventory-entry'
   }

package/src/repositories/order.ts

@@ -26,7 +26,7 @@ import {
   ReferenceTypeId,
   Store,
 } from '@commercetools/platform-sdk'
-import AbstractRepository, { QueryParams } from './abstract'
+import { AbstractResourceRepository, QueryParams } from './abstract'
 import {
   createCustomFields,
   createPrice,
@@ -37,7 +37,7 @@ import { Writable } from '../types'
 import { getBaseResourceProperties } from '../helpers'
 import { CommercetoolsError } from '../exceptions'
 
-export class OrderRepository extends AbstractRepository {
+export class OrderRepository extends AbstractResourceRepository {
   getTypeId(): ReferenceTypeId {
     return 'order'
   }

package/src/repositories/payment.ts

@@ -8,7 +8,7 @@ import {
   StateReference,
   TransactionDraft,
 } from '@commercetools/platform-sdk'
-import AbstractRepository from './abstract'
+import { AbstractResourceRepository } from './abstract'
 import {
   createCustomFields,
   createTypedMoney,
@@ -18,7 +18,7 @@ import { getBaseResourceProperties } from '../helpers'
 import { v4 as uuidv4 } from 'uuid'
 import { Writable } from '../types'
 
-export class PaymentRepository extends AbstractRepository {
+export class PaymentRepository extends AbstractResourceRepository {
   getTypeId(): ReferenceTypeId {
     return 'payment'
   }
@@ -40,8 +40,8 @@ export class PaymentRepository extends AbstractRepository {
               : undefined,
           }
         : {},
-      transactions: (draft.transactions || []).map(
-        this.transactionFromTransactionDraft
+      transactions: (draft.transactions || []).map(t =>
+        this.transactionFromTransactionDraft(t, projectKey)
       ),
       interfaceInteractions: (draft.interfaceInteractions || []).map(
         interaction =>
@@ -54,10 +54,14 @@ export class PaymentRepository extends AbstractRepository {
     return resource
   }
 
-  transactionFromTransactionDraft = (draft: TransactionDraft) => ({
+  transactionFromTransactionDraft = (
+    draft: TransactionDraft,
+    projectKey: string
+  ) => ({
     ...draft,
     id: uuidv4(),
     amount: createTypedMoney(draft.amount),
+    custom: createCustomFields(draft.custom, projectKey, this._storage),
   })
 
   actions = {
@@ -104,7 +108,7 @@ export class PaymentRepository extends AbstractRepository {
     ) => {
       resource.transactions = [
         ...resource.transactions,
-        this.transactionFromTransactionDraft(transaction),
+        this.transactionFromTransactionDraft(transaction, projectKey),
       ]
     },
     // addInterfaceInteraction: () => {},

package/src/repositories/product-projection.ts

@@ -0,0 +1,74 @@
+import { ParsedQs } from 'qs'
+import {
+  ProductDraft,
+  ProductProjection,
+  ProductVariant,
+  ProductVariantDraft,
+} from '@commercetools/platform-sdk'
+import { getBaseResourceProperties } from '../helpers'
+import { AbstractResourceRepository } from './abstract'
+import { RepositoryTypes } from '../types'
+import { parseFilterExpression } from '../lib/filterParser'
+
+export class ProductProjectionRepository extends AbstractResourceRepository {
+  getTypeId(): RepositoryTypes {
+    return 'product-projection'
+  }
+
+  create(projectKey: string, draft: ProductDraft): ProductProjection {
+    if (!draft.masterVariant) {
+      throw new Error(
+        `must provider mastervariant for product projection with key ${draft.key}`
+      )
+    }
+
+    if (!draft.productType.id) {
+      throw new Error(
+        `must provider product type id for product projection with key ${draft.key}`
+      )
+    }
+
+    const resource: ProductProjection = {
+      ...getBaseResourceProperties(),
+      name: draft.name,
+      slug: draft.slug,
+      categories: [],
+      productType: { ...draft.productType, id: draft.productType.id! },
+      masterVariant: variantFromDraft(0, draft.masterVariant!),
+      variants:
+        draft.variants?.map((variant, index) => {
+          return variantFromDraft(index + 1, variant)
+        }) ?? [],
+
+      // @ts-ignore
+      searchKeywords: draft.searchKeywords,
+    }
+
+    this.save(projectKey, resource)
+
+    return resource
+  }
+
+  search(projectKey: string, query: ParsedQs) {
+    const wherePredicate = parseFilterExpression(query.filter as any)
+
+    const results = this._storage.query(projectKey, this.getTypeId(), {
+      where: wherePredicate,
+    }) //TODO: this is a partial implementation, but I don't really have the time to implement an actual search API right now
+
+    return results
+  }
+
+  actions = {}
+}
+
+const variantFromDraft = (
+  variantId: number,
+  variant: ProductVariantDraft
+): ProductVariant => {
+  return {
+    id: variantId,
+    sku: variant?.sku,
+    attributes: variant?.attributes,
+  }
+}

package/src/repositories/product-type.ts

@@ -2,13 +2,18 @@ import { getBaseResourceProperties } from '../helpers'
 import {
   AttributeDefinition,
   AttributeDefinitionDraft,
+  AttributeType,
   ProductType,
+  ProductTypeChangeLabelAction,
+  ProductTypeChangeLocalizedEnumValueLabelAction,
   ProductTypeDraft,
+  ProductTypeUpdateAction,
   ReferenceTypeId,
 } from '@commercetools/platform-sdk'
-import AbstractRepository from './abstract'
+import { AbstractResourceRepository } from './abstract'
+import { Writable } from 'types'
 
-export class ProductTypeRepository extends AbstractRepository {
+export class ProductTypeRepository extends AbstractResourceRepository {
   getTypeId(): ReferenceTypeId {
     return 'product-type'
   }
@@ -16,7 +21,9 @@ export class ProductTypeRepository extends AbstractRepository {
   create(projectKey: string, draft: ProductTypeDraft): ProductType {
     const resource: ProductType = {
       ...getBaseResourceProperties(),
-      ...draft,
+      key: draft.key,
+      name: draft.name,
+      description: draft.description,
       attributes: (draft.attributes ?? []).map(a =>
         this.attributeDefinitionFromAttributeDefinitionDraft(projectKey, a)
       ),
@@ -52,5 +59,51 @@ export class ProductTypeRepository extends AbstractRepository {
     return
   }
 
-  actions = {}
+  actions: Partial<
+    Record<
+      ProductTypeUpdateAction['action'],
+      (projectKey: string, resource: Writable<ProductType>, action: any) => void
+    >
+  > = {
+    changeLocalizedEnumValueLabel: (
+      projectKey: string,
+      resource: Writable<ProductType>,
+      {
+        attributeName,
+        newValue,
+      }: ProductTypeChangeLocalizedEnumValueLabelAction
+    ) => {
+      const updateAttributeType = (type: Writable<AttributeType>) => {
+        switch (type.name) {
+          case 'lenum':
+            type.values.forEach(v => {
+              if (v.key == newValue.key) {
+                v.label = newValue.label
+              }
+            })
+            return
+          case 'set':
+            updateAttributeType(type.elementType)
+            return
+        }
+      }
+
+      resource.attributes?.forEach(value => {
+        if (value.name == attributeName) {
+          updateAttributeType(value.type)
+        }
+      })
+    },
+    changeLabel: (
+      projectKey: string,
+      resource: Writable<ProductType>,
+      { attributeName, label }: ProductTypeChangeLabelAction
+    ) => {
+      resource.attributes?.forEach(value => {
+        if (value.name == attributeName) {
+          value.label = label
+        }
+      })
+    },
+  }
 }

package/src/repositories/product.ts

@@ -1,4 +1,5 @@
 import {
+  Price,
   Product,
   ProductData,
   ProductDraft,
@@ -9,10 +10,10 @@ import {
   ReferenceTypeId,
 } from '@commercetools/platform-sdk'
 import { getBaseResourceProperties } from '../helpers'
-import AbstractRepository from './abstract'
+import { AbstractResourceRepository } from './abstract'
 import { Writable } from '../types'
 
-export class ProductRepository extends AbstractRepository {
+export class ProductRepository extends AbstractResourceRepository {
   getTypeId(): ReferenceTypeId {
     return 'product'
   }
@@ -207,5 +208,6 @@ const variantFromDraft = (
     id: variantId,
     sku: variant?.sku,
     attributes: variant?.attributes,
+    prices: variant?.prices as Price[],
   }
 }

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
+    },
+  }
 }