@graphcommerce/algolia-recommend 9.0.0-canary.84

package/mesh/createProductMapper.ts

@@ -0,0 +1,19 @@
+import { algoliaHitToMagentoProduct } from '@graphcommerce/algolia-products'
+import { getGroupId } from '@graphcommerce/algolia-products/mesh/getGroupId'
+import { getStoreConfig } from '@graphcommerce/algolia-products/mesh/getStoreConfig'
+import type {
+  MeshContext,
+  AlgoliarecommendationsHit,
+  Algoliahit,
+} from '@graphcommerce/graphql-mesh'
+
+export async function createProductMapper(context: MeshContext) {
+  const storeConfig = await getStoreConfig(context)
+  const groupId = getGroupId(context)
+
+  const isAlgoliaRecommendHit = (hit: AlgoliarecommendationsHit | Algoliahit): hit is Algoliahit =>
+    '__typename' in hit && hit.__typename === 'AlgoliarecommendHit'
+
+  return (hit: AlgoliarecommendationsHit) =>
+    isAlgoliaRecommendHit(hit) ? algoliaHitToMagentoProduct(hit, storeConfig, groupId) : null
+}

package/mesh/createValueFacetMapper.ts

@@ -0,0 +1,13 @@
+import type {
+  AlgoliarecommendationsHit,
+  AlgoliatrendingFacetHit,
+  TrendingFacetValue,
+} from '@graphcommerce/graphql-mesh'
+
+export function createFacetValueMapper() {
+  const isAlgoliaRecommendHit = (hit: AlgoliarecommendationsHit): hit is AlgoliatrendingFacetHit =>
+    !!hit && '__typename' in hit && hit.__typename === 'AlgoliatrendingFacetHit'
+
+  return (hit: AlgoliarecommendationsHit): TrendingFacetValue | null =>
+    isAlgoliaRecommendHit(hit) ? hit : null
+}

package/mesh/getRecommendationArgs.ts

@@ -0,0 +1,49 @@
+import { getSearchResultsInput } from '@graphcommerce/algolia-products'
+import {
+  QueryproductsArgs,
+  MeshContext,
+  AlgoliasearchParamsObject_Input,
+  AlgoliaLookingSimilarInput,
+} from '@graphcommerce/graphql-mesh'
+
+export async function getRecommendationQueryInput(
+  args: QueryproductsArgs,
+  context: MeshContext,
+): Promise<AlgoliasearchParamsObject_Input> {
+  const queryParameters = await getSearchResultsInput(args, context)
+
+  if (queryParameters?.facets) delete queryParameters.facets
+  if (queryParameters?.hitsPerPage) delete queryParameters.hitsPerPage
+  if (queryParameters?.page || queryParameters?.page === 0) {
+    delete queryParameters.page
+  }
+
+  return queryParameters
+}
+
+export async function getRecommendationsArgs(
+  root: { uid?: string },
+  args: { input?: AlgoliaLookingSimilarInput | null },
+  context: MeshContext,
+) {
+  const { fallback, filter, maxRecommendations = 8, search, threshold = 75 } = args.input ?? {}
+
+  return {
+    objectID: atob(root.uid ?? ''),
+    threshold,
+    maxRecommendations,
+    queryParameters: await getRecommendationQueryInput(
+      { filter, pageSize: maxRecommendations, search },
+      context,
+    ),
+    fallbackParameters: await getRecommendationQueryInput(
+      {
+        filter: fallback?.filter,
+        pageSize: maxRecommendations,
+        search: fallback?.search,
+        sort: fallback?.sort,
+      },
+      context,
+    ),
+  }
+}

package/mesh/getRecommendations.ts

