@labdigital/commercetools-mock 0.6.5 → 0.7.0

package/src/repositories/helpers.ts

@@ -1,11 +1,15 @@
 import { v4 as uuidv4 } from 'uuid'
 import {
+  Address,
+  BaseAddress,
   CustomFields,
   CustomFieldsDraft,
+  InvalidJsonInputError,
   Money,
   Price,
   PriceDraft,
   Reference,
+  ReferencedResourceNotFoundError,
   ResourceIdentifier,
   Store,
   StoreKeyReference,
@@ -13,9 +17,26 @@ import {
   Type,
   TypedMoney,
 } from '@commercetools/platform-sdk'
+import { Request } from 'express'
 import { AbstractStorage } from '../storage'
 import { RepositoryContext } from './abstract'
-import { Request } from 'express'
+import { CommercetoolsError } from '../exceptions'
+
+export const createAddress = (
+  base: BaseAddress | undefined,
+  projectKey: string,
+  storage: AbstractStorage
+): Address | undefined => {
+  if (!base) return undefined
+
+  if (!base?.country) {
+    throw new Error('Country is required')
+  }
+
+  return {
+    ...base,
+  }
+}
 
 export const createCustomFields = (
   draft: CustomFieldsDraft | undefined,
@@ -84,14 +105,35 @@ export const getReferenceFromResourceIdentifier = <T extends Reference>(
   projectKey: string,
   storage: AbstractStorage
 ): T => {
+  if (!resourceIdentifier.id && !resourceIdentifier.key) {
+    throw new CommercetoolsError<InvalidJsonInputError>(
+      {
+        code: 'InvalidJsonInput',
+        message: `${resourceIdentifier.typeId}: ResourceIdentifier requires an 'id' xor a 'key'`,
+      },
+      400
+    )
+  }
+
   const resource = storage.getByResourceIdentifier(
     projectKey,
     resourceIdentifier
   )
-  if (!resource)
-    throw new Error(
-      `resource type ${resourceIdentifier.typeId} with id ${resourceIdentifier.id} and key ${resourceIdentifier.key} not found`
+  if (!resource) {
+    const errIdentifier = resourceIdentifier.key
+      ? `key '${resourceIdentifier.key}'`
+      : `identifier '${resourceIdentifier.key}'`
+
+    throw new CommercetoolsError<ReferencedResourceNotFoundError>(
+      {
+        code: 'ReferencedResourceNotFound',
+        // @ts-ignore
+        typeId: resourceIdentifier.typeId,
+        message: `The referenced object of type '${resourceIdentifier.typeId}' with '${errIdentifier}' was not found. It either doesn't exist, or it can't be accessed from this endpoint (e.g., if the endpoint filters by store or customer account).`,
+      },
+      400
     )
+  }
 
   return ({
     typeId: resourceIdentifier.typeId,

package/src/repositories/product-discount.ts

@@ -0,0 +1,181 @@
+import {
+  ProductDiscount,
+  ProductDiscountChangeIsActiveAction,
+  ProductDiscountChangeNameAction,
+  ProductDiscountChangePredicateAction,
+  ProductDiscountChangeSortOrderAction,
+  ProductDiscountChangeValueAction,
+  ProductDiscountDraft,
+  ProductDiscountSetDescriptionAction,
+  ProductDiscountSetKeyAction,
+  ProductDiscountSetValidFromAction,
+  ProductDiscountSetValidFromAndUntilAction,
+  ProductDiscountSetValidUntilAction,
+  ProductDiscountUpdateAction,
+  ProductDiscountValue,
+  ProductDiscountValueAbsolute,
+  ProductDiscountValueDraft,
+  ProductDiscountValueExternal,
+  ProductDiscountValueRelative,
+  ReferenceTypeId,
+} from '@commercetools/platform-sdk'
+import { Writable } from 'types'
+import { getBaseResourceProperties } from '../helpers'
+import { AbstractResourceRepository, RepositoryContext } from './abstract'
+import { createTypedMoney } from './helpers'
+
+export class ProductDiscountRepository extends AbstractResourceRepository {
+  getTypeId(): ReferenceTypeId {
+    return 'product-discount'
+  }
+
+  create(
+    context: RepositoryContext,
+    draft: ProductDiscountDraft
+  ): ProductDiscount {
+    const resource: ProductDiscount = {
+      ...getBaseResourceProperties(),
+      key: draft.key,
+      name: draft.name,
+      description: draft.description,
+      value: this.transformValueDraft(draft.value),
+      predicate: draft.predicate,
+      sortOrder: draft.sortOrder,
+      isActive: draft.isActive || false,
+      validFrom: draft.validFrom,
+      validUntil: draft.validUntil,
+      references: [],
+    }
+    this.save(context, resource)
+    return resource
+  }
+
+  private transformValueDraft(
+    value: ProductDiscountValueDraft
+  ): ProductDiscountValue {
+    switch (value.type) {
+      case 'absolute': {
+        return {
+          type: 'absolute',
+          money: value.money.map(createTypedMoney),
+        } as ProductDiscountValueAbsolute
+      }
+      case 'external': {
+        return {
+          type: 'external',
+        } as ProductDiscountValueExternal
+      }
+      case 'relative': {
+        return {
+          ...value,
+        } as ProductDiscountValueRelative
+      }
+    }
+  }
+
+  getWithKey(
+    context: RepositoryContext,
+    key: string
+  ): ProductDiscount | undefined {
+    const result = this._storage.query(context.projectKey, this.getTypeId(), {
+      where: [`key="${key}"`],
+    })
+    if (result.count === 1) {
+      return result.results[0] as ProductDiscount
+    }
+
+    // Catch this for now, should be checked when creating/updating
+    if (result.count > 1) {
+      throw new Error('Duplicate product discount key')
+    }
+
+    return
+  }
+
+  actions: Partial<
+    Record<
+      ProductDiscountUpdateAction['action'],
+      (
+        context: RepositoryContext,
+        resource: Writable<ProductDiscount>,
+        action: any
+      ) => void
+    >
+  > = {
+    setKey: (
+      context: RepositoryContext,
+      resource: Writable<ProductDiscount>,
+      { key }: ProductDiscountSetKeyAction
+    ) => {
+      resource.key = key
+    },
+    setDescription: (
+      context: RepositoryContext,
+      resource: Writable<ProductDiscount>,
+      { description }: ProductDiscountSetDescriptionAction
+    ) => {
+      if (description && Object.keys(description).length > 0) {
+        resource.description = description
+      } else {
+        resource.description = undefined
+      }
+    },
+    changeName: (
+      context: RepositoryContext,
+      resource: Writable<ProductDiscount>,
+      { name }: ProductDiscountChangeNameAction
+    ) => {
+      resource.name = name
+    },
+    changeValue: (
+      context: RepositoryContext,
+      resource: Writable<ProductDiscount>,
+      { value }: ProductDiscountChangeValueAction
+    ) => {
+      resource.value = this.transformValueDraft(value)
+    },
+    changePredicate: (
+      context: RepositoryContext,
+      resource: Writable<ProductDiscount>,
+      { predicate }: ProductDiscountChangePredicateAction
+    ) => {
+      resource.predicate = predicate
+    },
+    changeSortOrder: (
+      context: RepositoryContext,
+      resource: Writable<ProductDiscount>,
+      { sortOrder }: ProductDiscountChangeSortOrderAction
+    ) => {
+      resource.sortOrder = sortOrder
+    },
+    changeIsActive: (
+      context: RepositoryContext,
+      resource: Writable<ProductDiscount>,
+      { isActive }: ProductDiscountChangeIsActiveAction
+    ) => {
+      resource.isActive = isActive
+    },
+    setValidFrom: (
+      context: RepositoryContext,
+      resource: Writable<ProductDiscount>,
+      { validFrom }: ProductDiscountSetValidFromAction
+    ) => {
+      resource.validFrom = validFrom
+    },
+    setValidUntil: (
+      context: RepositoryContext,
+      resource: Writable<ProductDiscount>,
+      { validUntil }: ProductDiscountSetValidUntilAction
+    ) => {
+      resource.validUntil = validUntil
+    },
+    setValidFromAndUntil: (
+      context: RepositoryContext,
+      resource: Writable<ProductDiscount>,
+      { validFrom, validUntil }: ProductDiscountSetValidFromAndUntilAction
+    ) => {
+      resource.validFrom = validFrom
+      resource.validUntil = validUntil
+    },
+  }
+}

package/src/repositories/product-projection.ts

@@ -1,81 +1,51 @@
 import { ParsedQs } from 'qs'
+import { ProductDraft, ProductProjection } from '@commercetools/platform-sdk'
 import {
-  ProductDraft,
-  ProductProjection,
-  ProductVariant,
-  ProductVariantDraft,
-} from '@commercetools/platform-sdk'
-import { getBaseResourceProperties } from '../helpers'
-import { AbstractResourceRepository, RepositoryContext } from './abstract'
+  AbstractResourceRepository,
+  QueryParams,
+  RepositoryContext,
+} from './abstract'
 import { RepositoryTypes } from '../types'
-import { parseFilterExpression } from '../lib/filterParser'
+import { AbstractStorage } from '../storage'
+import { ProductProjectionSearch } from '../product-projection-search'
+import { QueryParamsAsArray } from '../helpers'
 
 export class ProductProjectionRepository extends AbstractResourceRepository {
+  protected _searchService: ProductProjectionSearch
+
+  constructor(storage: AbstractStorage) {
+    super(storage)
+    this._searchService = new ProductProjectionSearch(storage)
+  }
+
   getTypeId(): RepositoryTypes {
     return 'product-projection'
   }
 
   create(context: RepositoryContext, 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(context, resource)
+    throw new Error('No valid action')
+  }
 
-    return resource
+  query(context: RepositoryContext, params: QueryParams = {}) {
+    return this._storage.query(context.projectKey, 'product', {
+      expand: params.expand,
+      where: params.where,
+      offset: params.offset,
+      limit: params.limit,
+    })
   }
 
   search(context: RepositoryContext, query: ParsedQs) {
-    const expand = query.expand
-      ? (query.expand as string | string[])
-      : undefined
-    const filter = (query['filter.query'] ?? query.filter) as any
-    const wherePredicate = filter ? parseFilterExpression(filter) : undefined
-
-    const results = this._storage.query(context.projectKey, this.getTypeId(), {
-      where: wherePredicate,
+    const results = this._searchService.search(context.projectKey, {
+      filter: QueryParamsAsArray(query.filter),
+      'filter.query': QueryParamsAsArray(query['filter.query']),
       offset: query.offset ? Number(query.offset) : undefined,
       limit: query.limit ? Number(query.limit) : undefined,
-      expand,
-    }) //TODO: this is a partial implementation, but I don't really have the time to implement an actual search API right now
+      expand: QueryParamsAsArray(query.expand),
+    })
 
     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

@@ -4,9 +4,13 @@ import {
   AttributeDefinitionDraft,
   AttributeType,
   ProductType,
+  ProductTypeAddAttributeDefinitionAction,
+  ProductTypeChangeAttributeOrderAction,
   ProductTypeChangeLabelAction,
   ProductTypeChangeLocalizedEnumValueLabelAction,
   ProductTypeDraft,
+  ProductTypeRemoveAttributeDefinitionAction,
+  ProductTypeRemoveEnumValuesAction,
   ProductTypeUpdateAction,
   ReferenceTypeId,
 } from '@commercetools/platform-sdk'
@@ -36,12 +40,18 @@ export class ProductTypeRepository extends AbstractResourceRepository {
   attributeDefinitionFromAttributeDefinitionDraft = (
     _context: RepositoryContext,
     draft: AttributeDefinitionDraft
-  ): AttributeDefinition => ({
-    ...draft,
-    attributeConstraint: draft.attributeConstraint ?? 'None',
-    inputHint: draft.inputHint ?? 'SingleLine',
-    isSearchable: draft.isSearchable ?? true,
-  })
+  ): 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(), {
@@ -109,5 +119,77 @@ export class ProductTypeRepository extends AbstractResourceRepository {
         }
       })
     },
+    addAttributeDefinition: (
+      context: RepositoryContext,
+      resource: Writable<ProductType>,
+      { attribute }: ProductTypeAddAttributeDefinitionAction
+    ) => {
+      resource.attributes?.push(
+        this.attributeDefinitionFromAttributeDefinitionDraft(context, attribute)
+      )
+    },
+    changeAttributeOrder: (
+      context: RepositoryContext,
+      resource: Writable<ProductType>,
+      { attributes }: ProductTypeChangeAttributeOrderAction
+    ) => {
+      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)
+        if (attr === undefined) {
+          throw new Error('New attr')
+        }
+        result.push(attr)
+
+        // Remove from current items
+        current = current?.filter(f => {
+          return f.name !== iAttr.name
+        })
+      })
+
+      resource.attributes = result
+      // Add attrs which were not specified in the order as last items. Not
+      // sure if this follows commercetools
+      if (current) {
+        resource.attributes.push(...current)
+      }
+    },
+    removeAttributeDefinition: (
+      context: RepositoryContext,
+      resource: Writable<ProductType>,
+      { name }: ProductTypeRemoveAttributeDefinitionAction
+    ) => {
+      resource.attributes = resource.attributes?.filter(f => {
+        return f.name !== name
+      })
+    },
+    removeEnumValues: (
+      context: RepositoryContext,
+      resource: Writable<ProductType>,
+      { attributeName, keys }: ProductTypeRemoveEnumValuesAction
+    ) => {
+      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)
+            })
+          }
+
+          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)
+                }
+              )
+            }
+          }
+        }
+      })
+    },
   }
 }

