@graphcommerce/algolia-products 9.0.0-canary.100

package/graphql/CustomerGroupId.graphql

@@ -0,0 +1,3 @@
+fragment CustomerGroupId on Customer @inject(into: ["CustomerInfo"]) {
+  group_id
+}

package/graphql/GetAlgoliaSettings.graphql

@@ -0,0 +1,122 @@
+query GetAlgoliaSettings($indexName: String!) {
+  algolia_getSettings(indexName: $indexName) {
+    attributesForFaceting
+    replicas
+    paginationLimitedTo
+    unretrievableAttributes
+    disableTypoToleranceOnWords
+    attributesToTransliterate
+    camelCaseAttributes
+    decompoundedAttributes {
+      de
+    }
+    indexLanguages
+    disablePrefixOnAttributes
+    allowCompressionOfIntegerArray
+    numericAttributesForFiltering
+    separatorsToIndex
+    searchableAttributes
+    userData {
+      settingID
+      pluginVersion
+    }
+    customNormalization
+    attributeForDistinct
+    attributesToRetrieve
+    ranking
+    customRanking
+    relevancyStrictness
+    attributesToHighlight
+    attributesToSnippet
+    highlightPreTag
+    highlightPostTag
+    snippetEllipsisText
+    restrictHighlightAndSnippetArrays
+    hitsPerPage
+    minWordSizefor1Typo
+    minWordSizefor2Typos
+    typoTolerance {
+      __typename
+      ... on AlgoliaBoolean_container {
+        Boolean
+      }
+      ... on Algoliatypo_tolerance_container {
+        typo_tolerance
+      }
+    }
+    allowTyposOnNumericTokens
+    disableTypoToleranceOnAttributes
+    ignorePlurals {
+      __typename
+      ... on AlgoliasupportedLanguage_container {
+        supportedLanguage
+      }
+      ... on AlgoliaBoolean_container {
+        Boolean
+      }
+    }
+    removeStopWords {
+      __typename
+    }
+    keepDiacriticsOnCharacters
+    queryLanguages
+    decompoundQuery
+    enableRules
+    enablePersonalization
+    queryType
+    removeWordsIfNoResults
+    mode
+    semanticSearch {
+      eventSources {
+        __typename
+        ... on AlgoliaString_container {
+          String
+        }
+        ... on AlgoliaVoid_container {
+          Void
+        }
+      }
+    }
+    advancedSyntax
+    optionalWords
+    disableExactOnAttributes
+    exactOnSingleWordQuery
+    alternativesAsExact
+    advancedSyntaxFeatures
+    distinct
+    replaceSynonymsInHighlight
+    minProximity
+    responseFields
+    maxFacetHits
+    maxValuesPerFacet
+    sortFacetValuesBy
+    attributeCriteriaComputedByMinProximity
+    renderingContent {
+      facetOrdering {
+        facets {
+          order
+        }
+        values {
+          additionalProperties {
+            key
+            value {
+              order
+              sortRemainingBy
+              hide
+            }
+          }
+        }
+      }
+    }
+    enableReRanking
+    reRankingApplyFilter {
+      __typename
+      ... on AlgoliaString_container {
+        String
+      }
+      ... on AlgoliaVoid_container {
+        Void
+      }
+    }
+  }
+}

package/graphql/ProductListItems_Algolia.graphql

@@ -0,0 +1,3 @@
+fragment ProductListItems_Algolia on Products @inject(into: ["ProductListItems"]) {
+  algolia_queryID
+}

package/hooks/useAlgoliaIndexName.ts

@@ -0,0 +1,5 @@
+import { useStorefrontConfig } from '@graphcommerce/next-ui'
+
+export function useAlgoliaIndexName() {
+  return `${import.meta.graphCommerce.algolia.indexNamePrefix}${useStorefrontConfig().magentoStoreCode}_products`
+}

package/hooks/useAlgoliaQueryContext.ts

@@ -0,0 +1,11 @@
+import React, { useContext } from 'react'
+
+export type AlgoliaQueryContextType = {
+  queryID?: string | null
+}
+
+export const AlgoliaQueryContext = React.createContext<AlgoliaQueryContextType>({})
+
+export function useAlgoliaQuery() {
+  return useContext(AlgoliaQueryContext)
+}

package/index.ts

@@ -0,0 +1,8 @@
+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 './hooks/useAlgoliaIndexName'
+export * from './hooks/useAlgoliaQueryContext'

package/link/customerGroupIdLink.ts

