@graphcommerce/algolia-products 9.0.0-canary.100

package/mesh/getSearchResultsInput.ts

@@ -0,0 +1,30 @@
+import type {
+  AlgoliasearchParamsObject_Input,
+  MeshContext,
+  QueryproductsArgs,
+} from '@graphcommerce/graphql-mesh'
+import { getStoreConfig } from './getStoreConfig'
+import {
+  productFilterInputToAlgoliaFacetFiltersInput,
+  productFilterInputToAlgoliaNumericFiltersInput,
+} from './productFilterInputToAlgoliafacetFiltersInput'
+
+export async function getSearchResultsInput(
+  args: QueryproductsArgs,
+  context: MeshContext,
+): Promise<AlgoliasearchParamsObject_Input> {
+  const { engine, ...filters } = args.filter ?? {}
+
+  return {
+    query: args.search ?? '',
+    facets: ['*'],
+    hitsPerPage: args.pageSize ? args.pageSize : 10,
+    page: args.currentPage ? args.currentPage - 1 : 0,
+    facetFilters: productFilterInputToAlgoliaFacetFiltersInput(filters),
+    numericFilters: await productFilterInputToAlgoliaNumericFiltersInput(
+      getStoreConfig(context),
+      filters,
+    ),
+    analytics: true,
+  }
+}

package/mesh/getSearchSuggestions.ts

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

package/mesh/getSearchSuggestionsInput.ts

@@ -0,0 +1,21 @@
+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,
+  context: MeshContext,
+): Promise<Queryalgolia_searchSingleIndexArgs['input']> {
+  return {
+    query: search,
+    hitsPerPage: 5,
+  }
+}

package/mesh/getStoreConfig.ts

