@graphcommerce/algolia-products 9.1.0-canary.28 → 9.1.0-canary.31

package/graphql/GetAlgoliaSettings.graphql

@@ -78,7 +78,7 @@ query GetAlgoliaSettings($indexName: String!) {
       }
     }
     advancedSyntax
-    optionalWords
+    # optionalWords
     disableExactOnAttributes
     exactOnSingleWordQuery
     alternativesAsExact

package/index.ts

@@ -1,8 +1,3 @@
-export * from './mesh/algoliaFacetsToAggregations'
-export * from './mesh/algoliaHitToMagentoProduct'
-export * from './mesh/getSearchResults'
-export * from './mesh/getSearchResultsInput'
-export * from './mesh/getSearchSuggestions'
-export * from './mesh/getSearchSuggestionsInput'
+export * from './mesh'
 export * from './hooks/useAlgoliaIndexName'
 export * from './hooks/useAlgoliaQueryContext'

package/mesh/algoliaFacetsToAggregations.ts

@@ -6,6 +6,7 @@ import type {
   MeshContext,
 } from '@graphcommerce/graphql-mesh'
 import type { AttributeList } from './getAttributeList'
+import { getIndexName } from './getIndexName'
 import type { GetStoreConfigReturn } from './getStoreConfig'
 
 type AlgoliaFacets = { [facetName: string]: AlgoliaFacetOption }
@@ -42,72 +43,24 @@ function compare(a, b) {
 }
 
 /** @public */
-export function algoliaPricesToPricesAggregations(pricesList: {
-  [key: string]: number
-}): AggregationOption[] {
+export function algoliaPricesToPricesAggregations(
+  pricesList: AlgoliaFacetOption,
+): AggregationOption[] {
   const priceArraylist: { value: number; count: number }[] = Object.entries(pricesList)
     .sort(compare)
-    .map((price) => {
-      const value: number = +price[0]
-      return { value, count: price[1] }
-    })
-
-  const interval = Math.round(
-    (priceArraylist[priceArraylist.length - 1].value - priceArraylist[0].value) / 2,
-  )
-
-  const pricesBucket: { [key: number]: { count: number; value: string; label: string } } = {}
-  let increasingInterval = interval
-  priceArraylist.forEach((price) => {
-    if (price.value <= increasingInterval) {
-      if (!pricesBucket[increasingInterval]) {
-        pricesBucket[increasingInterval] = {
-          count: price.count,
-          value:
-            increasingInterval === interval
-              ? `0_${interval}`
-              : `${increasingInterval - interval}_${increasingInterval}`,
-          label:
-            increasingInterval === interval
-              ? `0_${interval}`
-              : `${increasingInterval - interval}-${increasingInterval}`,
-        }
-      } else {
-        pricesBucket[increasingInterval].count += price.count
-      }
-    } else {
-      increasingInterval += interval
-      pricesBucket[increasingInterval] = {
-        count: price.count,
-        value:
-          increasingInterval === interval
-            ? `0_${interval}`
-            : `${increasingInterval - interval}_${increasingInterval}`,
-        label:
-          increasingInterval === interval
-            ? `0-${interval}`
-            : `${increasingInterval - interval}-${increasingInterval}`,
-      }
-    }
-    if (
-      price.value === increasingInterval &&
-      priceArraylist[priceArraylist.length - 1].value !== price.value
-    ) {
-      increasingInterval += interval
-      pricesBucket[increasingInterval] = {
-        count: price.count,
-        value:
-          increasingInterval === interval
-            ? `0_${interval}`
-            : `${increasingInterval - interval}_${increasingInterval}`,
-        label:
-          increasingInterval === interval
-            ? `0_${interval}`
-            : `${increasingInterval - interval}-${increasingInterval}`,
-      }
-    }
-  })
-  return Object.values(pricesBucket)
+    .map((price) => ({ value: Number(+price[0]), count: price[1] }))
+
+  let minValue = priceArraylist[0].value
+  const maxValue = priceArraylist[priceArraylist.length - 1].value
+  if (minValue === maxValue) minValue = 0
+
+  return [
+    {
+      value: `${minValue}_${maxValue}`,
+      label: `${minValue}-${maxValue}`,
+      count: priceArraylist.reduce((acc, price) => acc + price.count, 0),
+    },
+  ]
 }
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -117,8 +70,6 @@ function assertAlgoliaFacets(facets: any): facets is AlgoliaFacets {
 
 /**
  * Map algolia facets to aggregations format
- *
- * TODO: Make sure the aggregations are sorted correctly:
  * https://magento-247-git-canary-graphcommerce.vercel.app/men/photography, through position
  */
 export function algoliaFacetsToAggregations(
@@ -169,31 +120,41 @@ export function algoliaFacetsToAggregations(
         position,
       })
     } else {
-      // Fallback to code if no label is found
-      aggregations.push({
-        label,
-        attribute_code,
-        options: Object.entries(facet).map(([filter, count]) => ({
-          label: filter,
-          count,
-          value: filter,
-        })),
-        position,
-      })
+      /** @todo: We probably need to modify the render-side of this to make it work properly. Magento by default doesn't really support range filters that aren't prices. */
+      const isNumericFacet = false
+
+      if (isNumericFacet) {
+        aggregations.push({
+          label,
+          attribute_code,
+          options: algoliaPricesToPricesAggregations(facet),
+          position,
+        })
+      } else {
+        aggregations.push({
+          label,
+          attribute_code,
+          options: Object.entries(facet).map(([filter, count]) => ({
+            label: filter,
+            count,
+            // @see productFilterInputToAlgoliafacetFiltersInput for the other side.
+            value: filter.replaceAll('/', '_OR_').replaceAll(',', '_AND_'),
+          })),
+          position,
+        })
+      }
     }
   })
 
   return aggregations
 }
 