@@ -0,0 +1,20 @@
+import { ApolloCache, setContext } from '@graphcommerce/graphql'
+import { CustomerDocument } from '@graphcommerce/magento-customer'
+
+declare module '@apollo/client' {
+  interface DefaultContext {
+    cache?: ApolloCache<unknown>
+    headers?: Record<string, string>
+  }
+}
+
+export const customerGroupIdLink = setContext((_, context) => {
+  if (!context.headers) context.headers = {}
+  try {
+    const group_id = context.cache?.readQuery({ query: CustomerDocument })?.customer?.group_id
+    if (group_id) context.headers['x-magento-group-id'] = `${group_id}`
+    return context
+  } catch (error) {
+    return context
+  }
+})

package/mesh/algoliaFacetsToAggregations.ts

@@ -0,0 +1,209 @@
+import type {
+  Aggregation,
+  AggregationOption,
+  AlgoliasearchResponse,
+  CategoryResult,
+  MeshContext,
+} from '@graphcommerce/graphql-mesh'
+import { AttributeList } from './getAttributeList'
+import { GetStoreConfigReturn } from './getStoreConfig'
+
+type AlgoliaFacets = { [facetName: string]: AlgoliaFacetOption }
+type AlgoliaFacetOption = { [facetOption: string]: number }
+
+function categoryMapping(
+  categoryList: CategoryResult | null | undefined,
+  facetList: AlgoliaFacetOption,
+): AggregationOption[] {
+  if (!categoryList?.items) {
+    return []
+  }
+
+  return categoryList?.items
+    ?.map((category) => {
+      const count = category?.id ? facetList[category?.id] : 0
+      return { label: category?.name, value: category?.uid ?? '', count }
+    })
+    .filter((category) => category.count > 0)
+}
+
+function compare(a, b) {
+  const numberA: number = +a[0]
+  const numberB: number = +b[0]
+
+  if (numberA < numberB) {
+    return -1
+  }
+  if (numberA > numberB) {
+    return 1
+  }
+
+  return 0
+}
+
+export function algoliaPricesToPricesAggregations(pricesList: {
+  [key: string]: number
+}): 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)
+}
+
+function assertAlgoliaFacets(facets: any): facets is AlgoliaFacets {
+  return true
+}
+
+/**
+ * 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(
+  algoliaFacets: AlgoliasearchResponse['facets'],
+  attributes: AttributeList,
+  storeConfig: GetStoreConfigReturn,
+  categoryList?: null | CategoryResult,
+  groupId?: number,
+): Aggregation[] {
+  if (!storeConfig?.default_display_currency_code) throw new Error('Currency is required')
+  const aggregations: Aggregation[] = []
+
+  if (!assertAlgoliaFacets(algoliaFacets)) throw Error('these are not facets')
+
+  Object.entries(algoliaFacets).forEach(([facetIndex, facet]) => {
+    let attribute_code = facetIndex
+
+    if (facetIndex.startsWith('categories.level')) return
+    if (facetIndex.startsWith('price')) {
+      attribute_code = 'price'
+    }
+
+    const position = 0
+
+    const label =
+      attributes?.find((attribute) => attribute?.code === attribute_code)?.label ?? attribute_code
+    if (facetIndex === 'categoryIds') {
+      aggregations.push({
+        label,
+        attribute_code: 'category_uid',
+        options: categoryMapping(categoryList, algoliaFacets[facetIndex]),
+        position,
+      })
+    } else if (facetIndex.startsWith('price')) {
+      if (!groupId && facetIndex !== `price.${storeConfig.default_display_currency_code}.default`) {
+        return
+      }
+      if (
+        groupId &&
+        facetIndex !== `price.${storeConfig.default_display_currency_code}.group_${groupId}`
+      ) {
+        return
+      }
+      aggregations.push({
+        label,
+        attribute_code,
+        options: algoliaPricesToPricesAggregations(algoliaFacets[facetIndex]),
+        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,
+      })
+    }
+  })
+
+  return aggregations
+}
+
+let categoryListCache: CategoryResult | null = null
+
+export async function getCategoryList(context: MeshContext) {
+  if (categoryListCache) return categoryListCache
+
+  // context.cache.get('algolia_getCategoryList')
+
+  categoryListCache = await context.m2.Query.categories({
+    args: { filters: {} },
+    selectionSet: /* GraphQL */ `
+      {
+        items {
+          uid
+          name
+          id
+          position
+        }
+      }
+    `,
+    context,
+  })
+
+  return categoryListCache!
+}

package/mesh/algoliaHitToMagentoProduct.ts

