3948 add comments, add types, refactor, handle range and options

Author: tkostuch

src/api/attribute/service.ts

@@ -4,14 +4,20 @@ import TagCache from 'redis-tag-cache'
 import get from 'lodash/get';
 import cache from '../../lib/cache-instance'
 
-interface AttributeListParam {
+export interface AttributeListParam {
   [key: string]: number[]
 }
 
-function getUri (config, indexName) {
+/**
+ * Build ES uri fro attributes
+ */
+function getUri (config, indexName: string): string {
   return `${config.elasticsearch.protocol}://${config.elasticsearch.host}:${config.elasticsearch.port}/${indexName}/attribute/_search`
 }
 
+/**
+ * Returns attributes from cache
+ */
 async function getAttributeFromCache (attributeCode: string, config) {
   if (config.server.useOutputCache && cache) {
     try {
@@ -26,6 +32,9 @@ async function getAttributeFromCache (attributeCode: string, config) {
   }
 }
 
+/**
+ * Save attributes in cache
+ */
 async function setAttributeInCache (attributeList, config) {
   if (config.server.useOutputCache && cache) {
     try {
@@ -41,36 +50,49 @@ async function setAttributeInCache (attributeList, config) {
   }
 }
 
+/**
+ * Returns attribute with only needed options
+ * @param attribute - attribute object
+ * @param optionsIds - list of only needed options ids
+ */
 function clearAttributeOpitons (attribute, optionsIds: number[]) {
   const stringOptionsIds = optionsIds.map(String)
   return {
     ...attribute,
-    options: (attribute.options || []).filter(option => stringOptionsIds.includes(option.value))
+    options: (attribute.options || []).filter(option => stringOptionsIds.includes(String(option.value)))
   }
 }
 
-function list (attributesParam: AttributeListParam, config, indexName) {
+function list (attributesParam: AttributeListParam, config, indexName: string): Promise<any[]> {
   return new Promise(async (resolve, reject) => {
+    // we start with all attributeCodes that are requested
     let attributeCodes = Object.keys(attributesParam)
 
+    // here we check if some of attribute are in cache
     const rawCachedAttributeList = await Promise.all(
       attributeCodes.map(attributeCode => getAttributeFromCache(attributeCode, config))
     )
 
     const cachedAttributeList = rawCachedAttributeList
+      .filter(Boolean) // remove empty results from cache.get
       .map((cachedAttribute, index) => {
         if (cachedAttribute) {
           const attributeOptionsIds = attributesParam[cachedAttribute.attribute_code]
-          attributeCodes.splice(index, 1) // side effect - reduce elements in needed attribute list
+
+          // side effect - we want to reduce starting 'attributeCodes' because some of them are in cache
+          attributeCodes.splice(index, 1)
+
+          // clear unused options
           return clearAttributeOpitons(cachedAttribute, attributeOptionsIds)
         }
       })
-      .filter(Boolean)
 
+    // if all requested attributes are in cache then we can return here
     if (!attributeCodes.length) {
-      return cachedAttributeList
+      return resolve(cachedAttributeList)
     }
 
+    // fetch attributes for rest attributeCodes
     request({
       uri: getUri(config, indexName),
       method: 'POST',
@@ -81,17 +103,29 @@ function list (attributesParam: AttributeListParam, config, indexName) {
         reject(err)
       }
       const fetchedAttributeList = get(body, 'hits.hits', []).map(hit => hit._source)
+
+      // save atrributes in cache
       await setAttributeInCache(fetchedAttributeList, config)
-      resolve(cachedAttributeList.concat(
-        fetchedAttributeList.map(fetchedAttribute => {
+
+      // cached and fetched attributes
+      const allAttributes = [
+        ...cachedAttributeList,
+        ...fetchedAttributeList.map(fetchedAttribute => {
           const attributeOptionsIds = attributesParam[fetchedAttribute.attribute_code]
+
+          // clear unused options
           return clearAttributeOpitons(fetchedAttribute, attributeOptionsIds)
-        }))
-      )
+        })
+      ]
+
+      return resolve(allAttributes)
     })
   })
 }
 
+/**
+ * Returns only needed data for filters in vsf
+ */
 function transformToMetadata ({
   is_visible_on_front,
   is_visible,
@@ -103,7 +137,8 @@ function transformToMetadata ({
   is_comparable,
   attribute_code,
   slug,
-  options
+  options = [],
+  buckets = []
 }) {
   return {
     is_visible_on_front,
@@ -116,7 +151,8 @@ function transformToMetadata ({
     is_comparable,
     attribute_code,
     slug,
-    options
+    options,
+    buckets
   }
 }
 

src/api/catalog.ts

@@ -4,7 +4,7 @@ import ProcessorFactory from '../processor/factory';
 import { adjustBackendProxyUrl } from '../lib/elastic'
 import cache from '../lib/cache-instance'
 import { sha3_224 } from 'js-sha3'
-import AttributeService from './attribute/service'
+import AttributeService, { AttributeListParam } from './attribute/service'
 import bodybuilder from 'bodybuilder'
 import { elasticsearch, SearchQuery } from 'storefront-query-builder'
 
@@ -20,17 +20,45 @@ function _cacheStorageHandler (config, result, hash, tags) {
   }
 }
 
-async function getProductsAttributesMetadata (body, config, indexName): Promise<any> {
-  const attributeListParam = Object.keys(body.aggregations)
+/**
+ * Transforms ES aggregates into valid format for AttributeService - {[attribute_code]: [bucketId1, bucketId2]}
+ * @param body - products response body
+ * @param config - global config
+ * @param indexName - current indexName
+ */
+async function getProductsAttributesMetadata (body, config, indexName: string): Promise<any> {
+  const attributeListParam: AttributeListParam = Object.keys(body.aggregations)
     .filter(key => body.aggregations[key].buckets.length) // leave only buckets with values
     .reduce((acc, key) => {
-      const attributeCode = key.replace(/agg_terms_|agg_range_/, '')
-      return {
-        ...acc,
-        [attributeCode]: body.aggregations[key].buckets.map(bucket => bucket.key)
+      const attributeCode = key.replace(/^(agg_terms_|agg_range_)|(_options)$/g, '')
+      const bucketsIds = body.aggregations[key].buckets.map(bucket => bucket.key)
+
+      if (!acc[attributeCode]) {
+        acc[attributeCode] = []
       }
+
+      // there can be more then one attributes for example 'agg_terms_color' and 'agg_terms_color_options'
+      // we need to get buckets from both
+      acc[attributeCode] = [...new Set([...acc[attributeCode], ...bucketsIds])]
+
+      return acc
     }, {})
-  const attributeList = await AttributeService.list(attributeListParam, config, indexName)
+
+  // find attribute list
+  const attributeList: any[] = await AttributeService.list(attributeListParam, config, indexName)
+
+  // add buckets for range attributes
+  Object.keys(body.aggregations)
+    .filter(key => key.match(/^(agg_range_)/g))
+    .forEach(key => {
+      const attributeCode = key.replace(/^(agg_range_)/g, '')
+      const buckets = body.aggregations[key].buckets
+      const attribute = attributeList.find(attr => attr.attribute_code === attributeCode)
+      if (attribute) {
+        attribute.buckets = buckets
+      }
+    })
+
   return attributeList
 }