package/src/repositories/product.ts

@@ -1,17 +1,22 @@
 import {
   Price,
+  PriceDraft,
   Product,
   ProductData,
   ProductDraft,
   ProductPublishAction,
   ProductSetAttributeAction,
+  ProductType,
+  ProductTypeReference,
   ProductVariant,
   ProductVariantDraft,
   ReferenceTypeId,
 } from '@commercetools/platform-sdk'
+import { v4 as uuidv4 } from 'uuid'
 import { getBaseResourceProperties } from '../helpers'
 import { AbstractResourceRepository, RepositoryContext } from './abstract'
 import { Writable } from '../types'
+import { getReferenceFromResourceIdentifier } from './helpers'
 
 export class ProductRepository extends AbstractResourceRepository {
   getTypeId(): ReferenceTypeId {
@@ -19,17 +24,37 @@ export class ProductRepository extends AbstractResourceRepository {
   }
 
   create(context: RepositoryContext, draft: ProductDraft): Product {
-    const productData = {
+    if (!draft.masterVariant) {
+      throw new Error('Missing master variant')
+    }
+
+    let productType: ProductTypeReference | undefined = undefined
+    try {
+      productType = getReferenceFromResourceIdentifier<ProductTypeReference>(
+        draft.productType,
+        context.projectKey,
+        this._storage
+      )
+    } catch (err) {
+      // For now accept missing product types (but warn)
+      console.warn(
+        `Error resolving product-type '${draft.productType.id}'. This will be throw an error in later releases.`
+      )
+      productType = {
+        typeId: 'product-type',
+        id: draft.productType.id || '',
+      }
+    }
+
+    const productData: ProductData = {
       name: draft.name,
       slug: draft.slug,
       categories: [],
-      masterVariant:
-        draft.masterVariant && variantFromDraft(0, draft.masterVariant!),
+      masterVariant: variantFromDraft(1, draft.masterVariant),
       variants:
-        draft.variants &&
-        draft.variants.map((variant, index) => {
-          return variantFromDraft(index + 1, variant)
-        }),
+        draft.variants?.map((variant, index) => {
+          return variantFromDraft(index + 2, variant)
+        }) ?? [],
 
       // @ts-ignore
       searchKeywords: draft.searchKeywords,
@@ -37,6 +62,7 @@ export class ProductRepository extends AbstractResourceRepository {
 
     const resource: Product = {
       ...getBaseResourceProperties(),
+      productType: productType,
       masterData: {
         // @ts-ignore
         current: draft.publish ? productData : undefined,
@@ -207,7 +233,21 @@ const variantFromDraft = (
   return {
     id: variantId,
     sku: variant?.sku,
-    attributes: variant?.attributes,
-    prices: variant?.prices as Price[],
+    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',
+    },
   }
 }

package/src/repositories/shipping-method.ts

@@ -12,6 +12,8 @@ import {
   ShippingMethodChangeNameAction,
   ShippingMethodDraft,
   ShippingMethodRemoveZoneAction,
+  ShippingMethodSetCustomFieldAction,
+  ShippingMethodSetCustomTypeAction,
   ShippingMethodSetDescriptionAction,
   ShippingMethodSetKeyAction,
   ShippingMethodSetLocalizedDescriptionAction,
@@ -196,5 +198,34 @@ export class ShippingMethodRepository extends AbstractResourceRepository {
     ) => {
       resource.name = name
     },
+    setCustomType: (
+      context: RepositoryContext,
+      resource: Writable<ShippingMethod>,
+      { type, fields }: ShippingMethodSetCustomTypeAction
+    ) => {
+      if (type) {
+        resource.custom = createCustomFields(
+          { type, fields },
+          context.projectKey,
+          this._storage
+        )
+      } else {
+        resource.custom = undefined
+      }
+    },
+    setCustomField: (
+      context: RepositoryContext,
+      resource: Writable<ShippingMethod>,
+      { name, value }: ShippingMethodSetCustomFieldAction
+    ) => {
+      if (!resource.custom) {
+        return
+      }
+      if (value === null) {
+        delete resource.custom.fields[name]
+      } else {
+        resource.custom.fields[name] = value
+      }
+    },
   }
 }