@labdigital/commercetools-mock 0.9.0 → 0.10.0

package/src/product-projection-search.ts

@@ -5,14 +5,11 @@ import {
   ProductProjection,
   QueryParam,
   FacetResults,
-  FacetTerm,
   TermFacetResult,
   RangeFacetResult,
   FilteredFacetResult,
 } from '@commercetools/platform-sdk'
-import { ByProjectKeyProductProjectionsSearchRequestBuilder } from '@commercetools/platform-sdk/dist/declarations/src/generated/client/search/by-project-key-product-projections-search-request-builder'
 import { nestedLookup } from './helpers'
-import { ProductService } from './services/product'
 import { Writable } from './types'
 import { CommercetoolsError } from './exceptions'
 import {
@@ -60,13 +57,18 @@ export class ProductProjectionSearch {
     projectKey: string,
     params: ProductProjectionSearchParams
   ): ProductProjectionPagedSearchResponse {
-    // Get a copy of all the products in the storage engine. We need a copy
-    // since we will be modifying the data.
     let resources = this._storage
       .all(projectKey, 'product')
-      .map(r => JSON.parse(JSON.stringify(r)))
+      .map((r) => this.transform(r, params.staged ?? false))
+      .filter((p): p is ProductProjection => p !== null)
+      .filter((p) => {
+        if (!params.staged ?? false) {
+          return p.published
+        }
+        return true
+      })
 
-    let markMatchingVariant = params.markMatchingVariants ?? false
+    const markMatchingVariant = params.markMatchingVariants ?? false
 
     // Apply the priceSelector
     applyPriceSelector(resources, {
@@ -79,15 +81,14 @@ export class ProductProjectionSearch {
     // Apply filters pre facetting
     if (params.filter) {
       try {
-        const filters = params.filter.map(f =>
-          parseFilterExpression(f, params.staged ?? false)
-        )
+        const filters = params.filter.map(parseFilterExpression)
 
         // Filters can modify the output. So clone the resources first.
-        resources = resources.filter(resource =>
-          filters.every(f => f(resource, markMatchingVariant))
+        resources = resources.filter((resource) =>
+          filters.every((f) => f(resource, markMatchingVariant))
         )
       } catch (err) {
+        console.error(err)
         throw new CommercetoolsError<InvalidInputError>(
           {
             code: 'InvalidInput',
@@ -104,12 +105,9 @@ export class ProductProjectionSearch {
     // Apply filters post facetting
     if (params['filter.query']) {
       try {
-        const filters = params['filter.query'].map(f =>
-          parseFilterExpression(f, params.staged ?? false)
-        )
-        
-        resources = resources.filter(resource =>
-          filters.every(f => f(resource, markMatchingVariant))
+        const filters = params['filter.query'].map(parseFilterExpression)
+        resources = resources.filter((resource) =>
+          filters.every((f) => f(resource, markMatchingVariant))
         )
       } catch (err) {
         throw new CommercetoolsError<InvalidInputError>(
@@ -122,33 +120,35 @@ export class ProductProjectionSearch {
       }
     }
 
-    // Get the total before slicing the array
-    const totalResources = resources.length
-
-    // Apply offset, limit
-    const offset = params.offset || 0
-    const limit = params.limit || 20
-    resources = resources.slice(offset, offset + limit)
-
     // Expand the resources
     if (params.expand !== undefined) {
-      resources = resources.map(resource => {
-        return this._storage.expand(projectKey, resource, params.expand)
-      })
+      resources = resources.map((resource) =>
+        this._storage.expand(projectKey, resource, params.expand)
+      )
     }
 
+    // Create a slice for the pagination. If we were working with large datasets
+    // then we should have done this before transforming. But that isn't the
+    // goal of this library. So lets keep it simple.
+    const totalResults = resources.length
+    const offset = params.offset || 0
+    const limit = params.limit || 20
+    const results = resources.slice(offset, offset + limit)
+
     return {
-      count: totalResources,
-      total: resources.length,
+      count: totalResults,
+      total: results.length,
       offset: offset,
       limit: limit,
-      results: resources.map(this.transform),
+      results: results,
       facets: facets,
     }
   }
 
-  transform(product: Product): ProductProjection {
-    const obj = product.masterData.current
+  transform(product: Product, staged: boolean): ProductProjection | null {
+    const obj = !staged ? product.masterData.current : product.masterData.staged
+    if (!obj) return null
+
     return {
       id: product.id,
       createdAt: product.createdAt,
@@ -163,12 +163,14 @@ export class ProductProjectionSearch {
       masterVariant: obj.masterVariant,
       variants: obj.variants,
       productType: product.productType,
+      hasStagedChanges: product.masterData.hasStagedChanges,
+      published: product.masterData.published,
     }
   }
 
   getFacets(
     params: ProductProjectionSearchParams,
-    products: Product[]
+    products: ProductProjection[]
   ): FacetResults {
     if (!params.facet) return {}
     const staged = false
@@ -179,7 +181,7 @@ export class ProductProjectionSearch {
 
       // Term Facet
       if (expression.type === 'TermExpression') {
-        result[facet] = this.termFacet(expression.source, products, staged)
+        result[facet] = this.termFacet(expression.source, products)
       }
 
       // Range Facet
@@ -187,8 +189,7 @@ export class ProductProjectionSearch {
         result[expression.source] = this.rangeFacet(
           expression.source,
           expression.children,
-          products,
-          staged
+          products
         )
       }
 
@@ -197,8 +198,7 @@ export class ProductProjectionSearch {
         result[expression.source] = this.filterFacet(
           expression.source,
           expression.children,
-          products,
-          staged
+          products
         )
       }
     }
@@ -211,11 +211,7 @@ export class ProductProjectionSearch {
    *  - counting products
    *  - correct dataType
    */
-  termFacet(
-    facet: string,
-    products: Product[],
-    staged: boolean
-  ): TermFacetResult {
+  termFacet(facet: string, products: ProductProjection[]): TermFacetResult {
     const result: Writable<TermFacetResult> = {
       type: 'terms',
       dataType: 'text',
@@ -227,9 +223,9 @@ export class ProductProjectionSearch {
     const terms: Record<any, number> = {}
 
     if (facet.startsWith('variants.')) {
-      products.forEach(p => {
-        const variants = getVariants(p, staged)
-        variants.forEach(v => {
+      products.forEach((p) => {
+        const variants = getVariants(p)
+        variants.forEach((v) => {
           result.total++
 
           let value = resolveVariantValue(v, facet)
@@ -244,7 +240,7 @@ export class ProductProjectionSearch {
         })
       })
     } else {
-      products.forEach(p => {
+      products.forEach((p) => {
         const value = nestedLookup(p, facet)
         result.total++
         if (value === undefined) {
@@ -266,15 +262,14 @@ export class ProductProjectionSearch {
   filterFacet(
     source: string,
     filters: FilterExpression[] | undefined,
-    products: Product[],
-    staged: boolean
+    products: ProductProjection[]
   ): FilteredFacetResult {
     let count = 0
     if (source.startsWith('variants.')) {
       for (const p of products) {
-        for (const v of getVariants(p, staged)) {
+        for (const v of getVariants(p)) {
           const val = resolveVariantValue(v, source)
-          if (filters?.some(f => f.match(val))) {
+          if (filters?.some((f) => f.match(val))) {
             count++
           }
         }
@@ -292,15 +287,14 @@ export class ProductProjectionSearch {
   rangeFacet(
     source: string,
     ranges: RangeExpression[] | undefined,
-    products: Product[],
-    staged: boolean
+    products: ProductProjection[]
   ): RangeFacetResult {
     const counts =
-      ranges?.map(range => {
+      ranges?.map((range) => {
         if (source.startsWith('variants.')) {
           const values = []
           for (const p of products) {
-            for (const v of getVariants(p, staged)) {
+            for (const v of getVariants(p)) {
               const val = resolveVariantValue(v, source)
               if (val === undefined) {
                 continue

package/src/repositories/abstract.ts

@@ -1,15 +1,16 @@
-import { RepositoryTypes } from './../types'
+import { RepositoryTypes, Resource, Writable } from './../types'
 import deepEqual from 'deep-equal'
 
 import {
   BaseResource,
-  InvalidOperationError,
   Project,
+  ResourceNotFoundError,
   UpdateAction,
 } from '@commercetools/platform-sdk'
 import { AbstractStorage } from '../storage'
 import { checkConcurrentModification } from './errors'
 import { CommercetoolsError } from '../exceptions'
+import { cloneObject } from '../helpers'
 
 export type QueryParams = {
   expand?: string[]
@@ -39,44 +40,68 @@ export abstract class AbstractRepository {
     this._storage = storage
   }
 
-  abstract save(
+  abstract saveNew({ projectKey }: RepositoryContext, resource: Resource): void
+
+  abstract saveUpdate(
     { projectKey }: RepositoryContext,
-    resource: BaseResource | Project
+    version: number,
+    resource: Resource
   ): void
 
-  processUpdateActions(
+  processUpdateActions<T extends Resource>(
     context: RepositoryContext,
-    resource: BaseResource | Project,
+    resource: T,
+    version: number,
     actions: UpdateAction[]
-  ): BaseResource {
+  ): T {
     // Deep-copy
-    const modifiedResource = JSON.parse(JSON.stringify(resource))
+    const updatedResource = cloneObject(resource) as Writable<Resource>
+    const identifier = (resource as BaseResource).id
+      ? (resource as BaseResource).id
+      : (resource as Project).key
 
-    actions.forEach(action => {
+    actions.forEach((action) => {
       const updateFunc = this.actions[action.action]
 
       if (!updateFunc) {
         console.error(`No mock implemented for update action ${action.action}`)
-        return
+        throw new Error(
+          `No mock implemented for update action ${action.action}`
+        )
+      }
+
+      const beforeUpdate = cloneObject(resource)
+      updateFunc(context, updatedResource, action)
+
+      // Check if the object is updated. We need to increase the version of
+      // an object per action which does an actual modification.
+      // This isn't the most performant method to do this (the update action
+      // should return a flag) but for now the easiest.
+      if (!deepEqual(beforeUpdate, updatedResource)) {
+        // We only check the version when there is an actual modification to
+        // be stored.
+        checkConcurrentModification(resource.version, version, identifier)
+
+        updatedResource.version += 1
       }
-      updateFunc(context, modifiedResource, action)
     })
 
-    if (!deepEqual(modifiedResource, resource)) {
-      this.save(context, modifiedResource)
+    // If all actions succeeded we write the new version
+    // to the storage.
+    if (resource.version != updatedResource.version) {
+      this.saveUpdate(context, version, updatedResource)
     }
 
-    const result = this.postProcessResource(modifiedResource)
+    const result = this.postProcessResource(updatedResource)
     if (!result) {
-      throw new Error("invalid post process action")
+      throw new Error('invalid post process action')
     }
-    return result
+    return result as T
   }
 
-  postProcessResource(resource: BaseResource | null): BaseResource | null {
+  postProcessResource<T extends Resource>(resource: T): T {
     return resource
   }
-
 }
 
 export abstract class AbstractResourceRepository extends AbstractRepository {
@@ -85,7 +110,6 @@ export abstract class AbstractResourceRepository extends AbstractRepository {
 
   constructor(storage: AbstractStorage) {
     super(storage)
-    this._storage.assertStorage(this.getTypeId())
   }
 
   query(context: RepositoryContext, params: QueryParams = {}) {
@@ -98,7 +122,6 @@ export abstract class AbstractResourceRepository extends AbstractRepository {
 
     // @ts-ignore
     result.results = result.results.map(this.postProcessResource)
-
     return result
   }
 
@@ -107,8 +130,13 @@ export abstract class AbstractResourceRepository extends AbstractRepository {
     id: string,
     params: GetParams = {}
   ): BaseResource | null {
-    const resource = this._storage.get(context.projectKey, this.getTypeId(), id, params)
-    return this.postProcessResource(resource)
+    const resource = this._storage.get(
+      context.projectKey,
+      this.getTypeId(),
+      id,
+      params
+    )
+    return resource ? this.postProcessResource(resource) : null
   }
 
   getByKey(
@@ -122,7 +150,7 @@ export abstract class AbstractResourceRepository extends AbstractRepository {
       key,
       params
     )
-    return this.postProcessResource(resource)
+    return resource ? this.postProcessResource(resource) : null
   }
 
   delete(
@@ -136,28 +164,44 @@ export abstract class AbstractResourceRepository extends AbstractRepository {
       id,
       params
     )
-    return this.postProcessResource(resource)
+    return resource ? this.postProcessResource(resource) : null
   }
 
-  save(context: RepositoryContext, resource: BaseResource) {
-    const current = this.get(context, resource.id)
-
-    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<BaseResource>) {
+    resource.version = 1
+    this._storage.add(context.projectKey, this.getTypeId(), resource as any)
+  }
+
+  saveUpdate(
+    context: RepositoryContext,
+    version: number,
+    resource: Writable<BaseResource>
+  ) {
+    // Check if the resource still exists.
+    const current = this._storage.get(
+      context.projectKey,
+      this.getTypeId(),
+      resource.id
+    )
+    if (!current) {
+      throw new CommercetoolsError<ResourceNotFoundError>(
+        {
+          code: 'ResourceNotFound',
+          message: 'Resource not found while updating',
+        },
+        400
+      )
     }
 
-    // @ts-ignore
-    resource.version += 1
+    checkConcurrentModification(current.version, version, resource.id)
+
+    if (current.version === resource.version) {
+      throw new Error('Internal error: no changes to save')
+    }
+    resource.lastModifiedAt = new Date().toISOString()
+
     this._storage.add(context.projectKey, this.getTypeId(), resource as any)
+
+    return resource
   }
 }

package/src/repositories/cart-discount.ts

@@ -43,7 +43,7 @@ export class CartDiscountRepository extends AbstractResourceRepository {
       validUntil: draft.validUntil,
       value: this.transformValueDraft(draft.value),
     }
-    this.save(context, resource)
+    this.saveNew(context, resource)
     return resource
   }
 

package/src/repositories/cart.ts

@@ -34,7 +34,7 @@ export class CartRepository extends AbstractResourceRepository {
 
   create(context: RepositoryContext, draft: CartDraft): Cart {
     const lineItems =
-      draft.lineItems?.map(draftLineItem =>
+      draft.lineItems?.map((draftLineItem) =>
         this.draftLineItemtoLineItem(
           context.projectKey,
           draftLineItem,
@@ -43,7 +43,7 @@ export class CartRepository extends AbstractResourceRepository {
         )
       ) ?? []
 
-    const resource: Cart = {
+    const resource: Writable<Cart> = {
       ...getBaseResourceProperties(),
       cartState: 'Active',
       lineItems,
@@ -67,11 +67,9 @@ export class CartRepository extends AbstractResourceRepository {
         this._storage
       ),
     }
-
-    // @ts-ignore
     resource.totalPrice.centAmount = calculateCartTotalPrice(resource)
 
-    this.save(context, resource)
+    this.saveNew(context, resource)
     return resource
   }
 
@@ -94,7 +92,6 @@ export class CartRepository extends AbstractResourceRepository {
       { productId, variantId, sku, quantity = 1 }: CartAddLineItemAction
     ) => {
       let product: Product | null = null
-      let variant: ProductVariant | undefined
 
       if (productId && variantId) {
         // Fetch product and variant by ID
@@ -128,10 +125,10 @@ export class CartRepository extends AbstractResourceRepository {
       }
 
       // Find matching variant
-      variant = [
+      const variant: ProductVariant | undefined = [
         product.masterData.current.masterVariant,
         ...product.masterData.current.variants,
-      ].find(x => {
+      ].find((x) => {
         if (sku) return x.sku === sku
         if (variantId) return x.id === variantId
         return false
@@ -148,11 +145,11 @@ export class CartRepository extends AbstractResourceRepository {
       }
 
       const alreadyAdded = resource.lineItems.some(
-        x => x.productId === product?.id && x.variant.id === variant?.id
+        (x) => x.productId === product?.id && x.variant.id === variant?.id
       )
       if (alreadyAdded) {
         // increase quantity and update total price
-        resource.lineItems.map(x => {
+        resource.lineItems.map((x) => {
           if (x.productId === product?.id && x.variant.id === variant?.id) {
             x.quantity += quantity
             x.totalPrice.centAmount = calculateLineItemTotalPrice(x)
@@ -209,7 +206,7 @@ export class CartRepository extends AbstractResourceRepository {
       resource: Writable<Cart>,
       { lineItemId, quantity }: CartRemoveLineItemAction
     ) => {
-      const lineItem = resource.lineItems.find(x => x.id === lineItemId)
+      const lineItem = resource.lineItems.find((x) => x.id === lineItemId)
       if (!lineItem) {
         // Check if product is found
         throw new CommercetoolsError<GeneralError>({
@@ -221,10 +218,12 @@ export class CartRepository extends AbstractResourceRepository {
       const shouldDelete = !quantity || quantity >= lineItem.quantity
       if (shouldDelete) {
         // delete line item
-        resource.lineItems = resource.lineItems.filter(x => x.id !== lineItemId)
+        resource.lineItems = resource.lineItems.filter(
+          (x) => x.id !== lineItemId
+        )
       } else {
         // decrease quantity and update total price
-        resource.lineItems.map(x => {
+        resource.lineItems.map((x) => {
           if (x.id === lineItemId && quantity) {
             x.quantity -= quantity
             x.totalPrice.centAmount = calculateLineItemTotalPrice(x)
@@ -248,21 +247,28 @@ export class CartRepository extends AbstractResourceRepository {
       resource: Writable<Cart>,
       { shippingMethod }: CartSetShippingMethodAction
     ) => {
-      const resolvedType = this._storage.getByResourceIdentifier(
-        context.projectKey,
-        //@ts-ignore
-        shippingMethod
-      )
+      if (shippingMethod) {
+        const method = this._storage.getByResourceIdentifier<'shipping-method'>(
+          context.projectKey,
+          shippingMethod
+        )
 
-      if (!resolvedType) {
-        throw new Error(`Type ${shippingMethod} not found`)
-      }
-      //@ts-ignore
-      resource.shippingInfo = {
-        shippingMethod: {
-          typeId: 'shipping-method',
-          id: resolvedType.id,
-        },
+        if (!method) {
+          throw new Error(`Type ${shippingMethod} not found`)
+        }
+
+        // Based on the address we should select a shipping zone and
+        // use that to define the price.
+        // @ts-ignore
+        resource.shippingInfo = {
+          shippingMethod: {
+            typeId: 'shipping-method',
+            id: method.id,
+          },
+          shippingMethodName: method.name,
+        }
+      } else {
+        resource.shippingInfo = undefined
       }
     },
     setCountry: (
@@ -338,7 +344,6 @@ export class CartRepository extends AbstractResourceRepository {
     const { productId, quantity, variantId, sku } = draftLineItem
 
     let product: Product | null = null
-    let variant: ProductVariant | undefined
 
     if (productId && variantId) {
       // Fetch product and variant by ID
@@ -367,10 +372,10 @@ export class CartRepository extends AbstractResourceRepository {
     }
 
     // Find matching variant
-    variant = [
+    const variant = [
       product.masterData.current.masterVariant,
       ...product.masterData.current.variants,
-    ].find(x => {
+    ].find((x) => {
       if (sku) return x.sku === sku
       if (variantId) return x.id === variantId
       return false
@@ -432,7 +437,7 @@ const selectPrice = ({
   // Quick-and-dirty way of selecting price based on the given currency and country.
   // Can be improved later to give more priority to exact matches over
   // 'all country' matches, and include customer groups in the mix as well
-  return prices.find(price => {
+  return prices.find((price) => {
     const countryMatch = !price.country || price.country === country
     const currencyMatch = price.value.currencyCode === currency
     return countryMatch && currencyMatch

package/src/repositories/category.ts

@@ -38,28 +38,26 @@ export class CategoryRepository extends AbstractResourceRepository {
         : undefined,
       ancestors: [], // TODO
       assets:
-        draft.assets?.map(d => {
-          return {
-            id: uuidv4(),
-            name: d.name,
-            description: d.description,
-            sources: d.sources,
-            tags: d.tags,
-            key: d.key,
-            custom: createCustomFields(
-              draft.custom,
-              context.projectKey,
-              this._storage
-            ),
-          }
-        }) || [],
+        draft.assets?.map((d) => ({
+          id: uuidv4(),
+          name: d.name,
+          description: d.description,
+          sources: d.sources,
+          tags: d.tags,
+          key: d.key,
+          custom: createCustomFields(
+            draft.custom,
+            context.projectKey,
+            this._storage
+          ),
+        })) || [],
       custom: createCustomFields(
         draft.custom,
         context.projectKey,
         this._storage
       ),
     }
-    this.save(context, resource)
+    this.saveNew(context, resource)
     return resource
   }
 
@@ -69,7 +67,7 @@ export class CategoryRepository extends AbstractResourceRepository {
       resource: Writable<Category>,
       { assetId, assetKey, name }: CategoryChangeAssetNameAction
     ) => {
-      resource.assets?.forEach(asset => {
+      resource.assets?.forEach((asset) => {
         if (assetId && assetId === asset.id) {
           asset.name = name
         }
@@ -97,7 +95,7 @@ export class CategoryRepository extends AbstractResourceRepository {
       resource: Writable<Category>,
       { assetId, assetKey, description }: CategorySetAssetDescriptionAction
     ) => {
-      resource.assets?.forEach(asset => {
+      resource.assets?.forEach((asset) => {
         if (assetId && assetId === asset.id) {
           asset.description = description
         }
@@ -111,7 +109,7 @@ export class CategoryRepository extends AbstractResourceRepository {
       resource: Writable<Category>,
       { assetId, assetKey, sources }: CategorySetAssetSourcesAction
     ) => {
-      resource.assets?.forEach(asset => {
+      resource.assets?.forEach((asset) => {
         if (assetId && assetId === asset.id) {
           asset.sources = sources
         }