@@ -0,0 +1,201 @@
+import type {
+  AlgoliaPrice,
+  AlgoliaProductHitAdditionalProperties,
+  Algoliahit,
+  CurrencyEnum,
+  MeshContext,
+  PriceRange,
+  QueryproductsArgs,
+  RequireFields,
+  ResolverFn,
+  ResolversParentTypes,
+  ResolversTypes,
+} from '@graphcommerce/graphql-mesh'
+// eslint-disable-next-line import/no-extraneous-dependencies
+import { GraphQLResolveInfo } from 'graphql'
+import { GetStoreConfigReturn } from './getStoreConfig'
+
+export function assertAdditional(
+  additional: unknown,
+): additional is AlgoliaProductHitAdditionalProperties {
+  return true
+}
+
+const algoliaTypeToTypename = {
+  bundle: 'BundleProduct',
+  simple: 'SimpleProduct',
+  configurable: 'ConfigurableProduct',
+  downloadable: 'DownloadableProduct',
+  virtual: 'VirtualProduct',
+  grouped: 'GroupedProduct',
+  giftcard: 'GiftCardProduct',
+} as const
+
+function mapPriceRange(
+  price: AlgoliaProductHitAdditionalProperties['price'],
+  storeConfig: GetStoreConfigReturn,
+  customerGroup = 0,
+): PriceRange {
+  if (!storeConfig?.default_display_currency_code) throw new Error('Currency is required')
+
+  const key = storeConfig.default_display_currency_code as keyof AlgoliaPrice
+  const currency = storeConfig.default_display_currency_code as CurrencyEnum
+
+  const maxRegular = price?.[key]?.default_max ?? 0
+  const maxFinal = price?.[key]?.[`group_${customerGroup}_max`] ?? price?.[key]?.default_max ?? 0
+
+  const minRegular = price?.[key]?.default ?? 0
+  const minFinal = price?.[key]?.[`group_${customerGroup}`] ?? price?.[key]?.default
+
+  return {
+    maximum_price: {
+      regular_price: {
+        currency,
+        value: maxRegular,
+      },
+      final_price: {
+        currency,
+        value: maxFinal,
+      },
+      discount: {
+        percent_off:
+          maxRegular !== maxFinal && maxRegular > 0 ? 1 - (maxFinal / maxRegular) * 100 : 0,
+        amount_off: maxRegular - maxFinal,
+      },
+      // fixed_product_taxes
+    },
+    minimum_price: {
+      regular_price: {
+        currency,
+        value: price?.[key]?.default,
+      },
+      final_price: {
+        currency,
+        value: minFinal,
+      },
+      discount: {
+        percent_off:
+          minRegular !== minFinal && minRegular > 0 ? 1 - (minFinal / minRegular) * 100 : 0,
+        amount_off: minRegular - minFinal,
+      },
+      // fixed_product_taxes
+    },
+  }
+}
+
+export function algoliaUrlToUrlKey(url?: string | null, base?: string | null): string | null {
+  if (!url || !base) return null
+  return url.replace(base, '')
+}
+
+/**
+ * For the URL https://configurator.reachdigital.dev/media/catalog/product/cache/d911de87cf9e562637815cc5a14b1b05/1/0/1087_1_3.jpg
+ * Remove /cache/HASH from the URL but only if the url contains media/catalog/product
+ * @param url
+ */
+function getOriginalImage(url?: string | undefined | null) {
+  if (!url || !url.includes('media/catalog/product')) return url
+  return url.replace(/\/cache\/[a-z0-9]+/, '')
+}
+
+export type ProductsItemsItem = NonNullable<
+  Awaited<
+    ReturnType<
+      ResolverFn<
+        ResolversTypes['Products'],
+        ResolversParentTypes['Query'],
+        MeshContext,
+        RequireFields<QueryproductsArgs, 'pageSize' | 'currentPage'>
+      >
+    >
+  >['items']
+>[number] & {
+  __typename: (typeof algoliaTypeToTypename)[keyof typeof algoliaTypeToTypename]
+}
+
+/**
+ * Mapping function to map Algolia hit to Magento product.
+ *
+ * You can create a FunctionPlugin to modify the behavior of this function or implement brand specific code.
+ */
+export function algoliaHitToMagentoProduct(
+  hit: Algoliahit,
+  storeConfig: GetStoreConfigReturn,
+  customerGroup: number,
+): ProductsItemsItem | null {
+  const { objectID, additionalProperties } = hit
+  if (!assertAdditional(additionalProperties)) return null
+
+  const {
+    sku,
+    created_at,
+    image_url,
+    is_stock,
+
+    price,
+    thumbnail_url,
+    type_id,
+    url,
+
+    // not used
+    ordered_qty,
+    visibility_catalog,
+    visibility_search,
+    rating_summary,
+
+    // The rest will be spread into the product
+    ...rest
+  } = additionalProperties
+
+  // Some custom attributes are returned as array while they need to be a string. Flatten those arrays
+  const flattenedCustomAttributes = {}
+  for (const [key, value] of Object.entries(rest)) {
+    if (value !== null && Array.isArray(value) && value?.length > 0) {
+      flattenedCustomAttributes[key] = value.toString()
+      delete rest[key]
+    }
+  }
+
+  return {
+    redirect_code: 0,
+    __typename: algoliaTypeToTypename[type_id as keyof typeof algoliaTypeToTypename],
+    uid: btoa(objectID),
+    sku: Array.isArray(sku) ? sku[0] : `${sku}`,
+    price_range: mapPriceRange(price, storeConfig, customerGroup),
+    created_at: created_at ? new Date(created_at).toISOString() : null,
+    stock_status: is_stock ? 'IN_STOCK' : 'OUT_OF_STOCK',
+    review_count: 0,
+    rating_summary: Number(rating_summary),
+    reviews: { items: [], page_info: {} },
+    // canonical_url: null,
+    // categories: [],
+    // country_of_manufacture: null,
+    // crosssell_products: [],
+    // custom_attributesV2: null,
+    // description: null,
+    // gift_message_available: null,
+    image: { url: getOriginalImage(image_url) },
+    // media_gallery: [],
+    // meta_keyword: null,
+    // meta_title: null,
+    // new_from_date: null,
+    // new_to_date: null,
+    // only_x_left_in_stock: null,
+    // 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_suffix: storeConfig?.product_url_suffix,
+    ...rest,
+    ...flattenedCustomAttributes,
+  }
+}

