@reactionary/provider-algolia 0.3.6 → 0.3.8

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@reactionary/provider-algolia",
-  "version": "0.3.6",
+  "version": "0.3.8",
   "main": "index.js",
   "types": "src/index.d.ts",
   "dependencies": {
-    "@reactionary/core": "0.3.6",
+    "@reactionary/core": "0.3.8",
     "algoliasearch": "^5.48.0",
     "zod": "4.1.9"
   },

package/providers/product-recommendations.provider.js

@@ -1,5 +1,7 @@
 import {
-  ProductRecommendationsProvider
+  ProductRecommendationsProvider,
+  ProductSearchResultItemVariantSchema,
+  ImageSchema
 } from "@reactionary/core";
 import {
   liteClient
@@ -157,12 +159,33 @@ class AlgoliaProductRecommendationsProvider extends ProductRecommendationsProvid
    * Maps Algolia recommendation results to ProductRecommendation format
    */
   parseSingle(hit, recommendationIdentifier) {
+    const product = this.parseSearchResultItem(hit);
     return {
       recommendationIdentifier,
-      product: {
-        key: hit.objectID
-      }
+      recommendationReturnType: "productSearchResultItem",
+      product
+    };
+  }
+  parseSearchResultItem(body) {
+    const product = {
+      identifier: { key: body.objectID },
+      name: body.name || body.objectID,
+      slug: body.slug || body.objectID,
+      variants: [...body.variants || []].map((variant) => this.parseVariant(variant, body))
     };
+    return product;
+  }
+  parseVariant(variant, product) {
+    const result = ProductSearchResultItemVariantSchema.parse({
+      variant: {
+        sku: variant.sku
+      },
+      image: ImageSchema.parse({
+        sourceUrl: variant.image,
+        altText: product.name || ""
+      })
+    });
+    return result;
   }
 }
 export {

package/src/providers/product-recommendations.provider.d.ts

@@ -1,12 +1,8 @@
-import { type Cache, ProductRecommendationsProvider, type ProductRecommendation, type ProductRecommendationAlgorithmFrequentlyBoughtTogetherQuery, type ProductRecommendationAlgorithmSimilarProductsQuery, type ProductRecommendationAlgorithmRelatedProductsQuery, type ProductRecommendationAlgorithmTrendingInCategoryQuery, type RequestContext, type ProductRecommendationsQuery } from '@reactionary/core';
+import { type Cache, ProductRecommendationsProvider, type ProductRecommendation, type ProductRecommendationAlgorithmFrequentlyBoughtTogetherQuery, type ProductRecommendationAlgorithmSimilarProductsQuery, type ProductRecommendationAlgorithmRelatedProductsQuery, type ProductRecommendationAlgorithmTrendingInCategoryQuery, type RequestContext, type ProductRecommendationsQuery, type ProductSearchResultItemVariant } from '@reactionary/core';
 import { type RecommendationsResults, type RecommendSearchParams, type LiteClient } from 'algoliasearch/lite';
 import type { AlgoliaConfiguration } from '../schema/configuration.schema.js';
 import type { AlgoliaProductRecommendationIdentifier } from '../schema/product-recommendation.schema.js';
-interface AlgoliaRecommendHit {
-    objectID: string;
-    sku?: string;
-    [key: string]: unknown;
-}
+import type { AlgoliaNativeRecord, AlgoliaNativeVariant } from '../schema/search.schema.js';
 /**
  * AlgoliaProductRecommendationsProvider
  *
@@ -38,21 +34,81 @@ export declare class AlgoliaProductRecommendationsProvider extends ProductRecomm
      * Get trending in category recommendations using Algolia Recommend
      */
     protected getTrendingInCategoryRecommendations(query: ProductRecommendationAlgorithmTrendingInCategoryQuery): Promise<ProductRecommendation[]>;
-    protected parseRecommendation(res: RecommendationsResults, query: ProductRecommendationsQuery): {
+    protected parseRecommendation(res: RecommendationsResults, query: ProductRecommendationsQuery): ({
         [x: string]: unknown;
         recommendationIdentifier: {
             [x: string]: unknown;
             key: string;
             algorithm: string;
         };
+        recommendationReturnType: "idOnly";
         product: {
             [x: string]: unknown;
             key: string;
         };
-    }[];
+    } | {
+        [x: string]: unknown;
+        recommendationIdentifier: {
+            [x: string]: unknown;
+            key: string;
+            algorithm: string;
+        };
+        recommendationReturnType: "productSearchResultItem";
+        product: {
+            [x: string]: unknown;
+            identifier: {
+                [x: string]: unknown;
+                key: string;
+            };
+            name: string;
+            slug: string;
+            variants: {
+                [x: string]: unknown;
+                variant: {
+                    [x: string]: unknown;
+                    sku: string;
+                };
+                image: {
+                    [x: string]: unknown;
+                    sourceUrl: string;
+                    altText: string;
+                    width?: number | undefined;
+                    height?: number | undefined;
+                };
+                options?: {
+                    [x: string]: unknown;
+                    identifier: {
+                        [x: string]: unknown;
+                        key: string;
+                    };
+                    name: string;
+                    value: {
+                        [x: string]: unknown;
+                        identifier: {
+                            [x: string]: unknown;
+                            option: {
+                                [x: string]: unknown;
+                                key: string;
+                            };
+                            key: string;
+                        };
+                        label: string;
+                    };
+                } | undefined;
+            }[];
+        };
+    })[];
     /**
      * Maps Algolia recommendation results to ProductRecommendation format
      */
-    protected parseSingle(hit: AlgoliaRecommendHit, recommendationIdentifier: AlgoliaProductRecommendationIdentifier): ProductRecommendation;
+    protected parseSingle(hit: AlgoliaNativeRecord, recommendationIdentifier: AlgoliaProductRecommendationIdentifier): ProductRecommendation;
+    protected parseSearchResultItem(body: AlgoliaNativeRecord): {
+        identifier: {
+            key: string;
+        };
+        name: string;
+        slug: string;
+        variants: ProductSearchResultItemVariant[];
+    };
+    protected parseVariant(variant: AlgoliaNativeVariant, product: AlgoliaNativeRecord): ProductSearchResultItemVariant;
 }
