@labdigital/commercetools-mock 0.6.5 → 0.8.0

package/src/repositories/channel.ts

@@ -1,10 +1,20 @@
 import {
   Channel,
+  ChannelChangeDescriptionAction,
+  ChannelChangeKeyAction,
+  ChannelChangeNameAction,
   ChannelDraft,
+  ChannelSetAddressAction,
+  ChannelSetCustomFieldAction,
+  ChannelSetCustomTypeAction,
+  ChannelSetGeoLocationAction,
+  ChannelUpdateAction,
   ReferenceTypeId,
 } from '@commercetools/platform-sdk'
+import { Writable } from 'types'
 import { getBaseResourceProperties } from '../helpers'
 import { AbstractResourceRepository, RepositoryContext } from './abstract'
+import { createAddress, createCustomFields } from './helpers'
 
 export class ChannelRepository extends AbstractResourceRepository {
   getTypeId(): ReferenceTypeId {
@@ -15,9 +25,103 @@ export class ChannelRepository extends AbstractResourceRepository {
     const resource: Channel = {
       ...getBaseResourceProperties(),
       key: draft.key,
+      name: draft.name,
+      description: draft.description,
       roles: draft.roles || [],
+      geoLocation: draft.geoLocation,
+      address: createAddress(draft.address, context.projectKey, this._storage),
+      custom: createCustomFields(
+        draft.custom,
+        context.projectKey,
+        this._storage
+      ),
     }
     this.save(context, resource)
     return resource
   }
+
+  actions: Partial<
+    Record<
+      ChannelUpdateAction['action'],
+      (
+        context: RepositoryContext,
+        resource: Writable<Channel>,
+        action: any
+      ) => void
+    >
+  > = {
+    changeKey: (
+      context: RepositoryContext,
+      resource: Writable<Channel>,
+      { key }: ChannelChangeKeyAction
+    ) => {
+      resource.key = key
+    },
+
+    changeName: (
+      context: RepositoryContext,
+      resource: Writable<Channel>,
+      { name }: ChannelChangeNameAction
+    ) => {
+      resource.name = name
+    },
+
+    changeDescription: (
+      context: RepositoryContext,
+      resource: Writable<Channel>,
+      { description }: ChannelChangeDescriptionAction
+    ) => {
+      resource.description = description
+    },
+
+    setAddress: (
+      context: RepositoryContext,
+      resource: Writable<Channel>,
+      { address }: ChannelSetAddressAction
+    ) => {
+      resource.address = createAddress(
+        address,
+        context.projectKey,
+        this._storage
+      )
+    },
+
+    setGeoLocation: (
+      context: RepositoryContext,
+      resource: Writable<Channel>,
+      { geoLocation }: ChannelSetGeoLocationAction
+    ) => {
+      resource.geoLocation = geoLocation
+    },
+
+    setCustomType: (
+      context: RepositoryContext,
+      resource: Writable<Channel>,
+      { type, fields }: ChannelSetCustomTypeAction
+    ) => {
+      if (type) {
+        resource.custom = createCustomFields(
+          { type, fields },
+          context.projectKey,
+          this._storage
+        )
+      } else {
+        resource.custom = undefined
+      }
+    },
+    setCustomField: (
+      context: RepositoryContext,
+      resource: Writable<Channel>,
+      { name, value }: ChannelSetCustomFieldAction
+    ) => {
+      if (!resource.custom) {
+        return
+      }
+      if (value === null) {
+        delete resource.custom.fields[name]
+      } else {
+        resource.custom.fields[name] = value
+      }
+    },
+  }
 }

package/src/repositories/customer-group.ts

@@ -2,12 +2,15 @@ import {
   CustomerGroup,
   CustomerGroupChangeNameAction,
   CustomerGroupDraft,
+  CustomerGroupSetCustomFieldAction,
+  CustomerGroupSetCustomTypeAction,
   CustomerGroupSetKeyAction,
   ReferenceTypeId,
 } from '@commercetools/platform-sdk'
 import { Writable } from 'types'
 import { getBaseResourceProperties } from '../helpers'
 import { AbstractResourceRepository, RepositoryContext } from './abstract'
+import { createCustomFields } from './helpers'
 
 export class CustomerGroupRepository extends AbstractResourceRepository {
   getTypeId(): ReferenceTypeId {
@@ -18,6 +21,11 @@ export class CustomerGroupRepository extends AbstractResourceRepository {
       ...getBaseResourceProperties(),
       key: draft.key,
       name: draft.groupName,
+      custom: createCustomFields(
+        draft.custom,
+        context.projectKey,
+        this._storage
+      ),
     }
     this.save(context, resource)
     return resource
@@ -38,5 +46,34 @@ export class CustomerGroupRepository extends AbstractResourceRepository {
     ) => {
       resource.name = name
     },
+    setCustomType: (
+      context: RepositoryContext,
+      resource: Writable<CustomerGroup>,
+      { type, fields }: CustomerGroupSetCustomTypeAction
+    ) => {
+      if (type) {
+        resource.custom = createCustomFields(
+          { type, fields },
+          context.projectKey,
+          this._storage
+        )
+      } else {
+        resource.custom = undefined
+      }
+    },
+    setCustomField: (
+      context: RepositoryContext,
+      resource: Writable<CustomerGroup>,
+      { name, value }: CustomerGroupSetCustomFieldAction
+    ) => {
+      if (!resource.custom) {
+        return
+      }
+      if (value === null) {
+        delete resource.custom.fields[name]
+      } else {
+        resource.custom.fields[name] = value
+      }
+    },
   }
 }

package/src/repositories/discount-code.ts

@@ -5,6 +5,8 @@ import {
   DiscountCodeChangeIsActiveAction,
   DiscountCodeDraft,
   DiscountCodeSetCartPredicateAction,
+  DiscountCodeSetCustomFieldAction,
+  DiscountCodeSetCustomTypeAction,
   DiscountCodeSetDescriptionAction,
   DiscountCodeSetMaxApplicationsAction,
   DiscountCodeSetMaxApplicationsPerCustomerAction,
@@ -18,6 +20,7 @@ import {
 import { Writable } from 'types'
 import { getBaseResourceProperties } from '../helpers'
 import { AbstractResourceRepository, RepositoryContext } from './abstract'
+import { createCustomFields } from './helpers'
 
 export class DiscountCodeRepository extends AbstractResourceRepository {
   getTypeId(): ReferenceTypeId {
@@ -45,6 +48,11 @@ export class DiscountCodeRepository extends AbstractResourceRepository {
       validUntil: draft.validUntil,
       maxApplications: draft.maxApplications,
       maxApplicationsPerCustomer: draft.maxApplicationsPerCustomer,
+      custom: createCustomFields(
+        draft.custom,
+        context.projectKey,
+        this._storage
+      ),
     }
     this.save(context, resource)
     return resource
@@ -138,5 +146,34 @@ export class DiscountCodeRepository extends AbstractResourceRepository {
       resource.validFrom = validFrom
       resource.validUntil = validUntil
     },
+    setCustomType: (
+      context: RepositoryContext,
+      resource: Writable<DiscountCode>,
+      { type, fields }: DiscountCodeSetCustomTypeAction
+    ) => {
+      if (type) {
+        resource.custom = createCustomFields(
+          { type, fields },
+          context.projectKey,
+          this._storage
+        )
+      } else {
+        resource.custom = undefined
+      }
+    },
+    setCustomField: (
+      context: RepositoryContext,
+      resource: Writable<DiscountCode>,
+      { name, value }: DiscountCodeSetCustomFieldAction
+    ) => {
+      if (!resource.custom) {
+        return
+      }
+      if (value === null) {
+        delete resource.custom.fields[name]
+      } else {
+        resource.custom.fields[name] = value
+      }
+    },
   }
 }

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,52 @@
 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']),
+      facet: QueryParamsAsArray(query.facet),
       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,
-  }
-}