@labdigital/commercetools-mock 0.7.1 → 0.9.1

package/src/product-projection-search.ts

@@ -4,9 +4,25 @@ import {
   Product,
   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 { parseFilterExpression } from './lib/projectionSearchFilter'
+import {
+  FilterExpression,
+  generateFacetFunc,
+  getVariants,
+  parseFilterExpression,
+  RangeExpression,
+  resolveVariantValue,
+} from './lib/projectionSearchFilter'
 import { applyPriceSelector } from './priceSelector'
 import { AbstractStorage } from './storage'
 
@@ -68,10 +84,9 @@ export class ProductProjectionSearch {
         )
 
         // 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) {
         throw new CommercetoolsError<InvalidInputError>(
           {
@@ -84,6 +99,7 @@ export class ProductProjectionSearch {
     }
 
     // TODO: Calculate facets
+    const facets = this.getFacets(params, resources)
 
     // Apply filters post facetting
     if (params['filter.query']) {
@@ -91,10 +107,10 @@ export class ProductProjectionSearch {
         const filters = params['filter.query'].map(f =>
           parseFilterExpression(f, params.staged ?? false)
         )
-        resources = resources
-          .filter(resource =>
-            filters.every(f => f(resource, markMatchingVariant))
-          )
+        
+        resources = resources.filter(resource =>
+          filters.every(f => f(resource, markMatchingVariant))
+        )
       } catch (err) {
         throw new CommercetoolsError<InvalidInputError>(
           {
@@ -127,7 +143,7 @@ export class ProductProjectionSearch {
       offset: offset,
       limit: limit,
       results: resources.map(this.transform),
-      facets: {},
+      facets: facets,
     }
   }
 
@@ -139,6 +155,9 @@ export class ProductProjectionSearch {
       lastModifiedAt: product.lastModifiedAt,
       version: product.version,
       name: obj.name,
+      key: product.key,
+      description: obj.description,
+      metaDescription: obj.metaDescription,
       slug: obj.slug,
       categories: obj.categories,
       masterVariant: obj.masterVariant,
@@ -146,4 +165,185 @@ export class ProductProjectionSearch {
       productType: product.productType,
     }
   }
+
+  getFacets(
+    params: ProductProjectionSearchParams,
+    products: Product[]
+  ): FacetResults {
+    if (!params.facet) return {}
+    const staged = false
+    const result: FacetResults = {}
+
+    for (const facet of params.facet) {
+      const expression = generateFacetFunc(facet)
+
+      // Term Facet
+      if (expression.type === 'TermExpression') {
+        result[facet] = this.termFacet(expression.source, products, staged)
+      }
+
+      // Range Facet
+      if (expression.type === 'RangeExpression') {
+        result[expression.source] = this.rangeFacet(
+          expression.source,
+          expression.children,
+          products,
+          staged
+        )
+      }
+
+      // FilteredFacet
+      if (expression.type === 'FilterExpression') {
+        result[expression.source] = this.filterFacet(
+          expression.source,
+          expression.children,
+          products,
+          staged
+        )
+      }
+    }
+
+    return result
+  }
+
+  /**
+   * TODO: This implemention needs the following additional features:
+   *  - counting products
+   *  - correct dataType
+   */
+  termFacet(
+    facet: string,
+    products: Product[],
+    staged: boolean
+  ): TermFacetResult {
+    const result: Writable<TermFacetResult> = {
+      type: 'terms',
+      dataType: 'text',
+      missing: 0,
+      total: 0,
+      other: 0,
+      terms: [],
+    }
+    const terms: Record<any, number> = {}
+
+    if (facet.startsWith('variants.')) {
+      products.forEach(p => {
+        const variants = getVariants(p, staged)
+        variants.forEach(v => {
+          result.total++
+
+          let value = resolveVariantValue(v, facet)
+          if (value === undefined) {
+            result.missing++
+          } else {
+            if (typeof value === 'number') {
+              value = Number(value).toFixed(1)
+            }
+            terms[value] = value in terms ? terms[value] + 1 : 1
+          }
+        })
+      })
+    } else {
+      products.forEach(p => {
+        const value = nestedLookup(p, facet)
+        result.total++
+        if (value === undefined) {
+          result.missing++
+        } else {
+          terms[value] = value in terms ? terms[value] + 1 : 1
+        }
+      })
+    }
+    for (const term in terms) {
+      result.terms.push({
+        term: term as any,
+        count: terms[term],
+      })
+    }
+    return result
+  }
+
+  filterFacet(
+    source: string,
+    filters: FilterExpression[] | undefined,
+    products: Product[],
+    staged: boolean
+  ): FilteredFacetResult {
+    let count = 0
+    if (source.startsWith('variants.')) {
+      for (const p of products) {
+        for (const v of getVariants(p, staged)) {
+          const val = resolveVariantValue(v, source)
+          if (filters?.some(f => f.match(val))) {
+            count++
+          }
+        }
+      }
+    } else {
+      throw new Error('not supported')
+    }
+
+    return {
+      type: 'filter',
+      count: count,
+    }
+  }
+
+  rangeFacet(
+    source: string,
+    ranges: RangeExpression[] | undefined,
+    products: Product[],
+    staged: boolean
+  ): RangeFacetResult {
+    const counts =
+      ranges?.map(range => {
+        if (source.startsWith('variants.')) {
+          const values = []
+          for (const p of products) {
+            for (const v of getVariants(p, staged)) {
+              const val = resolveVariantValue(v, source)
+              if (val === undefined) {
+                continue
+              }
+
+              if (range.match(val)) {
+                values.push(val)
+              }
+            }
+          }
+
+          const numValues = values.length
+          return {
+            type: 'double',
+            from: range.start || 0,
+            fromStr: range.start !== null ? Number(range.start).toFixed(1) : '',
+            to: range.stop || 0,
+            toStr: range.stop !== null ? Number(range.stop).toFixed(1) : '',
+            count: numValues,
+            // totalCount: 0,
+            total: values.reduce((a, b) => a + b, 0),
+            min: numValues > 0 ? Math.min(...values) : 0,
+            max: numValues > 0 ? Math.max(...values) : 0,
+            mean: numValues > 0 ? mean(values) : 0,
+          }
+        } else {
+          throw new Error('not supported')
+        }
+      }) || []
+    const data: RangeFacetResult = {
+      type: 'range',
+      // @ts-ignore
+      dataType: 'number',
+      ranges: counts,
+    }
+    return data
+  }
+}
+
+const mean = (arr: number[]) => {
+  let total = 0
+  for (let i = 0; i < arr.length; i++) {
+    total += arr[i]
+  }
+  return total / arr.length
 }

package/src/repositories/abstract.ts

@@ -65,8 +65,18 @@ export abstract class AbstractRepository {
     if (!deepEqual(modifiedResource, resource)) {
       this.save(context, modifiedResource)
     }
-    return modifiedResource
+
+    const result = this.postProcessResource(modifiedResource)
+    if (!result) {
+      throw new Error("invalid post process action")
+    }
+    return result
+  }
+
+  postProcessResource(resource: BaseResource | null): BaseResource | null {
+    return resource
   }
+
 }
 
 export abstract class AbstractResourceRepository extends AbstractRepository {
@@ -79,12 +89,17 @@ export abstract class AbstractResourceRepository extends AbstractRepository {
   }
 
   query(context: RepositoryContext, params: QueryParams = {}) {
-    return this._storage.query(context.projectKey, this.getTypeId(), {
+    const result = this._storage.query(context.projectKey, this.getTypeId(), {
       expand: params.expand,
       where: params.where,
       offset: params.offset,
       limit: params.limit,
     })
+
+    // @ts-ignore
+    result.results = result.results.map(this.postProcessResource)
+
+    return result
   }
 
   get(
@@ -92,7 +107,8 @@ export abstract class AbstractResourceRepository extends AbstractRepository {
     id: string,
     params: GetParams = {}
   ): BaseResource | null {
-    return this._storage.get(context.projectKey, this.getTypeId(), id, params)
+    const resource = this._storage.get(context.projectKey, this.getTypeId(), id, params)
+    return this.postProcessResource(resource)
   }
 
   getByKey(
@@ -100,12 +116,13 @@ export abstract class AbstractResourceRepository extends AbstractRepository {
     key: string,
     params: GetParams = {}
   ): BaseResource | null {
-    return this._storage.getByKey(
+    const resource = this._storage.getByKey(
       context.projectKey,
       this.getTypeId(),
       key,
       params
     )
+    return this.postProcessResource(resource)
   }
 
   delete(
@@ -113,12 +130,13 @@ export abstract class AbstractResourceRepository extends AbstractRepository {
     id: string,
     params: GetParams = {}
   ): BaseResource | null {
-    return this._storage.delete(
+    const resource = this._storage.delete(
       context.projectKey,
       this.getTypeId(),
       id,
       params
     )
+    return this.postProcessResource(resource)
   }
 
   save(context: RepositoryContext, resource: BaseResource) {

package/src/repositories/extension.ts

@@ -10,13 +10,30 @@ import {
 } from '@commercetools/platform-sdk'
 import { Writable } from '../types'
 import { getBaseResourceProperties } from '../helpers'
-import { AbstractResourceRepository, RepositoryContext } from './abstract'
+import { AbstractResourceRepository, GetParams, RepositoryContext } from './abstract'
+import { maskSecretValue } from '../lib/masking'
 
 export class ExtensionRepository extends AbstractResourceRepository {
   getTypeId(): ReferenceTypeId {
     return 'extension'
   }
 
+  postProcessResource(resource: Extension) {
+    if (resource) {
+      if (resource.destination.type === "HTTP" &&
+        resource.destination.authentication?.type === "AuthorizationHeader"
+      ) {
+        return maskSecretValue(
+          resource, 'destination.authentication.headerValue')
+      }
+      else if (resource.destination.type == "AWSLambda") {
+        return maskSecretValue(
+          resource, 'destination.accessSecret')
+      }
+    }
+    return resource
+  }
+
   create(context: RepositoryContext, draft: ExtensionDraft): Extension {
     const resource: Extension = {
       ...getBaseResourceProperties(),

package/src/repositories/helpers.ts

@@ -75,10 +75,44 @@ export const createPrice = (draft: PriceDraft): Price => {
 }
 
 export const createTypedMoney = (value: Money): TypedMoney => {
+
+  // Taken from https://docs.adyen.com/development-resources/currency-codes
+  let fractionDigits = 2
+  switch (value.currencyCode.toUpperCase()) {
+    case 'BHD':
+    case 'IQD':
+    case 'JOD':
+    case 'KWD':
+    case 'LYD':
+    case 'OMR':
+    case 'TND':
+      fractionDigits = 3
+      break
+    case 'CVE':
+    case 'DJF':
+    case 'GNF':
+    case 'IDR':
+    case 'JPY':
+    case 'KMF':
+    case 'KRW':
+    case 'PYG':
+    case 'RWF':
+    case 'UGX':
+    case 'VND':
+    case 'VUV':
+    case 'XAF':
+    case 'XOF':
+    case 'XPF':
+      fractionDigits = 0
+      break
+    default:
+      fractionDigits = 2
+  }
+
   return {
     type: 'centPrecision',
-    fractionDigits: 2,
     ...value,
+    fractionDigits: fractionDigits,
   }
 }
 
@@ -135,10 +169,10 @@ export const getReferenceFromResourceIdentifier = <T extends Reference>(
     )
   }
 
-  return ({
+  return {
     typeId: resourceIdentifier.typeId,
     id: resource?.id,
-  } as unknown) as T
+  } as unknown as T
 }
 
 export const getRepositoryContext = (request: Request): RepositoryContext => {

package/src/repositories/product-projection.ts

@@ -39,6 +39,7 @@ export class ProductProjectionRepository extends AbstractResourceRepository {
     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: QueryParamsAsArray(query.expand),

package/src/repositories/project.ts

@@ -23,11 +23,16 @@ import { maskSecretValue } from '../lib/masking'
 export class ProjectRepository extends AbstractRepository {
   get(context: RepositoryContext): Project | null {
     const resource = this._storage.getProject(context.projectKey)
-    const masked = maskSecretValue<Project>(
-      resource,
-      'externalOAuth.authorizationHeader'
-    )
-    return masked
+    return this.postProcessResource(resource)
+  }
+
+  postProcessResource(resource: any): any {
+    if (resource) {
+      return maskSecretValue(
+        resource, 'externalOAuth.authorizationHeader')
+    }
+    return resource
+
   }
 
   save(context: RepositoryContext, resource: Project) {

package/src/repositories/state.ts

@@ -2,12 +2,14 @@ import { getBaseResourceProperties } from '../helpers'
 import { getReferenceFromResourceIdentifier } from './helpers'
 import {
   ReferenceTypeId,
+  StateReference,
   State,
   StateChangeKeyAction,
   StateDraft,
   StateSetDescriptionAction,
   StateSetNameAction,
   StateSetRolesAction,
+  StateSetTransitionsAction,
   StateUpdateAction,
 } from '@commercetools/platform-sdk'
 import { AbstractResourceRepository, RepositoryContext } from './abstract'
@@ -71,5 +73,17 @@ export class StateRepository extends AbstractResourceRepository {
     ) => {
       resource.roles = roles
     },
+    setTransitions: (
+      context: RepositoryContext,
+      resource: Writable<State>,
+      { transitions }: StateSetTransitionsAction
+    ) => {
+      resource.transitions = transitions?.map((resourceId): StateReference => {
+        return {
+          id: resourceId.id || "",
+          typeId: "state",
+        }
+      })
+    }
   }
 }

package/src/services/product-projection.test.ts

@@ -50,10 +50,29 @@ beforeEach(async () => {
         attributes: [
           {
             name: 'number',
-            value: '1' as any,
+            value: 4 as any,
           },
         ],
       },
+      variants: [
+        {
+          sku: 'my-other-sku',
+          prices: [
+            {
+              value: {
+                currencyCode: 'EUR',
+                centAmount: 91789,
+              },
+            },
+          ],
+          attributes: [
+            {
+              name: 'number',
+              value: 50 as any,
+            },
+          ],
+        },
+      ],
       name: {
         'nl-NL': 'test product',
       },
@@ -96,7 +115,26 @@ beforeEach(async () => {
         images: [],
         attributes: productDraft.masterVariant?.attributes,
       },
-      variants: [],
+      variants: [
+        {
+          id: 2,
+          sku: 'my-other-sku',
+          prices: [
+            {
+              id: product.masterData.current.variants[0].prices[0].id,
+              value: {
+                type: 'centPrecision',
+                currencyCode: 'EUR',
+                centAmount: 91789,
+                fractionDigits: 2,
+              },
+            },
+          ],
+          assets: [],
+          images: [],
+          attributes: productDraft.variants![0].attributes,
+        },
+      ],
       name: productDraft.name,
       slug: productDraft.slug,
       categories: [],
@@ -210,7 +248,7 @@ describe('Product Projection Search - Filters', () => {
     const response = await supertest(ctMock.app)
       .get('/dummy/product-projections/search')
       .query({
-        filter: ['variants.attributes.number:range(2 TO 10)'],
+        filter: ['variants.attributes.number:range(5 TO 10)'],
       })
 
     const result: ProductProjectionPagedSearchResponse = response.body
@@ -220,3 +258,132 @@ describe('Product Projection Search - Filters', () => {
     })
   })
 })
+
+describe('Product Projection Search - Facets', () => {
+  test('termExpr - variants.attributes.number', async () => {
+    const response = await supertest(ctMock.app)
+      .get('/dummy/product-projections/search')
+      .query({
+        facet: ['variants.attributes.number'],
+      })
+
+    const result: ProductProjectionPagedSearchResponse = response.body
+    expect(result).toMatchObject({
+      count: 1,
+      facets: {
+        'variants.attributes.number': {
+          type: 'terms',
+          dataType: 'text',
+          missing: 0,
+          total: 2,
+          terms: [
+            {
+              term: '4.0',
+              count: 1,
+            },
+            {
+              term: '50.0',
+              count: 1,
+            },
+          ],
+        },
+      },
+      results: [
+        {
+          masterVariant: { sku: 'my-sku' },
+        },
+      ],
+    })
+  })
+
+  test('filterExpr - variants.attributes.number', async () => {
+    const response = await supertest(ctMock.app)
+      .get('/dummy/product-projections/search')
+      .query({
+        facet: ['variants.attributes.number:3,4'],
+      })
+
+    const result: ProductProjectionPagedSearchResponse = response.body
+    expect(result).toMatchObject({
+      count: 1,
+      facets: {
+        'variants.attributes.number': {
+          type: 'filter',
+          count: 1,
+        },
+      },
+      results: [
+        {
+          masterVariant: { sku: 'my-sku' },
+        },
+      ],
+    })
+  })
+
+  test('rangeExpr - variants.attributes.number', async () => {
+    const response = await supertest(ctMock.app)
+      .get('/dummy/product-projections/search')
+      .query({
+        facet: [
+          'variants.attributes.number:range(* TO 5), (5 TO 25), (25 TO 100)',
+        ],
+      })
+
+    const result: ProductProjectionPagedSearchResponse = response.body
+    expect(result).toMatchObject({
+      count: 1,
+      facets: {
+        'variants.attributes.number': {
+          type: 'range',
+          dataType: 'number',
+          ranges: [
+            {
+              type: 'double',
+              from: 0.0,
+              fromStr: '',
+              to: 5.0,
+              toStr: '5.0',
+              count: 1,
+              // totalCount: 1,
+              total: 4.0,
+              min: 4.0,
+              max: 4.0,
+              mean: 4.0,
+            },
+            {
+              type: 'double',
+              from: 5.0,
+              fromStr: '5.0',
+              to: 25.0,
+              toStr: '25.0',
+              count: 0,
+              // totalCount: 0,
+              total: 0.0,
+              min: 0.0,
+              max: 0.0,
+              mean: 0.0,
+            },
+            {
+              type: 'double',
+              from: 25.0,
+              fromStr: '25.0',
+              to: 100.0,
+              toStr: '100.0',
+              count: 1,
+              // totalCount: 1,
+              total: 50,
+              min: 50.0,
+              max: 50.0,
+              mean: 50.0,
+            },
+          ],
+        },
+      },
+      results: [
+        {
+          masterVariant: { sku: 'my-sku' },
+        },
+      ],
+    })
+  })
+})