package/mesh/getAlgoliaSettings.ts

@@ -0,0 +1,21 @@
+import type { AlgoliasettingsResponse, MeshContext } from '@graphcommerce/graphql-mesh'
+import { getIndexName } from './getIndexName'
+
+let settingsCache: AlgoliasettingsResponse | null = null
+
+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,
+    })
+  }
+
+  if (!settingsCache) throw Error('No settings found')
+  return settingsCache
+}

package/mesh/getAttributeList.ts

@@ -0,0 +1,31 @@
+import type { MeshContext } from '@graphcommerce/graphql-mesh'
+// eslint-disable-next-line import/no-extraneous-dependencies
+import { filterNonNullableKeys } from '@graphcommerce/next-ui/RenderType/filterNonNullableKeys'
+
+export type AttributeList = { label: string; code: string }[]
+
+let attributeListCache: AttributeList | null = null
+
+export async function getAttributeList(context: MeshContext): Promise<AttributeList> {
+  if (attributeListCache) return attributeListCache
+
+  if (
+    import.meta.graphCommerce.magentoVersion >= 247 &&
+    'attributesList' in context.m2.Query &&
+    typeof context.m2.Query.attributesList === 'function'
+  ) {
+    const items = (await context.m2.Query.attributesList({
+      args: {
+        entityType: 'CATALOG_PRODUCT',
+        filters: {},
+      },
+      selectionSet: `{ items{ code label } }`,
+      context,
+    }).then((res) => res?.items)) as { label?: string; code: string }[]
+    attributeListCache = filterNonNullableKeys(items, ['label'])
+
+    return filterNonNullableKeys(items, ['label'])
+  }
+
+  return []
+}

package/mesh/getGroupId.ts

@@ -0,0 +1,7 @@
+import type { MeshContext } from '@graphcommerce/graphql-mesh'
+
+export function getGroupId(context: MeshContext): number {
+  const { headers } = context as MeshContext & { headers?: Record<string, string | undefined> }
+  if (!headers?.authorization) return 0
+  return parseInt(headers?.['x-magento-group-id'] || '0', 10)
+}

package/mesh/getIndexName.ts

@@ -0,0 +1,11 @@
+import type { MeshContext } from '@graphcommerce/graphql-mesh'
+import { storefrontConfigDefault } from '@graphcommerce/next-ui'
+
+function getStoreHeader(context: MeshContext) {
+  return (context as MeshContext & { headers: Record<string, string | undefined> }).headers.store
+}
+
+export function getIndexName(context: MeshContext) {
+  const storeCode = getStoreHeader(context) ?? storefrontConfigDefault().magentoStoreCode
+  return `${import.meta.graphCommerce.algolia.indexNamePrefix}${storeCode}_products`
+}

package/mesh/getSearchResults.ts

@@ -0,0 +1,35 @@
+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'
+
+export async function getSearchResults(
+  args: QueryproductsArgs,
+  context: MeshContext,
+  info: GraphQLResolveInfo,
+) {
+  return context.algolia.Query.algolia_searchSingleIndex({
+    args: {
+      indexName: await getSortedIndex(context, getAlgoliaSettings(context), args.sort),
+      input: await getSearchResultsInput(args, context),
+    },
+    selectionSet: /* GraphQL */ `
+      {
+        nbPages
+        hitsPerPage
+        page
+        queryID
+        nbHits
+        hits {
+          __typename
+          objectID
+          additionalProperties
+        }
+        facets
+      }
+    `,
+    context,
+    info,
+  })
+}