-export {};

package/src/providers/product-search.provider.d.ts

@@ -1,16 +1,7 @@
 import { type Cache, type FacetIdentifier, type FacetValueIdentifier, ProductSearchProvider, type ProductSearchQueryByTerm, type ProductSearchQueryCreateNavigationFilter, type ProductSearchResult, type ProductSearchResultFacet, type ProductSearchResultFacetValue, type ProductSearchResultItemVariant, type RequestContext, type Result } from '@reactionary/core';
 import { type SearchResponse } from 'algoliasearch';
 import type { AlgoliaConfiguration } from '../schema/configuration.schema.js';
-interface AlgoliaNativeVariant {
-    sku: string;
-    image: string;
-}
-interface AlgoliaNativeRecord {
-    objectID: string;
-    slug?: string;
-    name?: string;
-    variants: Array<AlgoliaNativeVariant>;
-}
+import type { AlgoliaNativeRecord, AlgoliaNativeVariant } from '../schema/search.schema.js';
 export declare class AlgoliaProductSearchProvider extends ProductSearchProvider {
     protected config: AlgoliaConfiguration;
     constructor(cache: Cache, context: RequestContext, config: AlgoliaConfiguration);
@@ -59,4 +50,3 @@ export declare class AlgoliaProductSearchProvider extends ProductSearchProvider
     protected parseFacet(facetIdentifier: FacetIdentifier, facetValues: Record<string, number>): ProductSearchResultFacet;
     protected parseFacetValue(facetValueIdentifier: FacetValueIdentifier, label: string, count: number): ProductSearchResultFacetValue;
 }
-export {};

package/src/schema/search.schema.d.ts

@@ -101,3 +101,13 @@ export declare const AlgoliaProductSearchResultSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type AlgoliaProductSearchResult = z.infer<typeof AlgoliaProductSearchResultSchema>;
 export type AlgoliaProductSearchIdentifier = z.infer<typeof AlgoliaProductSearchIdentifierSchema>;
+export interface AlgoliaNativeVariant {
+    sku: string;
+    image: string;
+}
+export interface AlgoliaNativeRecord {
+    objectID: string;
+    slug?: string;
+    name?: string;
+    variants: Array<AlgoliaNativeVariant>;
+}