@@ -0,0 +1,33 @@
+import { MeshContext, Maybe, StoreConfig } from '@graphcommerce/graphql-mesh'
+
+export type GetStoreConfigReturn =
+  | Maybe<
+      Pick<
+        StoreConfig,
+        | 'root_category_uid'
+        | 'default_display_currency_code'
+        | 'base_link_url'
+        | 'product_url_suffix'
+      >
+    >
+  | undefined
+
+let configCache: Promise<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
+        }
+      `,
+    })
+  }
+  return configCache
+}

package/mesh/productFilterInputToAlgoliafacetFiltersInput.ts

@@ -0,0 +1,81 @@
+import type {
+  ProductAttributeFilterInput,
+  AlgolianumericFilters_Input,
+} from '@graphcommerce/graphql-mesh'
+import {
+  isFilterTypeEqual,
+  isFilterTypeRange,
+  isFilterTypeMatch,
+} from '@graphcommerce/magento-product'
+import { InputMaybe } from '@graphcommerce/next-config'
+import { GetStoreConfigReturn } from './getStoreConfig'
+import { nonNullable } from './utils'
+
+/**
+ * Map filters recieved from arguments to algolia facetfilter format
+ *
+ * https://www.algolia.com/doc/api-reference/api-parameters/facetFilters/
+ */
+export function productFilterInputToAlgoliaFacetFiltersInput(
+  filters?: InputMaybe<ProductAttributeFilterInput>,
+) {
+  const filterArray: (string | string[])[] = []
+  if (!filters) {
+    return []
+  }
+
+  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 (value.eq) {
+        if (key === 'category_uid') filterArray.push(`categoryIds:${atob(value.eq)}`)
+        else filterArray.push(`${key}:${value.eq}`)
+      }
+    }
+
+    if (isFilterTypeMatch(value)) {
+      throw Error('Match filters are not supported')
+    }
+  })
+
+  return filterArray
+}
+
+/**
+ * Map filters recieved from arguments to algolia facetfilter format
+ *
+ * https://www.algolia.com/doc/api-reference/api-parameters/numericFilters/#examples
+ */
+export async function productFilterInputToAlgoliaNumericFiltersInput(
+  storeConfig: Promise<GetStoreConfigReturn>,
+  filters?: InputMaybe<ProductAttributeFilterInput>,
+) {
+  if (!filters) return []
+
+  const filterArray: AlgolianumericFilters_Input[] = []
+
+  for (const [key, value] of Object.entries(filters)) {
+    if (isFilterTypeRange(value)) {
+      if (key === 'price') {
+        // eslint-disable-next-line no-await-in-loop
+        const currencyCode = (await storeConfig)?.default_display_currency_code
+        filterArray.push(
+          { numericFilters_Input: { String: `${key}.${currencyCode}.default >= ${value.from}` } },
+          { numericFilters_Input: { String: `${key}.${currencyCode}.default <= ${value.to}` } },
+        )
+      } else {
+        filterArray.push(
+          { numericFilters_Input: { String: `${key} >= ${value.from}` } },
+          { numericFilters_Input: { String: `${key} <= ${value.to}` } },
+        )
+      }
+    }
+  }
+
+  return filterArray
+}

package/mesh/resolvers.ts

@@ -0,0 +1,126 @@
+import {
+  AlgoliasearchResponse,
+  hasSelectionSetPath,
+  type Resolvers,
+} from '@graphcommerce/graphql-mesh'
+import type { GraphQLError, GraphQLResolveInfo } from 'graphql'
+import { algoliaFacetsToAggregations, getCategoryList } from './algoliaFacetsToAggregations'
+import { algoliaHitToMagentoProduct, ProductsItemsItem } from './algoliaHitToMagentoProduct'
+import { getAlgoliaSettings } from './getAlgoliaSettings'
+import { getAttributeList } from './getAttributeList'
+import { getGroupId } from './getGroupId'
+import { getSearchResults } from './getSearchResults'
+import { getSearchSuggestions } from './getSearchSuggestions'
+import { isSuggestionsEnabled } from './getSearchSuggestionsInput'
+import { getStoreConfig } from './getStoreConfig'
+import { sortingOptions } from './sortOptions'
+
+function isAlgoliaResponse<T extends object>(
+  root: T,
+): root is T & { algoliaSearchResults: AlgoliasearchResponse } {
+  return 'algoliaSearchResults' in root
+}
+
+function hasSearchRequest(info: GraphQLResolveInfo) {
+  const hasItems = hasSelectionSetPath(info.operation.selectionSet, 'products.items')
+  const hasAggregations = hasSelectionSetPath(info.operation.selectionSet, 'products.aggregations')
+  const hasPageInfo = hasSelectionSetPath(info.operation.selectionSet, 'products.page_info')
+  const hasTotalCount = hasSelectionSetPath(info.operation.selectionSet, 'products.total_count')
+  const hasSortFields = hasSelectionSetPath(info.operation.selectionSet, 'products.sort_fields')
+
+  return Boolean(hasItems || hasAggregations || hasPageInfo || hasTotalCount || hasSortFields)
+}
+
+function hasSuggestionsRequest(info: GraphQLResolveInfo) {
+  return hasSelectionSetPath(info.operation.selectionSet, 'products.suggestions')
+}
+
+function isGraphQLError(err: unknown): err is GraphQLError {
+  return !!(err as GraphQLError)?.message
+}
+
+export const resolvers: Resolvers = {
+  Products: {
+    aggregations: async (root, _args, context) => {
+      if (!isAlgoliaResponse(root)) return root.aggregations ?? null
+
+      return algoliaFacetsToAggregations(
+        root.algoliaSearchResults?.facets,
+        await getAttributeList(context),
+        await getStoreConfig(context),
+        await getCategoryList(context),
+        getGroupId(context),
+      )
+    },
+
+    sort_fields: async (root, _args, context) => {
+      if (isAlgoliaResponse(root)) {
+        return {
+          default: 'relevance',
+          options: Object.values(
+            sortingOptions(
+              await getAlgoliaSettings(context),
+              await getAttributeList(context),
+              context,
+            ),
+          ),
+        }
+      }
+      return root.sort_fields ?? null
+    },
+
+    total_count: (root) => {
+      if (!isAlgoliaResponse(root)) return root.total_count ?? null
+      return root.algoliaSearchResults?.nbHits
+    },
+
+    page_info: (root) => {
+      if (!isAlgoliaResponse(root)) return root.page_info ?? null
+      return {
+        current_page: root.algoliaSearchResults.page + 1,
+        page_size: root.algoliaSearchResults.hitsPerPage,
+        total_pages: root.algoliaSearchResults.nbPages,
+      }
+    },
+
+    items: async (root, args, context) => {
+      if (!isAlgoliaResponse(root)) return root.items ?? null
+
+      const items: (ProductsItemsItem | null)[] = []
+
+      const config = await getStoreConfig(context)
+      for (const hit of root.algoliaSearchResults.hits) {
+        if (hit?.objectID) {
+          const product = algoliaHitToMagentoProduct(hit, config, getGroupId(context))
+          items.push(product)
+        }
+      }
+
+      return items
+    },
+  },
+  Query: {
+    products: async (root, args, context, info) => {
+      const isAgolia = (args.filter?.engine?.in ?? [args.filter?.engine?.eq])[0] === 'algolia'
+
+      if (!isAgolia) return context.m2.Query.products({ root, args, context, info })
+
+      const searchSuggestsions =
+        isSuggestionsEnabled() &&
+        hasSuggestionsRequest(info) &&
+        args.search &&
+        getSearchSuggestions(args.search, context)
+
+      const searchResults = hasSearchRequest(info) ? getSearchResults(args, context, info) : null
+
+      if (isGraphQLError(await searchResults))
+        return context.m2.Query.products({ root, args, context, info })
+
+      return {
+        algoliaSearchResults: await searchResults,
+        suggestions: (await searchSuggestsions) || null,
+        algolia_queryID: (await searchResults)?.queryID,
+      }
+    },
+  },
+}

package/mesh/sortOptions.ts

@@ -0,0 +1,76 @@
+import {
+  AlgoliasettingsResponse,
+  MeshContext,
+  ProductAttributeSortInput,
+  SortEnum,
+  SortField,
+} from '@graphcommerce/graphql-mesh'
+import { nonNullable } from '@graphcommerce/magento-customer'
+import { AttributeList } from './getAttributeList'
+import { getIndexName } from './getIndexName'
+
+export type SortingOptions = Record<string, SortField & { dirs: SortEnum[] }>
+
+export async function sortingOptions(
+  settings: AlgoliasettingsResponse,
+  attributeList: AttributeList,
+  context: MeshContext,
+): Promise<SortingOptions> {
+  const sortRecord: SortingOptions = {
+    relevance: { label: 'Relevance', value: 'relevance', dirs: ['DESC'] },
+  }
+
+  ;(settings.replicas ?? [])
+    .map((replica) => {
+      if (!replica) return null
+
+      const regex = new RegExp(
+        `virtual\\(${getIndexName(context)}_(?<sortIndex>.*)_(?<dir>[^_]+)\\)`,
+      )
+
+      const res = regex.exec(replica)
+      if (!res) return null
+
+      const { dir, sortIndex } = res.groups ?? {}
+
+      return dir.toUpperCase() === 'DESC'
+        ? { dir: 'DESC' as const, sortIndex }
+        : { dir: 'ASC' as const, sortIndex }
+    })
+    .filter(nonNullable)
+    .forEach((curr) => {
+      let attributeCode = curr.sortIndex
+      if (curr.sortIndex.startsWith('price')) attributeCode = 'price'
+
+      if (!sortRecord[attributeCode]) {
+        sortRecord[attributeCode] = {
+          value: attributeCode,
+          label: attributeList.find((attr) => attr.code === attributeCode)?.label,
+          dirs: [curr.dir],
+        }
+      } else {
+        sortRecord[attributeCode].dirs.push(curr.dir)
+      }
+    }, {})
+
+  return sortRecord
+}
+
+export async function getSortedIndex(
+  context: MeshContext,
+  settings: Promise<AlgoliasettingsResponse>,
+  sortInput: ProductAttributeSortInput | null = {},
+): Promise<string> {
+  const baseIndex = getIndexName(context)
+  // const availableSorting = Object.values(sortOptions)
+  const [attr, dir] = Object.entries(sortInput ?? {}).filter(nonNullable)?.[0] ?? []
+  if (!attr || !dir) return baseIndex
+
+  const found = (await settings).replicas?.find(
+    (replica) =>
+      replica?.startsWith(`virtual(${baseIndex}_${attr}`) &&
+      replica?.endsWith(`${dir?.toLowerCase()})`),
+  )
+
+  return found ? found?.slice(8, -1) : baseIndex
+}

package/mesh/utils.ts

@@ -0,0 +1,3 @@
+export function nonNullable<T>(value: T): value is NonNullable<T> {
+  return value !== null && value !== undefined
+}

package/next-env.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="next" />
+/// <reference types="next/types/global" />
+/// <reference types="next/image-types/global" />
+/// <reference types="@graphcommerce/next-ui/types" />

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@graphcommerce/algolia-products",
+  "homepage": "https://www.graphcommerce.org/",
+  "repository": "github:graphcommerce-org/graphcommerce",
+  "version": "9.0.0-canary.100",
+  "sideEffects": false,
+  "prettier": "@graphcommerce/prettier-config-pwa",
+  "eslintConfig": {
+    "extends": "@graphcommerce/eslint-config-pwa",
+    "parserOptions": {
+      "project": "./tsconfig.json"
+    }
+  },
+  "scripts": {
+    "generate": "tsx scripts/generate-spec.mts"
+  },
+  "peerDependencies": {
+    "@graphcommerce/google-datalayer": "^9.0.0-canary.100",
+    "@graphcommerce/graphql": "^9.0.0-canary.100",
+    "@graphcommerce/graphql-mesh": "^9.0.0-canary.100",
+    "@graphcommerce/magento-customer": "^9.0.0-canary.100",
+    "@graphcommerce/magento-product": "^9.0.0-canary.100",
+    "@graphcommerce/magento-search": "^9.0.0-canary.100",
+    "@graphcommerce/next-config": "^9.0.0-canary.100",
+    "@graphcommerce/next-ui": "^9.0.0-canary.100",
+    "react": "^18.2.0"
+  },
+  "devDependencies": {
+    "graphql": "^16.0.0",
+    "tsx": "^4.16.2"
+  }
+}

package/plugins/GraphQLProviderAlgoliaCustomerGroupId.tsx

@@ -0,0 +1,14 @@
+import { GraphQLProviderProps } from '@graphcommerce/graphql'
+import type { PluginConfig, PluginProps } from '@graphcommerce/next-config'
+import { customerGroupIdLink } from '../link/customerGroupIdLink'
+
+export const config: PluginConfig = {
+  type: 'component',
+  module: '@graphcommerce/graphql',
+  ifConfig: 'algolia.customerGroupPricingEnabled',
+}
+
+export function GraphQLProvider(props: PluginProps<GraphQLProviderProps>) {
+  const { Prev, links = [], ...rest } = props
+  return <Prev {...rest} links={[...links, customerGroupIdLink]} />
+}

package/plugins/ProductListItemsBaseAlgolia.tsx

@@ -0,0 +1,21 @@
+import type { ProductItemsGridProps } from '@graphcommerce/magento-product'
+import type { PluginConfig, PluginProps } from '@graphcommerce/next-config'
+import { useMemo } from 'react'
+import { AlgoliaQueryContext } from '../hooks/useAlgoliaQueryContext'
+
+export const config: PluginConfig = {
+  module: '@graphcommerce/magento-product',
+  type: 'component',
+}
+
+export function ProductListItemsBase(props: PluginProps<ProductItemsGridProps>) {
+  const { Prev, ...rest } = props
+
+  return (
+    <AlgoliaQueryContext.Provider
+      value={useMemo(() => ({ queryID: rest.algolia_queryID }), [rest.algolia_queryID])}
+    >
+      <Prev {...rest} />
+    </AlgoliaQueryContext.Provider>
+  )
+}

package/plugins/magentoProductApplyAlgoliaEngine.ts

@@ -0,0 +1,25 @@
+import type {
+  useProductListApplyCategoryDefaults as useProductListApplyDefaults,
+  productListApplyCategoryDefaults as productListApplyDefaults,
+  categoryDefaultsToProductListFilters as defaultsToProductListFilters,
+} from '@graphcommerce/magento-product'
+import { FunctionPlugin, PluginConfig } from '@graphcommerce/next-config'
+import { applyEngineVariables } from '../utils/applyEngineVariable'
+
+export const config: PluginConfig = {
+  module: '@graphcommerce/magento-product',
+  type: 'function',
+  ifConfig: 'algolia.catalogEnabled',
+}
+
+export const useProductListApplyCategoryDefaults: FunctionPlugin<
+  typeof useProductListApplyDefaults
+> = (prev, params, category) => applyEngineVariables(prev(params, category))
+
+export const productListApplyCategoryDefaults: FunctionPlugin<
+  typeof productListApplyDefaults
+> = async (prev, params, conf, category) => applyEngineVariables(await prev(params, conf, category))
+
+export const categoryDefaultsToProductListFilters: FunctionPlugin<
+  typeof defaultsToProductListFilters
+> = (prev, variables) => applyEngineVariables(prev(variables))

package/plugins/magentoSearchApplyAlgoliaEngine.ts

@@ -0,0 +1,26 @@
+import type {
+  useProductListApplySearchDefaults as useProductListApplyDefaults,
+  productListApplySearchDefaults as productListApplyDefaults,
+  searchDefaultsToProductListFilters as defaultsToProductListFilters,
+} from '@graphcommerce/magento-search'
+import { FunctionPlugin, PluginConfig } from '@graphcommerce/next-config'
+import { applyEngineVariables } from '../utils/applyEngineVariable'
+
+export const config: PluginConfig = {
+  module: '@graphcommerce/magento-search',
+  type: 'function',
+}
+
+export const useProductListApplySearchDefaults: FunctionPlugin<
+  typeof useProductListApplyDefaults
+> = (prev, params) => applyEngineVariables(prev(params))
+
+export const productListApplySearchDefaults: FunctionPlugin<typeof productListApplyDefaults> = (
+  prev,
+  params,
+  conf,
+) => applyEngineVariables(prev(params, conf))
+
+export const searchDefaultsToProductListFilters: FunctionPlugin<
+  typeof defaultsToProductListFilters
+> = (prev, variables) => applyEngineVariables(prev(variables))

package/plugins/meshConfigAlgolia.ts

@@ -0,0 +1,66 @@
+import type { meshConfig as meshConfigBase } from '@graphcommerce/graphql-mesh/meshConfig'
+import type { FunctionPlugin, PluginConfig } from '@graphcommerce/next-config'
+
+export const config: PluginConfig = {
+  module: '@graphcommerce/graphql-mesh/meshConfig',
+  type: 'function',
+}
+
+export const meshConfig: FunctionPlugin<typeof meshConfigBase> = (
+  prev,
+  baseConfig,
+  graphCommerceConfig,
+) =>
+  prev(
+    {
+      ...baseConfig,
+      sources: [
+        ...baseConfig.sources,
+        {
+          name: 'algolia',
+          handler: {
+            openapi: {
+              endpoint: `https://${graphCommerceConfig.algolia.applicationId}.algolia.net/`,
+              source: '@graphcommerce/algolia-products/algolia-spec.yaml',
+              ignoreErrorResponses: true,
+              schemaHeaders: {
+                'X-Algolia-Application-Id': graphCommerceConfig.algolia.applicationId,
+                'X-Algolia-API-Key': graphCommerceConfig.algolia.searchOnlyApiKey,
+              },
+              operationHeaders: {
+                'X-Algolia-Application-Id': graphCommerceConfig.algolia.applicationId,
+                'X-Algolia-API-Key': graphCommerceConfig.algolia.searchOnlyApiKey,
+              },
+              selectQueryOrMutationField: [
+                { type: 'Query', fieldName: 'searchSingleIndex' },
+                { type: 'Query', fieldName: 'searchForFacetValues' },
+              ],
+            },
+          },
+          transforms: [
+            {
+              prefix: {
+                value: 'algolia_',
+                includeRootOperations: true,
+                includeTypes: false,
+                mode: 'bare',
+              },
+            },
+            {
+              prefix: {
+                value: 'Algolia',
+                includeRootOperations: false,
+                includeTypes: true,
+                mode: 'bare',
+              },
+            },
+          ],
+        },
+      ],
+      additionalResolvers: [
+        ...(baseConfig.additionalResolvers ?? []),
+        '@graphcommerce/algolia-products/mesh/resolvers.ts',
+      ],
+    },
+    graphCommerceConfig,
+  )

