@labdigital/commercetools-mock 0.9.1 → 0.10.1

package/src/repositories/product-type.ts

@@ -1,25 +1,24 @@
-import { getBaseResourceProperties } from '../helpers'
 import {
   AttributeDefinition,
   AttributeDefinitionDraft,
   AttributeType,
   ProductType,
   ProductTypeAddAttributeDefinitionAction,
-  ProductTypeChangeAttributeOrderAction,
+  ProductTypeChangeAttributeOrderByNameAction,
   ProductTypeChangeLabelAction,
   ProductTypeChangeLocalizedEnumValueLabelAction,
   ProductTypeDraft,
   ProductTypeRemoveAttributeDefinitionAction,
   ProductTypeRemoveEnumValuesAction,
   ProductTypeUpdateAction,
-  ReferenceTypeId,
 } from '@commercetools/platform-sdk'
+import { getBaseResourceProperties } from '../helpers'
+import { Writable } from '../types'
 import { AbstractResourceRepository, RepositoryContext } from './abstract'
-import { Writable } from 'types'
 
-export class ProductTypeRepository extends AbstractResourceRepository {
-  getTypeId(): ReferenceTypeId {
-    return 'product-type'
+export class ProductTypeRepository extends AbstractResourceRepository<'product-type'> {
+  getTypeId() {
+    return 'product-type' as const
   }
 
   create(context: RepositoryContext, draft: ProductTypeDraft): ProductType {
@@ -28,46 +27,28 @@ export class ProductTypeRepository extends AbstractResourceRepository {
       key: draft.key,
       name: draft.name,
       description: draft.description,
-      attributes: (draft.attributes ?? []).map(a =>
+      attributes: (draft.attributes ?? []).map((a) =>
         this.attributeDefinitionFromAttributeDefinitionDraft(context, a)
       ),
     }
 
-    this.save(context, resource)
+    this.saveNew(context, resource)
     return resource
   }
 
   attributeDefinitionFromAttributeDefinitionDraft = (
     _context: RepositoryContext,
     draft: AttributeDefinitionDraft
-  ): AttributeDefinition => {
-    return {
-      ...draft,
-      attributeConstraint: draft.attributeConstraint ?? 'None',
-      inputHint: draft.inputHint ?? 'SingleLine',
-      inputTip:
-        draft.inputTip && Object.keys(draft.inputTip).length > 0
-          ? draft.inputTip
-          : undefined,
-      isSearchable: draft.isSearchable ?? true,
-    }
-  }
-
-  getWithKey(context: RepositoryContext, key: string): ProductType | undefined {
-    const result = this._storage.query(context.projectKey, this.getTypeId(), {
-      where: [`key="${key}"`],
-    })
-    if (result.count === 1) {
-      return result.results[0] as ProductType
-    }
-
-    // Catch this for now, should be checked when creating/updating
-    if (result.count > 1) {
-      throw new Error('Duplicate product type key')
-    }
-
-    return
-  }
+  ): AttributeDefinition => ({
+    ...draft,
+    attributeConstraint: draft.attributeConstraint ?? 'None',
+    inputHint: draft.inputHint ?? 'SingleLine',
+    inputTip:
+      draft.inputTip && Object.keys(draft.inputTip).length > 0
+        ? draft.inputTip
+        : undefined,
+    isSearchable: draft.isSearchable ?? true,
+  })
 
   actions: Partial<
     Record<
@@ -90,7 +71,7 @@ export class ProductTypeRepository extends AbstractResourceRepository {
       const updateAttributeType = (type: Writable<AttributeType>) => {
         switch (type.name) {
           case 'lenum':
-            type.values.forEach(v => {
+            type.values.forEach((v) => {
               if (v.key === newValue.key) {
                 v.label = newValue.label
               }
@@ -102,7 +83,7 @@ export class ProductTypeRepository extends AbstractResourceRepository {
         }
       }
 
-      resource.attributes?.forEach(value => {
+      resource.attributes?.forEach((value) => {
         if (value.name === attributeName) {
           updateAttributeType(value.type)
         }
@@ -113,7 +94,7 @@ export class ProductTypeRepository extends AbstractResourceRepository {
       resource: Writable<ProductType>,
       { attributeName, label }: ProductTypeChangeLabelAction
     ) => {
-      resource.attributes?.forEach(value => {
+      resource.attributes?.forEach((value) => {
         if (value.name === attributeName) {
           value.label = label
         }
@@ -128,26 +109,26 @@ export class ProductTypeRepository extends AbstractResourceRepository {
         this.attributeDefinitionFromAttributeDefinitionDraft(context, attribute)
       )
     },
-    changeAttributeOrder: (
+    changeAttributeOrderByName: (
       context: RepositoryContext,
       resource: Writable<ProductType>,
-      { attributes }: ProductTypeChangeAttributeOrderAction
+      { attributeNames }: ProductTypeChangeAttributeOrderByNameAction
     ) => {
-      const attrs = new Map(resource.attributes?.map(item => [item.name, item]))
+      const attrs = new Map(
+        resource.attributes?.map((item) => [item.name, item])
+      )
       const result: AttributeDefinition[] = []
       let current = resource.attributes
 
-      attributes.forEach(iAttr => {
-        const attr = attrs.get(iAttr.name)
+      attributeNames.forEach((attrName) => {
+        const attr = attrs.get(attrName)
         if (attr === undefined) {
           throw new Error('New attr')
         }
         result.push(attr)
 
         // Remove from current items
-        current = current?.filter(f => {
-          return f.name !== iAttr.name
-        })
+        current = current?.filter((f) => f.name !== attrName)
       })
 
       resource.attributes = result
@@ -162,30 +143,27 @@ export class ProductTypeRepository extends AbstractResourceRepository {
       resource: Writable<ProductType>,
       { name }: ProductTypeRemoveAttributeDefinitionAction
     ) => {
-      resource.attributes = resource.attributes?.filter(f => {
-        return f.name !== name
-      })
+      resource.attributes = resource.attributes?.filter((f) => f.name !== name)
     },
     removeEnumValues: (
       context: RepositoryContext,
       resource: Writable<ProductType>,
       { attributeName, keys }: ProductTypeRemoveEnumValuesAction
     ) => {
-      resource.attributes?.forEach(attr => {
+      resource.attributes?.forEach((attr) => {
         if (attr.name == attributeName) {
           if (attr.type.name == 'enum') {
-            attr.type.values = attr.type.values.filter(v => {
-              return !keys.includes(v.key)
-            })
+            attr.type.values = attr.type.values.filter(
+              (v) => !keys.includes(v.key)
+            )
           }
 
           if (attr.type.name == 'set') {
             if (attr.type.elementType.name == 'enum') {
-              attr.type.elementType.values = attr.type.elementType.values.filter(
-                v => {
-                  return !keys.includes(v.key)
-                }
-              )
+              attr.type.elementType.values =
+                attr.type.elementType.values.filter(
+                  (v) => !keys.includes(v.key)
+                )
             }
           }
         }

package/src/repositories/product.ts

@@ -6,21 +6,23 @@ import {
   ProductDraft,
   ProductPublishAction,
   ProductSetAttributeAction,
-  ProductType,
+  ProductSetDescriptionAction,
+  ProductSetKeyAction,
   ProductTypeReference,
+  ProductUpdateAction,
   ProductVariant,
   ProductVariantDraft,
-  ReferenceTypeId,
 } from '@commercetools/platform-sdk'
 import { v4 as uuidv4 } from 'uuid'
+import { Writable } from '../types'
 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 {
-    return 'product'
+export class ProductRepository extends AbstractResourceRepository<'product'> {
+  getTypeId() {
+    return 'product' as const
   }
 
   create(context: RepositoryContext, draft: ProductDraft): Product {
@@ -52,97 +54,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 +222,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 +276,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

@@ -5,7 +5,7 @@ import {
   ProjectChangeCountryTaxRateFallbackEnabledAction,
   ProjectChangeCurrenciesAction,
   ProjectChangeLanguagesAction,
-  ProjectChangeMessagesEnabledAction,
+  ProjectChangeMessagesConfigurationAction,
   ProjectChangeNameAction,
   ProjectChangeOrderSearchStatusAction,
   ProjectChangeProductSearchIndexingEnabledAction,
@@ -13,47 +13,29 @@ 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 { AbstractRepository, RepositoryContext } from './abstract'
 import { maskSecretValue } from '../lib/masking'
+import { Writable } from '../types'
+import { AbstractRepository, RepositoryContext } from './abstract'
 
-export class ProjectRepository extends AbstractRepository {
+export class ProjectRepository extends AbstractRepository<Project> {
   get(context: RepositoryContext): Project | null {
     const resource = this._storage.getProject(context.projectKey)
     return this.postProcessResource(resource)
   }
 
-  postProcessResource(resource: any): any {
+  postProcessResource(resource: Project): Project {
     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)
   }
 
@@ -95,12 +77,12 @@ export class ProjectRepository extends AbstractRepository {
     ) => {
       resource.languages = languages
     },
-    changeMessagesEnabled: (
+    changeMessagesConfiguration: (
       context: RepositoryContext,
       resource: Writable<Project>,
-      { messagesEnabled }: ProjectChangeMessagesEnabledAction
+      { messagesConfiguration }: ProjectChangeMessagesConfigurationAction
     ) => {
-      resource.messages.enabled = messagesEnabled
+      resource.messages.enabled = messagesConfiguration.enabled
     },
     changeProductSearchIndexingEnabled: (
       context: RepositoryContext,
@@ -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/quote-request.ts

@@ -0,0 +1,28 @@
+import {
+  QuoteRequest,
+  QuoteRequestDraft,
+  QuoteRequestUpdateAction,
+} from '@commercetools/platform-sdk'
+import { Writable } from '../types'
+import { AbstractResourceRepository, RepositoryContext } from './abstract'
+
+export class QuoteRequestRepository extends AbstractResourceRepository<'quote-request'> {
+  getTypeId() {
+    return 'quote-request' as const
+  }
+
+  create(context: RepositoryContext, draft: QuoteRequestDraft): QuoteRequest {
+    throw new Error('not implemented')
+  }
+
+  actions: Partial<
+    Record<
+      QuoteRequestUpdateAction['action'],
+      (
+        context: RepositoryContext,
+        resource: Writable<QuoteRequest>,
+        action: any
+      ) => void
+    >
+  > = {}
+}

package/src/repositories/quote.ts

@@ -0,0 +1,28 @@
+import {
+  Quote,
+  QuoteDraft,
+  QuoteUpdateAction,
+} from '@commercetools/platform-sdk'
+import { Writable } from '../types'
+import { AbstractResourceRepository, RepositoryContext } from './abstract'
+
+export class QuoteRepository extends AbstractResourceRepository<'quote'> {
+  getTypeId() {
+    return 'quote' as const
+  }
+
+  create(context: RepositoryContext, draft: QuoteDraft): Quote {
+    throw new Error('not implemented')
+  }
+
+  actions: Partial<
+    Record<
+      QuoteUpdateAction['action'],
+      (
+        context: RepositoryContext,
+        resource: Writable<Quote>,
+        action: any
+      ) => void
+    >
+  > = {}
+}

package/src/repositories/review.ts

@@ -0,0 +1,34 @@
+import {
+  Review,
+  ReviewDraft,
+  ReviewUpdateAction,
+} from '@commercetools/platform-sdk'
+import { getBaseResourceProperties } from '../helpers'
+import { Writable } from '../types'
+import { AbstractResourceRepository, RepositoryContext } from './abstract'
+
+export class ReviewRepository extends AbstractResourceRepository<'review'> {
+  getTypeId() {
+    return 'review' as const
+  }
+
+  create(context: RepositoryContext, draft: ReviewDraft): Review {
+    const resource: Review = {
+      ...getBaseResourceProperties(),
+      includedInStatistics: false,
+    }
+    this.saveNew(context, resource)
+    return resource
+  }
+
+  actions: Partial<
+    Record<
+      ReviewUpdateAction['action'],
+      (
+        context: RepositoryContext,
+        resource: Writable<Review>,
+        action: any
+      ) => void
+    >
+  > = {}
+}