@@ -0,0 +1,81 @@
+import { getIndexName } from '@graphcommerce/algolia-products/mesh/getIndexName'
+import type {
+  AlgoliarecommendationsRequest_Input,
+  MeshContext,
+  AlgoliarecommendationsHit,
+} from '@graphcommerce/graphql-mesh'
+import { nonNullable } from '@graphcommerce/next-ui'
+import type { GraphQLResolveInfo } from 'graphql'
+import type { Simplify } from 'type-fest'
+
+const inputToModel = {
+  Trending_items_Input: 'trending_items' as const,
+  Trending_facet_values_Input: 'trending_facets' as const,
+  Frequently_bought_together_Input: 'bought_together' as const,
+  Looking_similar_Input: 'looking_similar' as const,
+  Related_products_Input: 'related_products' as const,
+}
+function isAlgoliaResponse<T extends object>(root: T): root is T & { uid: string } {
+  return 'uid' in root
+}
+function argsFromKeysInput(keys, args, context) {
+  const body = keys
+    .map(
+      (key) =>
+        ({
+          [key.keyInput]: {
+            model: inputToModel[key.keyInput as string],
+            indexName: getIndexName(context),
+
+            ...args,
+            objectID: key.objectId,
+          },
+        }) as unknown as AlgoliarecommendationsRequest_Input,
+    )
+    .filter(nonNullable)
+
+  const returnObject = { input: { requests: body } }
+
+  return returnObject
+}
+export async function getRecommendations<
+  K extends keyof AlgoliarecommendationsRequest_Input,
+  Input extends AlgoliarecommendationsRequest_Input[K],
+  R,
+>(
+  root: object,
+  keyInput: K,
+  args: Simplify<Omit<NonNullable<Input>, 'indexName' | 'model'>>,
+  context: MeshContext,
+  info: GraphQLResolveInfo,
+  mapper: (hit: AlgoliarecommendationsHit) => R,
+) {
+  if (!isAlgoliaResponse(root)) {
+    return []
+  }
+  return (
+    (await context.algoliaRecommend.Query.algolia_getRecommendations({
+      key: { keyInput, objectId: atob(root.uid) },
+      argsFromKeys: (keys) => argsFromKeysInput(keys, args, context),
+      valuesFromResults: (res, keys) =>
+        keys
+          .map((_key, index) => res?.results[index])
+          .map((r) => r?.hits.map((hit) => hit && mapper(hit)).filter(nonNullable)) ?? null,
+      selectionSet: /* GraphQL */ `
+        {
+          results {
+            nbHits
+            hits {
+              ... on AlgoliarecommendHit {
+                objectID
+                additionalProperties
+              }
+            }
+          }
+        }
+      `,
+      context,
+      info,
+    })) ?? null
+  )
+}

package/mesh/resolvers.ts