-let categoryListCache: CategoryResult | null = null
-
 export async function getCategoryList(context: MeshContext) {
-  if (categoryListCache) return categoryListCache
+  const cacheKey = `algolia_getCategoryList_${getIndexName(context)}`
+  const categoryListCached = context.cache.get(cacheKey)
 
-  // context.cache.get('algolia_getCategoryList')
-
-  categoryListCache = await context.m2.Query.categories({
+  if (categoryListCached) return categoryListCached as CategoryResult
+  const categoryListCache = await context.m2.Query.categories({
     args: { filters: {} },
     selectionSet: /* GraphQL */ `
       {
@@ -208,5 +169,8 @@ export async function getCategoryList(context: MeshContext) {
     context,
   })
 
-  return categoryListCache!
+  if (!categoryListCache) throw new Error('Category list not found')
+  await context.cache.set(cacheKey, categoryListCache)
+
+  return categoryListCache
 }

package/mesh/algoliaHitToMagentoProduct.ts

@@ -81,9 +81,14 @@ function mapPriceRange(
   }
 }
 
-export function algoliaUrlToUrlKey(url?: string | null, base?: string | null): string | null {
-  if (!url || !base) return null
-  return url.replace(base, '')
+export function algoliaUrlToUrlKey(url?: string | null, urlSuffix?: string | null): string | null {
+  if (!url) return null
+  const path = new URL(url).pathname.split('/')
+  // The URL key is the last part of the URL.
+  const urlKey = path[path.length - 1]
+
+  // The last part of the URL might end with the urlSuffix (something like `.html`), remove from the end of the URL.
+  return urlSuffix ? urlKey.replace(new RegExp(`${urlSuffix}$`), '') : urlKey
 }
 
 /**
@@ -132,11 +137,12 @@ export function algoliaHitToMagentoProduct(
     created_at,
     image_url,
     is_stock,
-
     price,
     thumbnail_url,
     type_id,
     url,
+    description,
+    short_description,
 
     // not used
     ordered_qty,
@@ -148,12 +154,13 @@ export function algoliaHitToMagentoProduct(
     ...rest
   } = additionalProperties
 
-  // Some custom attributes are returned as array while they need to be a string. Flatten those arrays
-  const flattenedCustomAttributes = {}
+  /**
+   * We flatten any custom attribute array values to a string as 95% of the time they are an array
+   * because the product is a configurable.
+   */
   for (const [key, value] of Object.entries(rest)) {
-    if (value !== null && Array.isArray(value) && value?.length > 0) {
-      flattenedCustomAttributes[key] = value.toString()
-      delete rest[key]
+    if (value !== null && Array.isArray(value)) {
+      rest[key] = value.join(' ')
     }
   }
 
@@ -170,6 +177,8 @@ export function algoliaHitToMagentoProduct(
     review_count: 0,
     rating_summary: Number(rating_summary),
     reviews: { items: [], page_info: {} },
+    description: description ? { html: description } : null,
+    short_description: short_description ? { html: short_description } : null,
     // canonical_url: null,
     // categories: [],
     // country_of_manufacture: null,
@@ -187,18 +196,14 @@ export function algoliaHitToMagentoProduct(
     // options_container: null,
     // price_tiers: [],
     // product_links: [],
-    // related_products: null,
-    // short_description: null,
-    // small_image: null,
     // special_price: null,
     // special_to_date: null,
     small_image: { url: getOriginalImage(thumbnail_url) },
     swatch_image: getOriginalImage(image_url),
     thumbnail: { url: getOriginalImage(thumbnail_url) },
     // upsell_products: [],
-    url_key: algoliaUrlToUrlKey(url, storeConfig?.base_link_url),
+    url_key: algoliaUrlToUrlKey(url, storeConfig?.product_url_suffix),
     url_suffix: storeConfig?.product_url_suffix,
     ...rest,
-    ...flattenedCustomAttributes,
   }
 }

package/mesh/getAlgoliaSettings.ts

@@ -1,21 +1,36 @@
 import type { AlgoliasettingsResponse, MeshContext } from '@graphcommerce/graphql-mesh'
+import type { GraphQLError } from 'graphql'
 import { getIndexName } from './getIndexName'
 
-let settingsCache: AlgoliasettingsResponse | null = null
+function isGraphQLError(err: unknown): err is GraphQLError {
+  return !!(err as GraphQLError)?.message
+}
+
+export type GetAlgoliaSettingsReturn = Pick<
+  AlgoliasettingsResponse,
+  'attributesForFaceting' | 'replicas'
+>
+
+export async function getAlgoliaSettings(context: MeshContext): Promise<GetAlgoliaSettingsReturn> {
+  const cacheKey = `algolia_getSettings_${getIndexName(context)}`
+  const settingsCached = context.cache.get(cacheKey)
+  if (settingsCached) return settingsCached
+
+  const settings = await context.algolia.Query.algolia_getSettings({
+    args: { indexName: getIndexName(context) },
+    selectionSet: /* GraphQL */ `
+      {
+        replicas
+        attributesForFaceting
+      }
+    `,
+    context,
+  })
+
+  if (isGraphQLError(settings)) throw settings
+  if (!settings) throw Error('No settings found')
 
-export async function getAlgoliaSettings(context: MeshContext): Promise<AlgoliasettingsResponse> {
-  if (!settingsCache) {
-    settingsCache = await context.algolia.Query.algolia_getSettings({
-      args: { indexName: getIndexName(context) },
-      selectionSet: /* GraphQL */ `
-        {
-          replicas
-        }
-      `,
-      context,
-    })
-  }
+  await context.cache.set(cacheKey, settings)
 
-  if (!settingsCache) throw Error('No settings found')
-  return settingsCache
+  return settings
 }

package/mesh/getAttributeList.ts

@@ -1,13 +1,14 @@
 import type { MeshContext } from '@graphcommerce/graphql-mesh'
 // eslint-disable-next-line import/no-extraneous-dependencies
 import { filterNonNullableKeys } from '@graphcommerce/next-ui/RenderType/filterNonNullableKeys'
+import { getIndexName } from './getIndexName'
 
 export type AttributeList = { label: string; code: string }[]
 
-let attributeListCache: AttributeList | null = null
-
 export async function getAttributeList(context: MeshContext): Promise<AttributeList> {
-  if (attributeListCache) return attributeListCache
+  const cacheKey = `algolia_getAttributeList_${getIndexName(context)}`
+  const attributeListCached = context.cache.get(cacheKey)
+  if (attributeListCached) return attributeListCached
 
   if (
     import.meta.graphCommerce.magentoVersion >= 247 &&
@@ -22,7 +23,9 @@ export async function getAttributeList(context: MeshContext): Promise<AttributeL
       selectionSet: '{ items{ code label } }',
       context,
     }).then((res) => res?.items)) as { label?: string; code: string }[]
-    attributeListCache = filterNonNullableKeys(items, ['label'])
+
+    if (!items) throw new Error('Attribute list not found')
+    await context.cache.set(cacheKey, filterNonNullableKeys(items, ['label']))
 
     return filterNonNullableKeys(items, ['label'])
   }

package/mesh/getSearchResults.ts

@@ -2,7 +2,7 @@ import type { MeshContext, QueryproductsArgs } from '@graphcommerce/graphql-mesh
 import type { GraphQLResolveInfo } from 'graphql'
 import { getAlgoliaSettings } from './getAlgoliaSettings'
 import { getSearchResultsInput } from './getSearchResultsInput'
-import { getSortedIndex } from './sortOptions'
+import { getSortedIndex } from './getSortedIndex'
 
 export async function getSearchResults(
   args: QueryproductsArgs,
@@ -27,6 +27,13 @@ export async function getSearchResults(
           additionalProperties
         }
         facets
+        renderingContent {
+          facetOrdering {
+            facets {
+              order
+            }
+          }
+        }
       }
     `,
     context,

package/mesh/getSearchResultsInput.ts

@@ -3,6 +3,7 @@ import type {
   MeshContext,
   QueryproductsArgs,
 } from '@graphcommerce/graphql-mesh'
+import { getAlgoliaSettings } from './getAlgoliaSettings'
 import { getStoreConfig } from './getStoreConfig'
 import {
   productFilterInputToAlgoliaFacetFiltersInput,
@@ -20,11 +21,16 @@ export async function getSearchResultsInput(
     facets: ['*'],
     hitsPerPage: args.pageSize ? args.pageSize : 10,
     page: args.currentPage ? args.currentPage - 1 : 0,
-    facetFilters: productFilterInputToAlgoliaFacetFiltersInput(filters),
+    facetFilters: productFilterInputToAlgoliaFacetFiltersInput(
+      await getAlgoliaSettings(context),
+      filters,
+      args.search ?? '',
+    ),
     numericFilters: await productFilterInputToAlgoliaNumericFiltersInput(
       getStoreConfig(context),
       filters,
     ),
     analytics: true,
+    ruleContexts: typeof args.search === 'string' ? ['Search'] : ['Catalog'],
   }
 }

package/mesh/getSearchSuggestions.ts

@@ -1,6 +1,7 @@
 import type { MeshContext, SearchSuggestion } from '@graphcommerce/graphql-mesh'
 import { filterNonNullableKeys } from '@graphcommerce/next-ui'
-import { getSearchSuggestionsInput, getSuggestionsIndexName } from './getSearchSuggestionsInput'
+import { getSearchSuggestionsIndexName } from './getSearchSuggestionsIndexName'
+import { getSearchSuggestionsInput } from './getSearchSuggestionsInput'
 
 export async function getSearchSuggestions(
   search: string,
@@ -8,7 +9,7 @@ export async function getSearchSuggestions(
 ): Promise<SearchSuggestion[]> {
   const suggestions = await context.algolia.Query.algolia_searchSingleIndex({
     args: {
-      indexName: getSuggestionsIndexName(context),
+      indexName: getSearchSuggestionsIndexName(context),
       input: await getSearchSuggestionsInput(search, context),
     },
     selectionSet: /* GraphQL */ `
@@ -23,5 +24,7 @@ export async function getSearchSuggestions(
     context,
   })
 
-  return filterNonNullableKeys(suggestions?.hits, []).map((hit) => ({ search: hit.objectID }))
+  return filterNonNullableKeys(suggestions?.hits, [])
+    .filter((hit) => hit.objectID !== search)
+    .map((hit) => ({ search: hit.objectID }))
 }

package/mesh/getSearchSuggestionsIndexName.ts

@@ -0,0 +1,6 @@
+import type { MeshContext } from '@graphcommerce/graphql-mesh'
+import { getIndexName } from './getIndexName'
+
+export function getSearchSuggestionsIndexName(context: MeshContext) {
+  return `${getIndexName(context)}${import.meta.graphCommerce.algolia.suggestionsSuffix}`
+}

package/mesh/getSearchSuggestionsInput.ts

@@ -1,14 +1,9 @@
 import type { MeshContext, Queryalgolia_searchSingleIndexArgs } from '@graphcommerce/graphql-mesh'
-import { getIndexName } from './getIndexName'
 
 export function isSuggestionsEnabled() {
   return Boolean(import.meta.graphCommerce.algolia.suggestionsSuffix)
 }
 
-export function getSuggestionsIndexName(context: MeshContext) {
-  return `${getIndexName(context).replace('_products', import.meta.graphCommerce.algolia.suggestionsSuffix ?? '')}`
-}
-
 // eslint-disable-next-line @typescript-eslint/require-await
 export async function getSearchSuggestionsInput(
   search: string,

package/mesh/getSortedIndex.ts

@@ -0,0 +1,54 @@
+import type { MeshContext, ProductAttributeSortInput } from '@graphcommerce/graphql-mesh'
+import { nonNullable } from '@graphcommerce/magento-customer'
+import type { GetAlgoliaSettingsReturn } from './getAlgoliaSettings'
+import { getGroupId } from './getGroupId'
+import { getIndexName } from './getIndexName'
+
+function stripVirtual(index: string) {
+  return index.slice(8, -1)
+}
+
+export async function getSortedIndex(
+  context: MeshContext,
+  settings: Promise<GetAlgoliaSettingsReturn>,
+  sortInput: ProductAttributeSortInput | null = {},
+): Promise<string> {
+  const baseIndex = getIndexName(context)
+  // const availableSorting = Object.values(sortOptions)
+  const [attr, dirEnum] = Object.entries(sortInput ?? {}).filter(nonNullable)?.[0] ?? []
+  if (!attr || !dirEnum) return baseIndex
+
+  const dir = dirEnum.toLowerCase()
+  const candidates = ((await settings).replicas ?? [])
+    .filter(nonNullable)
+    .filter((r) => r.startsWith(`virtual(${baseIndex}_${attr}`) && r.endsWith(`_${dir})`))
+
+  if (candidates.length === 0) {
+    console.warn(
+      `[@graphcommerce/algolia-products] WARNING: Expecting virtual replica but couldn't find the expected index for attr ${attr} with ${dir}, please add to the Algolia settings in the Magento Admin Panel. Falling back to baseIndex.`,
+    )
+    return baseIndex
+  }
+
+  if (attr === 'price') {
+    const enabled = import.meta.graphCommerce.algolia.customerGroupPricingEnabled
+
+    const groupId = enabled ? getGroupId(context) : 'default'
+    const found = candidates.find((r) => r.endsWith(`${groupId}_${dir})`))
+
+    if (!found) {
+      console.warn(
+        '[@graphcommerce/algolia-products] WARNING: Can not find correct price index.',
+        'It should look something like:',
+        `virtual(${baseIndex}_${attr}_${groupId}_${dir})`,
+        'Available indexes (using the first one):',
+        candidates,
+      )
+      return stripVirtual(candidates[0])
+    }
+
+    return stripVirtual(found)
+  }
+
+  return stripVirtual(candidates[0])
+}

package/mesh/getStoreConfig.ts

@@ -1,4 +1,5 @@
 import type { Maybe, MeshContext, StoreConfig } from '@graphcommerce/graphql-mesh'
+import { getIndexName } from './getIndexName'
 
 export type GetStoreConfigReturn =
   | Maybe<
@@ -12,22 +13,24 @@ export type GetStoreConfigReturn =
     >
   | undefined
 
-let configCache: Promise<StoreConfig>
+export async function getStoreConfig(context: MeshContext): Promise<StoreConfig> {
+  const cacheKey = `algolia_getStoreConfig_${getIndexName(context)}`
+  const configCached = context.cache.get(cacheKey)
+  if (configCached) return configCached as StoreConfig
 
-export function getStoreConfig(context: MeshContext): Promise<StoreConfig> {
-  // eslint-disable-next-line @typescript-eslint/no-misused-promises
-  if (!configCache) {
-    configCache = context.m2.Query.storeConfig({
-      context,
-      selectionSet: /* GraphQL */ `
-        {
-          root_category_uid
-          default_display_currency_code
-          base_link_url
-          product_url_suffix
-        }
-      `,
-    })
-  }
+  const configCache = await context.m2.Query.storeConfig({
+    context,
+    selectionSet: /* GraphQL */ `
+      {
+        root_category_uid
+        default_display_currency_code
+        base_link_url
+        product_url_suffix
+      }
+    `,
+  })
+
+  if (!configCache) throw new Error('Store config not found')
+  await context.cache.set(cacheKey, configCache)
   return configCache
 }

package/mesh/index.ts

@@ -0,0 +1,16 @@
+export * from './algoliaFacetsToAggregations'
+export * from './algoliaHitToMagentoProduct'
+export * from './getAlgoliaSettings'
+export * from './getAttributeList'
+export * from './getGroupId'
+export * from './getIndexName'
+export * from './getSearchResults'
+export * from './getSearchResultsInput'
+export * from './getSearchSuggestions'
+export * from './getSearchSuggestionsInput'
+export * from './getSortedIndex'
+export * from './getStoreConfig'
+export * from './productFilterInputToAlgoliafacetFiltersInput'
+export * from './sortAggregations'
+export * from './sortFieldOptions'
+export * from './utils'

package/mesh/productFilterInputToAlgoliafacetFiltersInput.ts

@@ -8,6 +8,7 @@ import {
   isFilterTypeRange,
 } from '@graphcommerce/magento-product'
 import type { InputMaybe } from '@graphcommerce/next-config'
+import type { GetAlgoliaSettingsReturn } from './getAlgoliaSettings'
 import type { GetStoreConfigReturn } from './getStoreConfig'
 import { nonNullable } from './utils'
 
@@ -17,24 +18,44 @@ import { nonNullable } from './utils'
  * https://www.algolia.com/doc/api-reference/api-parameters/facetFilters/
  */
 export function productFilterInputToAlgoliaFacetFiltersInput(
+  settings: GetAlgoliaSettingsReturn,
   filters?: InputMaybe<ProductAttributeFilterInput>,
+  query?: string,
 ) {
   const filterArray: (string | string[])[] = []
   if (!filters) {
     return []
   }
 
+  const hasVisibility = settings?.attributesForFaceting?.some(
+    (attr) => attr === 'visibility' || attr?.includes('filterOnly(visibility)'),
+  )
+
+  if (hasVisibility) {
+    if (typeof query === 'string') {
+      filterArray.push(['visibility:Catalog, Search', 'visibility:Search'])
+    } else {
+      filterArray.push(['visibility:Catalog, Search', 'visibility:Catalog'])
+    }
+  }
+
+  // @see algoliaFacetsToAggregations for the other side.
+  const maybeDecode = (value: string) => value.replaceAll('_OR_', '/').replaceAll('_AND_', ',')
+
   Object.entries(filters).forEach(([key, value]) => {
     if (isFilterTypeEqual(value)) {
       if (value.in) {
         const values = value.in.filter(nonNullable)
-        if (key === 'category_uid') filterArray.push(values.map((v) => `categoryIds:${atob(v)}`))
-        else filterArray.push(values.map((v) => `${key}:${v}`))
+        if (key === 'category_uid') {
+          filterArray.push(values.map((v) => `categoryIds:${atob(v)}`))
+        } else {
+          filterArray.push(values.map((v) => `${key}:${maybeDecode(v)}`))
+        }
       }
 
       if (value.eq) {
         if (key === 'category_uid') filterArray.push(`categoryIds:${atob(value.eq)}`)
-        else filterArray.push(`${key}:${value.eq}`)
+        else filterArray.push(`${key}:${maybeDecode(value.eq)}`)
       }
     }
 
@@ -42,7 +63,6 @@ export function productFilterInputToAlgoliaFacetFiltersInput(
       throw Error('Match filters are not supported')
     }
   })
-
   return filterArray
 }