@labdigital/commercetools-mock 0.9.1 → 0.10.1

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,17 @@ 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) => {
+        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 +80,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 +104,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 +119,34 @@ 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 {
+    const obj = !staged ? product.masterData.current : product.masterData.staged
+
     return {
       id: product.id,
       createdAt: product.createdAt,
@@ -163,12 +161,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 +179,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 +187,7 @@ export class ProductProjectionSearch {
         result[expression.source] = this.rangeFacet(
           expression.source,
           expression.children,
-          products,
-          staged
+          products
         )
       }
 
@@ -197,8 +196,7 @@ export class ProductProjectionSearch {
         result[expression.source] = this.filterFacet(
           expression.source,
           expression.children,
-          products,
-          staged
+          products
         )
       }
     }
@@ -211,11 +209,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 +221,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 +238,7 @@ export class ProductProjectionSearch {
         })
       })
     } else {
-      products.forEach(p => {
+      products.forEach((p) => {
         const value = nestedLookup(p, facet)
         result.total++
         if (value === undefined) {
@@ -266,15 +260,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 +285,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/projectAPI.test.ts

@@ -0,0 +1,7 @@
+import { CommercetoolsMock } from './index'
+
+test('getRepository', async () => {
+  const ctMock = new CommercetoolsMock()
+  const repo = ctMock.project('my-project-key').getRepository('order')
+  repo.get({ projectKey: 'unittest' }, '1234')
+})

package/src/projectAPI.ts

@@ -1,34 +1,31 @@
-import { ReferenceTypeId } from '@commercetools/platform-sdk'
 import { GetParams } from 'repositories/abstract'
 import { getBaseResourceProperties } from './helpers'
 import { AbstractStorage } from './storage'
-import {
-  RepositoryMap,
-  RepositoryTypes,
-  ResourceMap,
-  Services,
-  ServiceTypes,
-} from './types'
+import { RepositoryMap } from './repositories'
+import { ResourceMap, ResourceType } from './types'
 
 export class ProjectAPI {
   private projectKey: string
   private _storage: AbstractStorage
-  private _services: Services
+  private _repositories: RepositoryMap
 
   constructor(
     projectKey: string,
-    services: Services,
+    repositories: RepositoryMap,
     storage: AbstractStorage
   ) {
     this.projectKey = projectKey
     this._storage = storage
-    this._services = services
+    this._repositories = repositories
   }
 
-  add(typeId: ReferenceTypeId, resource: ResourceMap[ReferenceTypeId]) {
-    const service = this._services[typeId]
-    if (service) {
-      this._storage.add(this.projectKey, typeId as ReferenceTypeId, {
+  add<T extends keyof RepositoryMap & keyof ResourceMap>(
+    typeId: T,
+    resource: ResourceMap[T]
+  ) {
+    const repository = this._repositories[typeId]
+    if (repository) {
+      this._storage.add(this.projectKey, typeId, {
         ...getBaseResourceProperties(),
         ...resource,
       })
@@ -37,7 +34,7 @@ export class ProjectAPI {
     }
   }
 
-  get<RT extends RepositoryTypes>(
+  get<RT extends ResourceType>(
     typeId: RT,
     id: string,
     params?: GetParams
@@ -51,12 +48,10 @@ export class ProjectAPI {
   }
 
   // TODO: Not sure if we want to expose this...
-  getRepository<RT extends keyof RepositoryMap>(
-    typeId: ServiceTypes
-  ): RepositoryMap[RT] {
-    const service = this._services[typeId]
-    if (service !== undefined) {
-      return service.repository as RepositoryMap[RT]
+  getRepository<RT extends keyof RepositoryMap>(typeId: RT): RepositoryMap[RT] {
+    const repository = this._repositories[typeId]
+    if (repository !== undefined) {
+      return repository as RepositoryMap[RT]
     }
     throw new Error('No such repository')
   }

package/src/repositories/abstract.ts

@@ -1,15 +1,15 @@
-import { RepositoryTypes } from './../types'
-import deepEqual from 'deep-equal'
-
 import {
   BaseResource,
-  InvalidOperationError,
   Project,
+  ResourceNotFoundError,
   UpdateAction,
 } from '@commercetools/platform-sdk'
+import deepEqual from 'deep-equal'
+import { CommercetoolsError } from '../exceptions'
+import { cloneObject } from '../helpers'
 import { AbstractStorage } from '../storage'
+import { ResourceMap, ResourceType, ShallowWritable } from './../types'
 import { checkConcurrentModification } from './errors'
-import { CommercetoolsError } from '../exceptions'
 
 export type QueryParams = {
   expand?: string[]
@@ -26,7 +26,8 @@ export type RepositoryContext = {
   projectKey: string
   storeKey?: string
 }
-export abstract class AbstractRepository {
+
+export abstract class AbstractRepository<R extends BaseResource | Project> {
   protected _storage: AbstractStorage
   protected actions: Partial<
     Record<
@@ -39,53 +40,80 @@ export abstract class AbstractRepository {
     this._storage = storage
   }
 
-  abstract save(
+  abstract saveNew({ projectKey }: RepositoryContext, resource: R): void
+
+  abstract saveUpdate(
     { projectKey }: RepositoryContext,
-    resource: BaseResource | Project
+    version: number,
+    resource: R
   ): void
 
   processUpdateActions(
     context: RepositoryContext,
-    resource: BaseResource | Project,
+    resource: R,
+    version: number,
     actions: UpdateAction[]
-  ): BaseResource {
+  ): R {
     // Deep-copy
-    const modifiedResource = JSON.parse(JSON.stringify(resource))
+    const updatedResource = cloneObject(resource) as ShallowWritable<R>
+    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
   }
 
-  postProcessResource(resource: BaseResource | null): BaseResource | null {
-    return resource
-  }
-
+  abstract postProcessResource(resource: any): any
 }
 
-export abstract class AbstractResourceRepository extends AbstractRepository {
-  abstract create(context: RepositoryContext, draft: any): BaseResource
-  abstract getTypeId(): RepositoryTypes
+export abstract class AbstractResourceRepository<
+  T extends ResourceType
+> extends AbstractRepository<ResourceMap[T]> {
+  abstract create(context: RepositoryContext, draft: any): ResourceMap[T]
+  abstract getTypeId(): T
 
   constructor(storage: AbstractStorage) {
     super(storage)
-    this._storage.assertStorage(this.getTypeId())
+  }
+
+  postProcessResource(resource: ResourceMap[T]): ResourceMap[T] {
+    return resource
   }
 
   query(context: RepositoryContext, params: QueryParams = {}) {
@@ -98,7 +126,6 @@ export abstract class AbstractResourceRepository extends AbstractRepository {
 
     // @ts-ignore
     result.results = result.results.map(this.postProcessResource)
-
     return result
   }
 
@@ -106,58 +133,82 @@ export abstract class AbstractResourceRepository extends AbstractRepository {
     context: RepositoryContext,
     id: string,
     params: GetParams = {}
-  ): BaseResource | null {
-    const resource = this._storage.get(context.projectKey, this.getTypeId(), id, params)
-    return this.postProcessResource(resource)
+  ): ResourceMap[T] | null {
+    const resource = this._storage.get(
+      context.projectKey,
+      this.getTypeId(),
+      id,
+      params
+    )
+    return resource ? this.postProcessResource(resource) : null
   }
 
   getByKey(
     context: RepositoryContext,
     key: string,
     params: GetParams = {}
-  ): BaseResource | null {
+  ): ResourceMap[T] | null {
     const resource = this._storage.getByKey(
       context.projectKey,
       this.getTypeId(),
       key,
       params
     )
-    return this.postProcessResource(resource)
+    return resource ? this.postProcessResource(resource) : null
   }
 
   delete(
     context: RepositoryContext,
     id: string,
     params: GetParams = {}
-  ): BaseResource | null {
+  ): ResourceMap[T] | null {
     const resource = this._storage.delete(
       context.projectKey,
       this.getTypeId(),
       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: ShallowWritable<ResourceMap[T]>
+  ) {
+    resource.version = 1
+    this._storage.add(context.projectKey, this.getTypeId(), resource as any)
+  }
+
+  saveUpdate(
+    context: RepositoryContext,
+    version: number,
+    resource: ShallowWritable<ResourceMap[T]>
+  ) {
+    // 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

@@ -14,16 +14,15 @@ import {
   CartDiscountValueFixed,
   CartDiscountValueGiftLineItem,
   CartDiscountValueRelative,
-  ReferenceTypeId,
 } from '@commercetools/platform-sdk'
 import { Writable } from 'types'
 import { getBaseResourceProperties } from '../helpers'
 import { AbstractResourceRepository, RepositoryContext } from './abstract'
 import { createTypedMoney } from './helpers'
 
-export class CartDiscountRepository extends AbstractResourceRepository {
-  getTypeId(): ReferenceTypeId {
-    return 'cart-discount'
+export class CartDiscountRepository extends AbstractResourceRepository<'cart-discount'> {
+  getTypeId() {
+    return 'cart-discount' as const
   }
 
   create(context: RepositoryContext, draft: CartDiscountDraft): CartDiscount {
@@ -43,7 +42,7 @@ export class CartDiscountRepository extends AbstractResourceRepository {
       validUntil: draft.validUntil,
       value: this.transformValueDraft(draft.value),
     }
-    this.save(context, resource)
+    this.saveNew(context, resource)
     return resource
   }