@labdigital/commercetools-mock 0.9.0 → 0.10.0

package/src/repositories/product.ts

@@ -6,8 +6,10 @@ import {
   ProductDraft,
   ProductPublishAction,
   ProductSetAttributeAction,
-  ProductType,
+  ProductSetDescriptionAction,
+  ProductSetKeyAction,
   ProductTypeReference,
+  ProductUpdateAction,
   ProductVariant,
   ProductVariantDraft,
   ReferenceTypeId,
@@ -17,6 +19,7 @@ import { getBaseResourceProperties } from '../helpers'
 import { AbstractResourceRepository, RepositoryContext } from './abstract'
 import { Writable } from '../types'
 import { getReferenceFromResourceIdentifier } from './helpers'
+import deepEqual from 'deep-equal'
 
 export class ProductRepository extends AbstractResourceRepository {
   getTypeId(): ReferenceTypeId {
@@ -52,97 +55,136 @@ export class ProductRepository extends AbstractResourceRepository {
       categories: [],
       masterVariant: variantFromDraft(1, draft.masterVariant),
       variants:
-        draft.variants?.map((variant, index) => {
-          return variantFromDraft(index + 2, variant)
-        }) ?? [],
+        draft.variants?.map((variant, index) =>
+          variantFromDraft(index + 2, variant)
+        ) ?? [],
 
-      // @ts-ignore
-      searchKeywords: draft.searchKeywords,
+      searchKeywords: draft.searchKeywords ?? {},
     }
 
     const resource: Product = {
       ...getBaseResourceProperties(),
+      key: draft.key,
       productType: productType,
       masterData: {
-        // @ts-ignore
-        current: draft.publish ? productData : undefined,
-        // @ts-ignore
-        staged: draft.publish ? undefined : productData,
-        hasStagedChanges: draft.publish ?? true,
+        current: productData,
+        staged: productData,
+        hasStagedChanges: false,
         published: draft.publish ?? false,
       },
     }
 
-    this.save(context, resource)
+    this.saveNew(context, resource)
 
     return resource
   }
 
-  actions = {
+  actions: Partial<
+    Record<
+      ProductUpdateAction['action'],
+      (
+        context: RepositoryContext,
+        resource: Writable<Product>,
+        action: any
+      ) => void
+    >
+  > = {
     publish: (
       context: RepositoryContext,
       resource: Writable<Product>,
       { scope }: ProductPublishAction
     ) => {
-      if (resource.masterData.staged) {
-        resource.masterData.current = resource.masterData.staged
-        // @ts-ignore
-        resource.masterData.staged = undefined
-      }
-      resource.masterData.hasStagedChanges = false
+      resource.masterData.current = resource.masterData.staged
       resource.masterData.published = true
+      checkForStagedChanges(resource)
+    },
+    unpublish: (
+      context: RepositoryContext,
+      resource: Writable<Product>,
+      // { action }: ProductUnpublishAction
+    ) => {
+      resource.masterData.published = false
+      checkForStagedChanges(resource)
     },
     setAttribute: (
       context: RepositoryContext,
       resource: Writable<Product>,
       { variantId, sku, name, value, staged }: ProductSetAttributeAction
     ) => {
-      const isStaged = staged !== undefined ? staged : false
-      const productData = getProductData(resource, isStaged)
-      const { variant, isMasterVariant, variantIndex } = getVariant(
-        productData,
-        variantId,
-        sku
-      )
-      if (!variant) {
-        throw new Error(
-          `Variant with id ${variantId} or sku ${sku} not found on product ${resource.id}`
+      const setAttr = (data: Writable<ProductData>) => {
+        const { variant, isMasterVariant, variantIndex } = getVariant(
+          data,
+          variantId,
+          sku
         )
-      }
+        if (!variant) {
+          throw new Error(
+            `Variant with id ${variantId} or sku ${sku} not found on product ${resource.id}`
+          )
+        }
 
-      if (!variant.attributes) {
-        variant.attributes = []
-      }
+        if (!variant.attributes) {
+          variant.attributes = []
+        }
 
-      const existingAttr = variant.attributes.find(attr => attr.name === name)
-      if (existingAttr) {
-        existingAttr.value = value
-      } else {
-        variant.attributes.push({
-          name,
-          value,
-        })
-      }
-      if (isStaged) {
-        resource.masterData.staged = productData
-        if (isMasterVariant) {
-          resource.masterData.staged.masterVariant = variant
+        const existingAttr = variant.attributes.find(
+          (attr) => attr.name === name
+        )
+        if (existingAttr) {
+          existingAttr.value = value
         } else {
-          resource.masterData.staged.variants[variantIndex] = variant
+          variant.attributes.push({
+            name,
+            value,
+          })
         }
-        resource.masterData.hasStagedChanges = true
-      } else {
-        resource.masterData.current = productData
         if (isMasterVariant) {
-          resource.masterData.current.masterVariant = variant
+          data.masterVariant = variant
         } else {
-          resource.masterData.current.variants[variantIndex] = variant
+          data.variants[variantIndex] = variant
         }
       }
+
+      // If true, only the staged Attribute is set. If false, both current and
+      // staged Attribute is set.  Default is true
+      const onlyStaged = staged !== undefined ? staged : true
+
+      // Write the attribute to the staged data
+      setAttr(resource.masterData.staged)
+
+      // Also write to published data is isStaged = false
+      // if isStaged is false we set the attribute on both the staged and
+      // published data.
+      if (!onlyStaged) {
+        setAttr(resource.masterData.current)
+      }
+      checkForStagedChanges(resource)
+
+      return resource
+    },
+    'setDescription': (
+      context: RepositoryContext,
+      resource: Writable<Product>,
+      { description, staged }: ProductSetDescriptionAction
+    ) => {
+      const onlyStaged = staged !== undefined ? staged : true
+
+      resource.masterData.staged.description = description
+      if (!onlyStaged) {
+        resource.masterData.current.description = description
+      }
+      checkForStagedChanges(resource)
+      return resource
+    },
+    'setKey': (
+      context: RepositoryContext,
+      resource: Writable<Product>,
+      { key }: ProductSetKeyAction
+    ) => {
+      resource.key = key
+      return resource
     },
-    // 'setKey': () => {},
     // 'changeName': () => {},
-    // 'setDescription': () => {},
     // 'changeSlug': () => {},
     // 'addVariant': () => {},
     // 'removeVariant': () => {},
@@ -181,16 +223,22 @@ export class ProductRepository extends AbstractResourceRepository {
     // 'setMetaKeywords': () => {},
     // 'revertStagedChanges': () => {},
     // 'revertStagedVariantChanges': () => {},
-    // 'unpublish': () => {},
     // 'transitionState': () => {},
   }
 }
 
-const getProductData = (product: Product, staged: boolean) => {
-  if (!staged && product.masterData.current) {
-    return product.masterData.current
+// Check if the product still has staged data that is different from the
+// current data.
+const checkForStagedChanges = (product: Writable<Product>) => {
+  if (!product.masterData.staged) {
+    product.masterData.staged = product.masterData.current
+  }
+
+  if (deepEqual(product.masterData.current, product.masterData.staged)) {
+    product.masterData.hasStagedChanges = false
+  } else {
+    product.masterData.hasStagedChanges = true
   }
-  return product.masterData.staged
 }
 
 interface VariantResult {
@@ -229,25 +277,21 @@ const getVariant = (
 const variantFromDraft = (
   variantId: number,
   variant: ProductVariantDraft
-): ProductVariant => {
-  return {
-    id: variantId,
-    sku: variant?.sku,
-    attributes: variant?.attributes ?? [],
-    prices: variant?.prices?.map(priceFromDraft),
-    assets: [],
-    images: [],
-  }
-}
+): ProductVariant => ({
+  id: variantId,
+  sku: variant?.sku,
+  attributes: variant?.attributes ?? [],
+  prices: variant?.prices?.map(priceFromDraft),
+  assets: [],
+  images: [],
+})
 
-const priceFromDraft = (draft: PriceDraft): Price => {
-  return {
-    id: uuidv4(),
-    value: {
-      currencyCode: draft.value.currencyCode,
-      centAmount: draft.value.centAmount,
-      fractionDigits: 2,
-      type: 'centPrecision',
-    },
-  }
-}
+const priceFromDraft = (draft: PriceDraft): Price => ({
+  id: uuidv4(),
+  value: {
+    currencyCode: draft.value.currencyCode,
+    centAmount: draft.value.centAmount,
+    fractionDigits: 2,
+    type: 'centPrecision',
+  },
+})

package/src/repositories/project.ts

@@ -13,10 +13,7 @@ import {
   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 { Resource, Writable } from 'types'
 import { AbstractRepository, RepositoryContext } from './abstract'
 import { maskSecretValue } from '../lib/masking'
 
@@ -26,34 +23,19 @@ export class ProjectRepository extends AbstractRepository {
     return this.postProcessResource(resource)
   }
 
-  postProcessResource(resource: any): any {
+  postProcessResource<T extends Resource>(resource: T): T {
     if (resource) {
-      return maskSecretValue(
-        resource, 'externalOAuth.authorizationHeader')
+      return maskSecretValue(resource, 'externalOAuth.authorizationHeader')
     }
     return resource
-
   }
 
-  save(context: RepositoryContext, resource: Project) {
-    const current = this.get(context)
-
-    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
-        )
-      }
-    }
+  saveNew(context: RepositoryContext, resource: Writable<Project>) {
+    resource.version = 1
+    this._storage.saveProject(resource)
+  }
 
-    // @ts-ignore
-    resource.version += 1
+  saveUpdate(context: RepositoryContext, version: number, resource: Project) {
     this._storage.saveProject(resource)
   }
 
@@ -147,7 +129,8 @@ export class ProjectRepository extends AbstractRepository {
         countryTaxRateFallbackEnabled,
       }: ProjectChangeCountryTaxRateFallbackEnabledAction
     ) => {
-      resource.carts.countryTaxRateFallbackEnabled = countryTaxRateFallbackEnabled
+      resource.carts.countryTaxRateFallbackEnabled =
+        countryTaxRateFallbackEnabled
     },
     changeCartsConfiguration: (
       context: RepositoryContext,

package/src/repositories/shipping-method.ts

@@ -47,7 +47,7 @@ export class ShippingMethodRepository extends AbstractResourceRepository {
         context.projectKey,
         this._storage
       ),
-      zoneRates: draft.zoneRates?.map(z =>
+      zoneRates: draft.zoneRates?.map((z) =>
         this._transformZoneRateDraft(context, z)
       ),
       custom: createCustomFields(
@@ -56,7 +56,7 @@ export class ShippingMethodRepository extends AbstractResourceRepository {
         this._storage
       ),
     }
-    this.save(context, resource)
+    this.saveNew(context, resource)
     return resource
   }
 
@@ -73,13 +73,11 @@ export class ShippingMethodRepository extends AbstractResourceRepository {
     shippingRates: draft.shippingRates?.map(this._transformShippingRate),
   })
 
-  private _transformShippingRate = (rate: ShippingRateDraft): ShippingRate => {
-    return {
-      price: createTypedMoney(rate.price),
-      freeAbove: rate.freeAbove && createTypedMoney(rate.freeAbove),
-      tiers: rate.tiers || [],
-    }
-  }
+  private _transformShippingRate = (rate: ShippingRateDraft): ShippingRate => ({
+    price: createTypedMoney(rate.price),
+    freeAbove: rate.freeAbove && createTypedMoney(rate.freeAbove),
+    tiers: rate.tiers || [],
+  })
 
   actions: Partial<
     Record<
@@ -98,7 +96,7 @@ export class ShippingMethodRepository extends AbstractResourceRepository {
     ) => {
       const rate = this._transformShippingRate(shippingRate)
 
-      resource.zoneRates.forEach(zoneRate => {
+      resource.zoneRates.forEach((zoneRate) => {
         if (zoneRate.zone.id === zone.id) {
           zoneRate.shippingRates.push(rate)
           return
@@ -119,11 +117,11 @@ export class ShippingMethodRepository extends AbstractResourceRepository {
     ) => {
       const rate = this._transformShippingRate(shippingRate)
 
-      resource.zoneRates.forEach(zoneRate => {
+      resource.zoneRates.forEach((zoneRate) => {
         if (zoneRate.zone.id === zone.id) {
-          zoneRate.shippingRates = zoneRate.shippingRates.filter(otherRate => {
-            return !deepEqual(rate, otherRate)
-          })
+          zoneRate.shippingRates = zoneRate.shippingRates.filter(
+            (otherRate) => !deepEqual(rate, otherRate)
+          )
         }
       })
     },
@@ -152,9 +150,9 @@ export class ShippingMethodRepository extends AbstractResourceRepository {
       resource: Writable<ShippingMethod>,
       { zone }: ShippingMethodRemoveZoneAction
     ) => {
-      resource.zoneRates = resource.zoneRates.filter(zoneRate => {
-        return zoneRate.zone.id !== zone.id
-      })
+      resource.zoneRates = resource.zoneRates.filter(
+        (zoneRate) => zoneRate.zone.id !== zone.id
+      )
     },
     setKey: (
       _context: RepositoryContext,

package/src/repositories/shopping-list.ts

@@ -27,7 +27,7 @@ export class ShoppingListRepository extends AbstractResourceRepository {
         this._storage
       ),
       textLineItems: [],
-      lineItems: draft.lineItems?.map(e => ({
+      lineItems: draft.lineItems?.map((e) => ({
         ...getBaseResourceProperties(),
         ...e,
         addedAt: e.addedAt ?? '',
@@ -48,7 +48,7 @@ export class ShoppingListRepository extends AbstractResourceRepository {
         ? { typeId: 'store', key: draft.store.key! }
         : undefined,
     }
-    this.save(context, resource)
+    this.saveNew(context, resource)
     return resource
   }
 }

package/src/repositories/state.ts

@@ -26,12 +26,12 @@ export class StateRepository extends AbstractResourceRepository {
       ...draft,
       builtIn: false,
       initial: draft.initial || false,
-      transitions: (draft.transitions || []).map(t =>
+      transitions: (draft.transitions || []).map((t) =>
         getReferenceFromResourceIdentifier(t, context.projectKey, this._storage)
       ),
     }
 
-    this.save(context, resource)
+    this.saveNew(context, resource)
     return resource
   }
 
@@ -78,12 +78,12 @@ export class StateRepository extends AbstractResourceRepository {
       resource: Writable<State>,
       { transitions }: StateSetTransitionsAction
     ) => {
-      resource.transitions = transitions?.map((resourceId): StateReference => {
-        return {
-          id: resourceId.id || "",
-          typeId: "state",
-        }
-      })
-    }
+      resource.transitions = transitions?.map(
+        (resourceId): StateReference => ({
+          id: resourceId.id || '',
+          typeId: 'state',
+        })
+      )
+    },
   }
 }

package/src/repositories/store.ts

@@ -42,7 +42,7 @@ export class StoreRepository extends AbstractResourceRepository {
         this._storage
       ),
     }
-    this.save(context, resource)
+    this.saveNew(context, resource)
     return resource
   }
 
@@ -52,7 +52,7 @@ export class StoreRepository extends AbstractResourceRepository {
   ) {
     if (!channels) return []
 
-    return channels.map(ref =>
+    return channels.map((ref) =>
       getReferenceFromResourceIdentifier<ChannelReference>(
         ref,
         context.projectKey,

package/src/repositories/subscription.ts

@@ -44,7 +44,7 @@ export class SubscriptionRepository extends AbstractResourceRepository {
       messages: draft.messages || [],
       status: 'Healthy',
     }
-    this.save(context, resource)
+    this.saveNew(context, resource)
     return resource
   }
 }

package/src/repositories/tax-category.ts

@@ -28,7 +28,7 @@ export class TaxCategoryRepository extends AbstractResourceRepository {
       ...draft,
       rates: draft.rates?.map(this.taxRateFromTaxRateDraft) || [],
     }
-    this.save(context, resource)
+    this.saveNew(context, resource)
     return resource
   }
 
@@ -82,9 +82,9 @@ export class TaxCategoryRepository extends AbstractResourceRepository {
       if (resource.rates === undefined) {
         resource.rates = []
       }
-      resource.rates = resource.rates.filter(taxRate => {
-        return taxRate.id !== taxRateId
-      })
+      resource.rates = resource.rates.filter(
+        (taxRate) => taxRate.id !== taxRateId
+      )
     },
     replaceTaxRate: (
       context: RepositoryContext,

package/src/repositories/type.ts

@@ -33,7 +33,7 @@ export class TypeRepository extends AbstractResourceRepository {
       fieldDefinitions: draft.fieldDefinitions || [],
       description: draft.description,
     }
-    this.save(context, resource)
+    this.saveNew(context, resource)
     return resource
   }
   actions: Partial<
@@ -58,9 +58,9 @@ export class TypeRepository extends AbstractResourceRepository {
       resource: Writable<Type>,
       { fieldName }: TypeRemoveFieldDefinitionAction
     ) => {
-      resource.fieldDefinitions = resource.fieldDefinitions.filter(f => {
-        return f.name !== fieldName
-      })
+      resource.fieldDefinitions = resource.fieldDefinitions.filter(
+        (f) => f.name !== fieldName
+      )
     },
     setDescription: (
       context: RepositoryContext,
@@ -82,12 +82,12 @@ export class TypeRepository extends AbstractResourceRepository {
       { fieldNames }: TypeChangeFieldDefinitionOrderAction
     ) => {
       const fields = new Map(
-        resource.fieldDefinitions.map(item => [item.name, item])
+        resource.fieldDefinitions.map((item) => [item.name, item])
       )
       const result: FieldDefinition[] = []
       let current = resource.fieldDefinitions
 
-      fieldNames.forEach(fieldName => {
+      fieldNames.forEach((fieldName) => {
         const field = fields.get(fieldName)
         if (field === undefined) {
           throw new Error('New field')
@@ -95,15 +95,13 @@ export class TypeRepository extends AbstractResourceRepository {
         result.push(field)
 
         // Remove from current items
-        current = current.filter(f => {
-          return f.name !== fieldName
-        })
+        current = current.filter((f) => f.name !== fieldName)
       })
 
       if (
         isEqual(
           fieldNames,
-          resource.fieldDefinitions.map(item => item.name)
+          resource.fieldDefinitions.map((item) => item.name)
         )
       ) {
         throw new CommercetoolsError<InvalidOperationError>({
@@ -126,7 +124,7 @@ export class TypeRepository extends AbstractResourceRepository {
       resource: Writable<Type>,
       { fieldName, value }: TypeAddEnumValueAction
     ) => {
-      resource.fieldDefinitions.forEach(field => {
+      resource.fieldDefinitions.forEach((field) => {
         if (field.name === fieldName) {
           // TODO, should be done better i suppose
           if (field.type.name === 'Enum') {
@@ -147,11 +145,11 @@ export class TypeRepository extends AbstractResourceRepository {
       resource: Writable<Type>,
       { fieldName, value }: TypeChangeEnumValueLabelAction
     ) => {
-      resource.fieldDefinitions.forEach(field => {
+      resource.fieldDefinitions.forEach((field) => {
         if (field.name === fieldName) {
           // TODO, should be done better i suppose
           if (field.type.name === 'Enum') {
-            field.type.values.forEach(v => {
+            field.type.values.forEach((v) => {
               if (v.key === value.key) {
                 v.label = value.label
               }
@@ -160,7 +158,7 @@ export class TypeRepository extends AbstractResourceRepository {
             field.type.name === 'Set' &&
             field.type.elementType.name === 'Enum'
           ) {
-            field.type.elementType.values.forEach(v => {
+            field.type.elementType.values.forEach((v) => {
               if (v.key === value.key) {
                 v.label = value.label
               }

package/src/repositories/zone.ts

@@ -26,7 +26,7 @@ export class ZoneRepository extends AbstractResourceRepository {
       name: draft.name,
       description: draft.description,
     }
-    this.save(context, resource)
+    this.saveNew(context, resource)
     return resource
   }
 
@@ -52,11 +52,10 @@ export class ZoneRepository extends AbstractResourceRepository {
       resource: Writable<Zone>,
       { location }: ZoneRemoveLocationAction
     ) => {
-      resource.locations = resource.locations.filter(loc => {
-        return !(
-          loc.country === location.country && loc.state === location.state
-        )
-      })
+      resource.locations = resource.locations.filter(
+        (loc) =>
+          !(loc.country === location.country && loc.state === location.state)
+      )
     },
     changeName: (
       context: RepositoryContext,

package/src/server.ts

@@ -1,5 +1,10 @@
 import { CommercetoolsMock } from './index'
 
+process.on('SIGINT', function() {
+    console.info("Stopping server...")
+    process.exit();
+});
+
 const instance = new CommercetoolsMock()
 
 let port = 3000