@@ -0,0 +1,239 @@
+/* eslint-disable @typescript-eslint/require-await */
+import fragments from '@graphcommerce/graphql/generated/fragments.json'
+import type {
+  AlgoliaLookingSimilarInput,
+  AlgoliaRelatedProductsInput,
+  MeshContext,
+  ProductInterfaceResolvers,
+  ResolverFn,
+  Resolvers,
+  ResolversParentTypes,
+  ResolversTypes,
+} from '@graphcommerce/graphql-mesh'
+import {
+  GraphCommerceAlgoliaRecommendationLocation,
+  InputMaybe,
+  Maybe,
+} from '@graphcommerce/next-config'
+import { createProductMapper } from './createProductMapper'
+import { createFacetValueMapper } from './createValueFacetMapper'
+import { getRecommendationsArgs } from './getRecommendationArgs'
+import { getRecommendations } from './getRecommendations'
+
+type ProductTypes = NonNullable<Awaited<ReturnType<ProductInterfaceResolvers['__resolveType']>>>
+const productInterfaceTypes = fragments.possibleTypes.ProductInterface as ProductTypes[]
+
+const resolvers: Resolvers = {
+  Query: {
+    trendingProducts: async (root, args, context, info) => {
+      const { facetName, facetValue } = args.input
+      const { threshold, fallbackParameters, maxRecommendations, queryParameters } =
+        await getRecommendationsArgs(root, args, context)
+      return getRecommendations(
+        root,
+        'Trending_items_Input',
+        {
+          threshold,
+          facetName,
+          facetValue,
+          fallbackParameters,
+          maxRecommendations,
+          queryParameters,
+        },
+        context,
+        info,
+        await createProductMapper(context),
+      )
+    },
+    trendingFacetValues: async (root, args, context, info) => {
+      const { threshold, fallbackParameters, maxRecommendations, queryParameters } =
+        await getRecommendationsArgs(root, args, context)
+      return getRecommendations(
+        root,
+        'Trending_facet_values_Input',
+        {
+          facetName: args.input.facetName,
+          threshold,
+          fallbackParameters,
+          maxRecommendations,
+          queryParameters,
+        },
+        context,
+        info,
+        createFacetValueMapper(),
+      )
+    },
+  },
+}
+
+function isEnabled(location: InputMaybe<GraphCommerceAlgoliaRecommendationLocation> | undefined) {
+  return location && location !== 'DISABLED'
+}
+
+function enumToLocation(
+  location: InputMaybe<GraphCommerceAlgoliaRecommendationLocation> | undefined,
+) {
+  if (!isEnabled(location)) throw Error('Check for isEnabled before calling this function')
+  if (location === 'CROSSSELL_PRODUCTS') return 'crosssell_products' as const
+  if (location === 'UPSELL_PRODUCTS') return 'upsell_products' as const
+  return 'related_products' as const
+}
+
+type ProductResolver = ResolverFn<
+  Maybe<Array<Maybe<ResolversTypes['ProductInterface']>>>,
+  ResolversParentTypes['ProductInterface'],
+  MeshContext,
+  Record<string, never>
+>
+
+if (isEnabled(import.meta.graphCommerce.algolia.relatedProducts)) {
+  const resolve: ProductResolver = async (root, args, context, info) => {
+    const { objectID, threshold, fallbackParameters, maxRecommendations, queryParameters } =
+      await getRecommendationsArgs(root, args, context)
+
+    return getRecommendations(
+      root,
+      'Related_products_Input',
+      { objectID, threshold, fallbackParameters, maxRecommendations, queryParameters },
+      context,
+      info,
+      await createProductMapper(context),
+    )
+  }
+
+  productInterfaceTypes.forEach((productType) => {
+    if (!resolvers[productType]) resolvers[productType] = {}
+    resolvers[productType][enumToLocation(import.meta.graphCommerce.algolia.relatedProducts)] = {
+      selectionSet: `{ uid }`,
+      resolve,
+    }
+  })
+}
+
+if (isEnabled(import.meta.graphCommerce.algolia.lookingSimilar)) {
+  const resolve: ProductResolver = async (root, args, context, info) => {
+    const { objectID, threshold, fallbackParameters, maxRecommendations, queryParameters } =
+      await getRecommendationsArgs(root, args, context)
+    return getRecommendations(
+      root,
+      'Looking_similar_Input',
+      { objectID, threshold, fallbackParameters, maxRecommendations, queryParameters },
+      context,
+      info,
+      await createProductMapper(context),
+    )
+  }
+
+  productInterfaceTypes.forEach((productType) => {
+    if (!resolvers[productType]) resolvers[productType] = {}
+    resolvers[productType][enumToLocation(import.meta.graphCommerce.algolia.lookingSimilar)] = {
+      selectionSet: `{ uid }`,
+      resolve,
+    }
+  })
+}
+
+if (isEnabled(import.meta.graphCommerce.algolia.frequentlyBoughtTogether)) {
+  const resolver: ProductResolver = async (root, args, context, info) => {
+    const { objectID, threshold, maxRecommendations, queryParameters } =
+      await getRecommendationsArgs(root, args, context)
+
+    return getRecommendations(
+      root,
+      'Frequently_bought_together_Input',
+      { objectID, threshold, maxRecommendations, queryParameters },
+      context,
+      info,
+      await createProductMapper(context),
+    )
+  }
+
+  productInterfaceTypes.forEach((productType) => {
+    if (!resolvers[productType]) resolvers[productType] = {}
+    resolvers[productType][
+      enumToLocation(import.meta.graphCommerce.algolia.frequentlyBoughtTogether)
+    ] = resolver
+  })
+}
+
+const similar: ResolverFn<
+  Maybe<Array<Maybe<ResolversTypes['ProductInterface']>>>,
+  ResolversParentTypes['ProductInterface'],
+  MeshContext,
+  { input?: AlgoliaLookingSimilarInput | null }
+> = async (root, args, context, info) => {
+  const { objectID, threshold, fallbackParameters, maxRecommendations, queryParameters } =
+    await getRecommendationsArgs(root, args, context)
+
+  return getRecommendations(
+    root,
+    'Looking_similar_Input',
+    { objectID, threshold, fallbackParameters, maxRecommendations, queryParameters },
+    context,
+    info,
+    await createProductMapper(context),
+  )
+}
+
+const related: ResolverFn<
+  Maybe<Array<Maybe<ResolversTypes['ProductInterface']>>>,
+  ResolversParentTypes['ProductInterface'],
+  MeshContext,
+  { input?: AlgoliaRelatedProductsInput | null }
+> = async (root, args, context, info) => {
+  const { objectID, threshold, maxRecommendations, queryParameters } = await getRecommendationsArgs(
+    root,
+    args,
+    context,
+  )
+  return getRecommendations(
+    root,
+    'Related_products_Input',
+    {
+      objectID,
+      threshold,
+      // fallbackParameters,
+      maxRecommendations,
+      queryParameters,
+    },
+    context,
+    info,
+    await createProductMapper(context),
+  )
+}
+
+const together: ResolverFn<
+  Maybe<Array<Maybe<ResolversTypes['ProductInterface']>>>,
+  ResolversParentTypes['ProductInterface'],
+  MeshContext,
+  { input?: AlgoliaRelatedProductsInput | null }
+> = async (root, args, context, info) => {
+  const { objectID, threshold, maxRecommendations, queryParameters } = await getRecommendationsArgs(
+    root,
+    args,
+    context,
+  )
+  return getRecommendations(
+    root,
+    'Frequently_bought_together_Input',
+    { objectID, threshold, maxRecommendations, queryParameters },
+    context,
+    info,
+    await createProductMapper(context),
+  )
+}
+
+productInterfaceTypes.forEach((productType) => {
+  if (!resolvers[productType]) resolvers[productType] = {}
+
+  resolvers[productType].algolia_looking_similar = { selectionSet: `{ uid }`, resolve: similar }
+
+  resolvers[productType].algolia_related_products = { selectionSet: `{ uid }`, resolve: related }
+
+  resolvers[productType].algolia_frequently_bought_together = {
+    selectionSet: `{ uid }`,
+    resolve: together,
+  }
+})
+
+export default resolvers