package/schema/AlgoliaSchema.graphqls

@@ -0,0 +1,60 @@
+type AlgoliaPriceValue {
+  default: Float
+  default_formatted: String
+  special_from_date: String
+  special_to_date: String
+  default_max: Float
+  default_original_formatted: String
+}
+
+type AlgoliaPrice {
+  SOME_CURRENCY: AlgoliaPriceValue
+}
+
+scalar AlgoliaSku
+
+type AlgoliaProductHitAdditionalProperties {
+  name: String
+  sku: AlgoliaSku
+  price: AlgoliaPrice
+
+  # categories
+  # categories_without_path
+  # categoryIds
+  is_stock: Int
+  ordered_qty: Int
+  created_at: String
+  url: String
+  visibility_search: Int
+  visibility_catalog: Int
+  type_id: String
+  rating_summary: String
+  thumbnail_url: String
+  image_url: String
+}
+
+type Algoliahit {
+  additionalProperties: AlgoliaProductHitAdditionalProperties
+}
+
+input ProductAttributeFilterInput {
+  """
+  When set to true, the query is passed to Algolia.
+
+  This is faster, but is only recommended for search and category pages as the data could be out of date and many fields of a product aren't supported.
+  """
+  engine: FilterEqualTypeInput
+}
+
+input CategoryFilterInput {
+  """
+  When set to true, the categories query is passed to Algolia
+
+  This is faster, but is only recommended for search and category pages as the data could be out of date and many fields of a product aren't supported.
+  """
+  engine: FilterEqualTypeInput
+}
+
+type Products {
+  algolia_queryID: String
+}

package/schema/CustomerAlgoliaGroupId.graphqls

@@ -0,0 +1,9 @@
+type Customer {
+  group_id: Int
+    @resolveTo(
+      sourceName: "m2rest"
+      sourceTypeName: "Query"
+      sourceFieldName: "m2rest_GetV1CustomersMe"
+      result: "group_id"
+    )
+}