package/package.json

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

package/plugins/meshConfigAlgoliaRecommend.ts

@@ -0,0 +1,63 @@
+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: 'algoliaRecommend',
+          handler: {
+            openapi: {
+              endpoint: `https://${graphCommerceConfig.algolia.applicationId}.algolia.net/`,
+              source: '@graphcommerce/algolia-recommend/algolia-recommend-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: 'getRecommendations' }],
+            },
+          },
+          transforms: [
+            {
+              prefix: {
+                value: 'algolia_',
+                includeRootOperations: true,
+                includeTypes: false,
+                mode: 'bare',
+              },
+            },
+            {
+              prefix: {
+                value: 'Algolia',
+                includeRootOperations: false,
+                includeTypes: true,
+                mode: 'bare',
+              },
+            },
+          ],
+        },
+      ],
+      additionalResolvers: [
+        ...(baseConfig.additionalResolvers ?? []),
+        '@graphcommerce/algolia-recommend/mesh/resolvers.ts',
+      ],
+    },
+    graphCommerceConfig,
+  )

package/schema/AlgoliaProductRecommendations.graphqls

@@ -0,0 +1,137 @@
+input AlgoliaFallbackParams {
+  """
+  One or more keywords to use in a full-text search.
+  """
+  search: String
+  """
+  The product attributes to search for and return.
+  """
+  filter: ProductAttributeFilterInput
+  """
+  Specifies which attributes to sort on, and whether to return the results in ascending or descending order.
+  """
+  sort: ProductAttributeSortInput
+}
+
+input AlgoliaLookingSimilarInput {
+  maxRecommendations: Int = 8
+
+  """
+  Minimum score a recommendation must have to be included in the response.
+  """
+  threshold: Float! = 75
+
+  """
+  One or more keywords to use in a full-text search.
+  """
+  search: String
+
+  """
+  The product attributes to search for and return.
+  """
+  filter: ProductAttributeFilterInput
+
+  """
+  When there are no related products, use this fallback query
+  """
+  fallback: AlgoliaFallbackParams
+}
+
+input AlgoliaFrequentlyBoughtTogetherInput {
+  maxRecommendations: Int = 8
+
+  """
+  Minimum score a recommendation must have to be included in the response.
+  """
+  threshold: Float! = 75
+
+  """
+  One or more keywords to use in a full-text search.
+  """
+  search: String
+
+  """
+  The product attributes to search for and return.
+  """
+  filter: ProductAttributeFilterInput
+}
+
+input AlgoliaRelatedProductsInput {
+  maxRecommendations: Int = 8
+
+  """
+  Minimum score a recommendation must have to be included in the response.
+  """
+  threshold: Float! = 75
+
+  """
+  One or more keywords to use in a full-text search.
+  """
+  search: String
+
+  """
+  The product attributes to search for and return.
+  """
+  filter: ProductAttributeFilterInput
+
+  """
+  When there are no related products, use this fallback query
+  """
+  fallback: AlgoliaFallbackParams
+}
+
+interface ProductInterface {
+  algolia_looking_similar(input: AlgoliaLookingSimilarInput): [ProductInterface]
+  algolia_frequently_bought_together(
+    input: AlgoliaFrequentlyBoughtTogetherInput
+  ): [ProductInterface]
+  algolia_related_products(input: AlgoliaRelatedProductsInput): [ProductInterface]
+}
+
+type SimpleProduct implements ProductInterface {
+  algolia_looking_similar(input: AlgoliaLookingSimilarInput): [ProductInterface]
+  algolia_frequently_bought_together(
+    input: AlgoliaFrequentlyBoughtTogetherInput
+  ): [ProductInterface]
+  algolia_related_products(input: AlgoliaRelatedProductsInput): [ProductInterface]
+}
+
+type VirtualProduct implements ProductInterface {
+  algolia_looking_similar(input: AlgoliaLookingSimilarInput): [ProductInterface]
+  algolia_frequently_bought_together(
+    input: AlgoliaFrequentlyBoughtTogetherInput
+  ): [ProductInterface]
+  algolia_related_products(input: AlgoliaRelatedProductsInput): [ProductInterface]
+}
+
+type ConfigurableProduct implements ProductInterface {
+  algolia_looking_similar(input: AlgoliaLookingSimilarInput): [ProductInterface]
+  algolia_frequently_bought_together(
+    input: AlgoliaFrequentlyBoughtTogetherInput
+  ): [ProductInterface]
+  algolia_related_products(input: AlgoliaRelatedProductsInput): [ProductInterface]
+}
+
+type BundleProduct implements ProductInterface {
+  algolia_looking_similar(input: AlgoliaLookingSimilarInput): [ProductInterface]
+  algolia_frequently_bought_together(
+    input: AlgoliaFrequentlyBoughtTogetherInput
+  ): [ProductInterface]
+  algolia_related_products(input: AlgoliaRelatedProductsInput): [ProductInterface]
+}
+
+type DownloadableProduct implements ProductInterface {
+  algolia_looking_similar(input: AlgoliaLookingSimilarInput): [ProductInterface]
+  algolia_frequently_bought_together(
+    input: AlgoliaFrequentlyBoughtTogetherInput
+  ): [ProductInterface]
+  algolia_related_products(input: AlgoliaRelatedProductsInput): [ProductInterface]
+}
+
+type GroupedProduct implements ProductInterface {
+  algolia_looking_similar(input: AlgoliaLookingSimilarInput): [ProductInterface]
+  algolia_frequently_bought_together(
+    input: AlgoliaFrequentlyBoughtTogetherInput
+  ): [ProductInterface]
+  algolia_related_products(input: AlgoliaRelatedProductsInput): [ProductInterface]
+}