@reactionary/provider-algolia 0.6.1 → 0.6.2

package/core/initialize.js

@@ -1,17 +1,63 @@
 import { AlgoliaProductSearchProvider } from "../providers/product-search.provider.js";
 import { AlgoliaAnalyticsProvider } from "../providers/analytics.provider.js";
 import { AlgoliaProductRecommendationsProvider } from "../providers/product-recommendations.provider.js";
+import { AlgoliaProductSearchFactory } from "../factories/product-search/product-search.factory.js";
+import { AlgoliaProductSearchResultSchema } from "../schema/search.schema.js";
+import {
+  resolveCapabilityProvider,
+  resolveProviderOnlyCapability
+} from "./initialize.types.js";
 function withAlgoliaCapabilities(configuration, capabilities) {
   return (cache, context) => {
     const client = {};
-    if (capabilities.productSearch) {
-      client.productSearch = new AlgoliaProductSearchProvider(cache, context, configuration);
+    if (capabilities.productSearch?.enabled) {
+      const defaultFactory = new AlgoliaProductSearchFactory(
+        AlgoliaProductSearchResultSchema
+      );
+      client.productSearch = resolveCapabilityProvider(
+        capabilities.productSearch,
+        {
+          factory: defaultFactory,
+          provider: (args) => new AlgoliaProductSearchProvider(
+            args.cache,
+            args.context,
+            args.config,
+            args.factory
+          )
+        },
+        (factory) => ({
+          cache,
+          context,
+          config: configuration,
+          factory
+        })
+      );
     }
-    if (capabilities.analytics) {
-      client.analytics = new AlgoliaAnalyticsProvider(cache, context, configuration);
+    if (capabilities.analytics?.enabled) {
+      client.analytics = resolveProviderOnlyCapability(
+        capabilities.analytics,
+        (args) => new AlgoliaAnalyticsProvider(args.cache, args.context, args.config),
+        {
+          cache,
+          context,
+          config: configuration
+        }
+      );
     }
-    if (capabilities.productRecommendations) {
-      client.productRecommendations = new AlgoliaProductRecommendationsProvider(configuration, cache, context);
+    if (capabilities.productRecommendations?.enabled) {
+      client.productRecommendations = resolveProviderOnlyCapability(
+        capabilities.productRecommendations,
+        (args) => new AlgoliaProductRecommendationsProvider(
+          args.config,
+          args.cache,
+          args.context
+        ),
+        {
+          cache,
+          context,
+          config: configuration
+        }
+      );
     }
     return client;
   };

package/core/initialize.types.js

@@ -0,0 +1,13 @@
+function resolveCapabilityProvider(capability, defaults, buildProviderArgs) {
+  const factory = capability?.factory ?? defaults.factory;
+  const provider = capability?.provider ?? defaults.provider;
+  return provider(buildProviderArgs(factory));
+}
+function resolveProviderOnlyCapability(capability, defaultProvider, args) {
+  const provider = capability?.provider ?? defaultProvider;
+  return provider(args);
+}
+export {
+  resolveCapabilityProvider,
+  resolveProviderOnlyCapability
+};

package/factories/index.js

@@ -0,0 +1 @@
+export * from "./product-search/product-search.factory.js";

package/factories/product-search/product-search.factory.js

@@ -0,0 +1,123 @@
+import {
+  FacetIdentifierSchema,
+  FacetValueIdentifierSchema,
+  ImageSchema,
+  ProductSearchResultFacetSchema,
+  ProductSearchResultFacetValueSchema,
+  ProductSearchResultItemVariantSchema
+} from "@reactionary/core";
+class AlgoliaProductSearchFactory {
+  constructor(productSearchResultSchema) {
+    this.productSearchResultSchema = productSearchResultSchema;
+  }
+  parseSearchResult(_context, data, query) {
+    const body = this.parseInput(data);
+    const items = body.hits.map((hit) => this.parseSingle(hit));
+    let facets = [];
+    for (const id in body.facets) {
+      const values = body.facets[id];
+      const facetId = FacetIdentifierSchema.parse({ key: id });
+      facets.push(this.parseFacet(facetId, values));
+    }
+    const selectedCategoryFacet = query.search.facets.find((x) => x.facet.key === "categories") || query.search.categoryFilter;
+    let subCategoryFacet;
+    if (selectedCategoryFacet) {
+      const valueDepth = selectedCategoryFacet.key.split(" > ").length;
+      subCategoryFacet = facets.find(
+        (f) => f.identifier.key === `hierarchy.lvl${valueDepth}`
+      );
+    } else {
+      subCategoryFacet = facets.find((f) => f.identifier.key === "hierarchy.lvl0");
+    }
+    if (subCategoryFacet) {
+      subCategoryFacet.identifier = FacetIdentifierSchema.parse({ key: "categories" });
+      subCategoryFacet.name = "Categories";
+      for (const value of subCategoryFacet.values) {
+        const pathParts = value.identifier.key.split(" > ");
+        value.identifier.facet = subCategoryFacet.identifier;
+        value.name = pathParts[pathParts.length - 1];
+      }
+    }
+    facets = facets.filter((f) => !f.identifier.key.startsWith("hierarchy.lvl"));
+    const result = {
+      identifier: {
+        term: query.search.term,
+        facets: query.search.facets,
+        filters: query.search.filters,
+        paginationOptions: query.search.paginationOptions,
+        index: body.index || "",
+        key: body.queryID || ""
+      },
+      pageNumber: (body.page || 0) + 1,
+      pageSize: body.hitsPerPage || 0,
+      totalCount: body.nbHits || 0,
+      totalPages: body.nbPages || 0,
+      items,
+      facets
+    };
+    return this.productSearchResultSchema.parse(result);
+  }
+  parseSingle(body) {
+    return {
+      identifier: { key: body.objectID },
+      name: body.name || body.objectID,
+      slug: body.slug || body.objectID,
+      variants: [...body.variants || []].map(
+        (variant) => this.parseVariant(variant, body)
+      )
+    };
+  }
+  parseVariant(variant, product) {
+    return ProductSearchResultItemVariantSchema.parse({
+      variant: {
+        sku: variant.sku
+      },
+      image: ImageSchema.parse({
+        sourceUrl: variant.image,
+        altText: product.name || ""
+      })
+    });
+  }
+  parseFacet(facetIdentifier, facetValues) {
+    const result = ProductSearchResultFacetSchema.parse({
+      identifier: facetIdentifier,
+      name: facetIdentifier.key,
+      values: []
+    });
+    for (const valueId in facetValues) {
+      const count = facetValues[valueId];
+      const facetValueIdentifier = FacetValueIdentifierSchema.parse({
+        facet: facetIdentifier,
+        key: valueId
+      });
+      result.values.push(this.parseFacetValue(facetValueIdentifier, valueId, count));
+    }
+    return result;
+  }
+  parseFacetValue(facetValueIdentifier, label, count) {
+    return ProductSearchResultFacetValueSchema.parse({
+      identifier: facetValueIdentifier,
+      name: label,
+      count,
+      active: false
+    });
+  }
+  parseInput(data) {
+    if (!this.isSearchResponse(data)) {
+      throw new Error("Invalid Algolia search response");
+    }
+    return data;
+  }
+  isSearchResponse(data) {
+    if (!data || typeof data !== "object") {
+      return false;
+    }
+    if (!("hits" in data) || !Array.isArray(data.hits)) {
+      return false;
+    }
+    return true;
+  }
+}
+export {
+  AlgoliaProductSearchFactory
+};

package/index.js

@@ -1,5 +1,5 @@
 export * from "./core/initialize.js";
-export * from "./providers/product-search.provider.js";
-export * from "./providers/product-recommendations.provider.js";
+export * from "./providers/index.js";
+export * from "./factories/index.js";
 export * from "./schema/configuration.schema.js";
 export * from "./schema/capabilities.schema.js";

package/package.json

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

package/providers/analytics.provider.js

@@ -21,7 +21,7 @@ class AlgoliaAnalyticsProvider extends AnalyticsProvider {
         userToken: this.context.session.identityContext.personalizationKey,
         queryID: event.source.identifier.key
       };
-      const response = await this.client.pushEvents({
+      await this.client.pushEvents({
         events: [algoliaEvent]
       });
     }
@@ -37,7 +37,7 @@ class AlgoliaAnalyticsProvider extends AnalyticsProvider {
         positions: [event.position],
         queryID: event.source.identifier.key
       };
-      const response = await this.client.pushEvents({
+      await this.client.pushEvents({
         events: [algoliaEvent]
       });
     }
@@ -51,7 +51,7 @@ class AlgoliaAnalyticsProvider extends AnalyticsProvider {
         objectIDs: event.products.map((x) => x.key),
         userToken: this.context.session.identityContext.personalizationKey
       };
-      const response = await this.client.pushEvents({
+      await this.client.pushEvents({
         events: [algoliaEvent]
       });
     }
@@ -65,7 +65,7 @@ class AlgoliaAnalyticsProvider extends AnalyticsProvider {
       objectIDs: event.order.items.map((x) => x.variant.sku),
       userToken: this.context.session.identityContext.personalizationKey
     };
-    const response = await this.client.pushEvents({
+    await this.client.pushEvents({
       events: [algoliaEvent]
     });
   }

package/providers/product-search.provider.js

@@ -12,30 +12,27 @@ var __decorateClass = (decorators, target, key, kind) => {
 import {
   FacetIdentifierSchema,
   FacetValueIdentifierSchema,
-  ImageSchema,
   ProductSearchProvider,
   ProductSearchQueryByTermSchema,
-  ProductSearchResultFacetSchema,
-  ProductSearchResultFacetValueSchema,
-  ProductSearchResultItemVariantSchema,
   ProductSearchResultSchema,
   Reactionary,
   success
 } from "@reactionary/core";
 import { algoliasearch } from "algoliasearch";
 class AlgoliaProductSearchProvider extends ProductSearchProvider {
-  constructor(cache, context, config) {
+  constructor(cache, context, config, factory) {
     super(cache, context);
     this.config = config;
+    this.factory = factory;
   }
   queryByTermPayload(payload) {
-    const facetsThatAreNotCategory = payload.search.facets.filter((x) => x.facet.key !== "categories");
+    const facetsThatAreNotCategory = payload.search.facets.filter(
+      (x) => x.facet.key !== "categories"
+    );
     const categoryFacet = payload.search.facets.find((x) => x.facet.key === "categories") || payload.search.categoryFilter;
     const finalFilters = [...payload.search.filters || []];
     const finalFacetFilters = [
-      ...facetsThatAreNotCategory.map(
-        (x) => `${x.facet.key}:${x.key}`
-      )
+      ...facetsThatAreNotCategory.map((x) => `${x.facet.key}:${x.key}`)
     ];
     if (categoryFacet) {
       finalFilters.push(`categories:"${categoryFacet.key}"`);
@@ -49,25 +46,26 @@ class AlgoliaProductSearchProvider extends ProductSearchProvider {
       analytics: true,
       clickAnalytics: true,
       facetFilters: finalFacetFilters,
-      filters: (finalFilters || []).join(" AND ")
+      filters: finalFilters.join(" AND ")
     };
   }
   async queryByTerm(payload) {
     const client = algoliasearch(this.config.appId, this.config.apiKey);
     const remote = await client.search({
-      requests: [
-        this.queryByTermPayload(payload)
-      ]
+      requests: [this.queryByTermPayload(payload)]
     });
     const input = remote.results[0];
-    const result = this.parsePaginatedResult(input, payload);
+    const result = this.factory.parseSearchResult(this.context, input, payload);
     for (const selectedFacet of payload.search.facets) {
-      const facet = result.facets.find((f) => f.identifier.key === selectedFacet.facet.key);
-      if (facet) {
-        const value = facet.values.find((v) => v.identifier.key === selectedFacet.key);
-        if (value) {
-          value.active = true;
-        }
+      const facet = result.facets.find(
+        (f) => f.identifier.key === selectedFacet.facet.key
+      );
+      if (!facet) {
+        continue;
+      }
+      const value = facet.values.find((v) => v.identifier.key === selectedFacet.key);
+      if (value) {
+        value.active = true;
       }
     }
     return success(result);
@@ -82,100 +80,6 @@ class AlgoliaProductSearchProvider extends ProductSearchProvider {
     });
     return success(facetValueIdentifier);
   }
-  parseSingle(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;
-  }
-  parsePaginatedResult(body, query) {
-    const items = body.hits.map((hit) => this.parseSingle(hit));
-    let facets = [];
-    for (const id in body.facets) {
-      const f = body.facets[id];
-      const facetId = FacetIdentifierSchema.parse({
-        key: id
-      });
-      const facet = this.parseFacet(facetId, f);
-      facets.push(facet);
-    }
-    const selectedCategoryFacet = query.search.facets.find((x) => x.facet.key === "categories") || query.search.categoryFilter;
-    let subCategoryFacet;
-    if (selectedCategoryFacet) {
-      const valueDepth = selectedCategoryFacet.key.split(" > ").length;
-      subCategoryFacet = facets.find((f) => f.identifier.key === `hierarchy.lvl${valueDepth}`);
-    } else {
-      subCategoryFacet = facets.find((f) => f.identifier.key === "hierarchy.lvl0");
-    }
-    if (subCategoryFacet) {
-      subCategoryFacet.identifier = FacetIdentifierSchema.parse({
-        key: "categories"
-      });
-      subCategoryFacet.name = "Categories";
-      for (const v of subCategoryFacet.values) {
-        const pathParts = v.identifier.key.split(" > ");
-        v.identifier.facet = subCategoryFacet.identifier;
-        v.name = pathParts[pathParts.length - 1];
-      }
-    }
-    facets = facets.filter((f) => !f.identifier.key.startsWith("hierarchy.lvl"));
-    const result = {
-      identifier: {
-        term: query.search.term,
-        facets: query.search.facets,
-        filters: query.search.filters,
-        paginationOptions: query.search.paginationOptions,
-        index: body.index || "",
-        key: body.queryID || ""
-      },
-      pageNumber: (body.page || 0) + 1,
-      pageSize: body.hitsPerPage || 0,
-      totalCount: body.nbHits || 0,
-      totalPages: body.nbPages || 0,
-      items,
-      facets
-    };
-    return result;
-  }
-  parseFacet(facetIdentifier, facetValues) {
-    const result = ProductSearchResultFacetSchema.parse({
-      identifier: facetIdentifier,
-      name: facetIdentifier.key,
-      values: []
-    });
-    for (const vid in facetValues) {
-      const fv = facetValues[vid];
-      const facetValueIdentifier = FacetValueIdentifierSchema.parse({
-        facet: facetIdentifier,
-        key: vid
-      });
-      result.values.push(this.parseFacetValue(facetValueIdentifier, vid, fv));
-    }
-    return result;
-  }
-  parseFacetValue(facetValueIdentifier, label, count) {
-    return ProductSearchResultFacetValueSchema.parse({
-      identifier: facetValueIdentifier,
-      name: label,
-      count,
-      active: false
-    });
-  }
 }
 __decorateClass([
   Reactionary({

package/schema/capabilities.schema.js

@@ -1,8 +1,22 @@
 import { CapabilitiesSchema } from "@reactionary/core";
+import * as z from "zod";
+const ProductSearchCapabilitySchema = z.looseObject({
+  enabled: z.boolean(),
+  factory: z.unknown().optional(),
+  provider: z.unknown().optional()
+});
+const ProviderCapabilitySchema = z.looseObject({
+  enabled: z.boolean(),
+  provider: z.unknown().optional()
+});
 const AlgoliaCapabilitiesSchema = CapabilitiesSchema.pick({
   productSearch: true,
   analytics: true,
   productRecommendations: true
+}).extend({
+  productSearch: ProductSearchCapabilitySchema.optional(),
+  analytics: ProviderCapabilitySchema.optional(),
+  productRecommendations: ProviderCapabilitySchema.optional()
 }).partial();
 export {
   AlgoliaCapabilitiesSchema

package/src/core/initialize.d.ts

@@ -1,4 +1,5 @@
-import type { Cache, ClientFromCapabilities, RequestContext } from "@reactionary/core";
-import type { AlgoliaCapabilities } from "../schema/capabilities.schema.js";
-import type { AlgoliaConfiguration } from "../schema/configuration.schema.js";
-export declare function withAlgoliaCapabilities<T extends AlgoliaCapabilities>(configuration: AlgoliaConfiguration, capabilities: T): (cache: Cache, context: RequestContext) => ClientFromCapabilities<T>;
+import type { Cache, RequestContext } from '@reactionary/core';
+import type { AlgoliaCapabilities } from '../schema/capabilities.schema.js';
+import type { AlgoliaConfiguration } from '../schema/configuration.schema.js';
+import { type AlgoliaClientFromCapabilities } from './initialize.types.js';
+export declare function withAlgoliaCapabilities<T extends AlgoliaCapabilities>(configuration: AlgoliaConfiguration, capabilities: T): (cache: Cache, context: RequestContext) => AlgoliaClientFromCapabilities<T>;

package/src/core/initialize.types.d.ts

@@ -0,0 +1,43 @@
+import type { ClientFromCapabilities, ProductSearchFactory } from '@reactionary/core';
+import type { AlgoliaCapabilities } from '../schema/capabilities.schema.js';
+import type { AlgoliaProductSearchFactory } from '../factories/product-search/product-search.factory.js';
+import type { AlgoliaAnalyticsProvider } from '../providers/analytics.provider.js';
+import type { AlgoliaProductRecommendationsProvider } from '../providers/product-recommendations.provider.js';
+import type { AlgoliaProductSearchProvider } from '../providers/product-search.provider.js';
+type EnabledCapability<TCapability> = TCapability extends {
+    enabled: true;
+} ? true : false;
+type NormalizeConfiguredCapabilities<T extends AlgoliaCapabilities> = Omit<T, 'productSearch' | 'analytics' | 'productRecommendations'> & {
+    productSearch?: EnabledCapability<T['productSearch']>;
+    analytics?: EnabledCapability<T['analytics']>;
+    productRecommendations?: EnabledCapability<T['productRecommendations']>;
+};
+type ExtractCapabilityFactory<TCapability, TContract, TDefaultFactory> = TCapability extends {
+    enabled: true;
+    factory?: infer TFactory;
+} ? TFactory extends TContract ? TFactory : TDefaultFactory : TDefaultFactory;
+type ExtractCapabilityProvider<TCapability, TDefaultProvider> = TCapability extends {
+    enabled: true;
+    provider?: infer TProviderFactory;
+} ? TProviderFactory extends (...args: unknown[]) => infer TProvider ? TProvider : TDefaultProvider : TDefaultProvider;
+type CapabilityOverride<TCapability, TKey extends string, TProvider> = TCapability extends {
+    enabled: true;
+} ? {
+    [K in TKey]: TProvider;
+} : Record<never, never>;
+type ProductSearchFactoryFor<T extends AlgoliaCapabilities> = ExtractCapabilityFactory<T['productSearch'], ProductSearchFactory, AlgoliaProductSearchFactory>;
+type ProductSearchProviderFor<T extends AlgoliaCapabilities> = ExtractCapabilityProvider<T['productSearch'], AlgoliaProductSearchProvider<ProductSearchFactoryFor<T>>>;
+type AnalyticsProviderFor<T extends AlgoliaCapabilities> = ExtractCapabilityProvider<T['analytics'], AlgoliaAnalyticsProvider>;
+type ProductRecommendationsProviderFor<T extends AlgoliaCapabilities> = ExtractCapabilityProvider<T['productRecommendations'], AlgoliaProductRecommendationsProvider>;
+export type AlgoliaClientFromCapabilities<T extends AlgoliaCapabilities> = Omit<ClientFromCapabilities<NormalizeConfiguredCapabilities<T>>, 'productSearch' | 'analytics' | 'productRecommendations'> & CapabilityOverride<T['productSearch'], 'productSearch', ProductSearchProviderFor<T>> & CapabilityOverride<T['analytics'], 'analytics', AnalyticsProviderFor<T>> & CapabilityOverride<T['productRecommendations'], 'productRecommendations', ProductRecommendationsProviderFor<T>>;
+export declare function resolveCapabilityProvider<TFactory, TProvider, TProviderArgs>(capability: {
+    factory?: TFactory;
+    provider?: (args: TProviderArgs) => TProvider;
+} | undefined, defaults: {
+    factory: TFactory;
+    provider: (args: TProviderArgs) => TProvider;
+}, buildProviderArgs: (factory: TFactory) => TProviderArgs): TProvider;
+export declare function resolveProviderOnlyCapability<TProvider, TProviderArgs>(capability: {
+    provider?: (args: TProviderArgs) => TProvider;
+} | undefined, defaultProvider: (args: TProviderArgs) => TProvider, args: TProviderArgs): TProvider;
+export {};

package/src/factories/index.d.ts

@@ -0,0 +1 @@
+export * from './product-search/product-search.factory.js';

package/src/factories/product-search/product-search.factory.d.ts

@@ -0,0 +1,16 @@
+import type { AnyProductSearchResultSchema, FacetIdentifier, FacetValueIdentifier, ProductSearchFactory, ProductSearchQueryByTerm, ProductSearchResultFacet, ProductSearchResultFacetValue, ProductSearchResultItem, ProductSearchResultItemVariant, RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+import type { SearchResponse } from 'algoliasearch';
+import type { AlgoliaNativeRecord, AlgoliaNativeVariant } from '../../schema/search.schema.js';
+import type { AlgoliaProductSearchResultSchema } from '../../schema/search.schema.js';
+export declare class AlgoliaProductSearchFactory<TProductSearchResultSchema extends AnyProductSearchResultSchema = typeof AlgoliaProductSearchResultSchema> implements ProductSearchFactory<TProductSearchResultSchema> {
+    readonly productSearchResultSchema: TProductSearchResultSchema;
+    constructor(productSearchResultSchema: TProductSearchResultSchema);
+    parseSearchResult(_context: RequestContext, data: unknown, query: ProductSearchQueryByTerm): z.output<TProductSearchResultSchema>;
+    protected parseSingle(body: AlgoliaNativeRecord): ProductSearchResultItem;
+    protected parseVariant(variant: AlgoliaNativeVariant, product: AlgoliaNativeRecord): ProductSearchResultItemVariant;
+    protected parseFacet(facetIdentifier: FacetIdentifier, facetValues: Record<string, number>): ProductSearchResultFacet;
+    protected parseFacetValue(facetValueIdentifier: FacetValueIdentifier, label: string, count: number): ProductSearchResultFacetValue;
+    protected parseInput(data: unknown): SearchResponse<AlgoliaNativeRecord>;
+    protected isSearchResponse(data: unknown): data is SearchResponse<AlgoliaNativeRecord>;
+}

package/src/index.d.ts

@@ -1,5 +1,5 @@
 export * from './core/initialize.js';
-export * from './providers/product-search.provider.js';
-export * from './providers/product-recommendations.provider.js';
+export * from './providers/index.js';
+export * from './factories/index.js';
 export * from './schema/configuration.schema.js';
 export * from './schema/capabilities.schema.js';

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

@@ -1,10 +1,10 @@
-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 Cache, type FacetValueIdentifier, ProductSearchProvider, type ProductSearchFactory, type ProductSearchFactoryOutput, type ProductSearchFactoryWithOutput, type ProductSearchQueryByTerm, type ProductSearchQueryCreateNavigationFilter, type RequestContext, type Result } from '@reactionary/core';
 import type { AlgoliaConfiguration } from '../schema/configuration.schema.js';
-import type { AlgoliaNativeRecord, AlgoliaNativeVariant } from '../schema/search.schema.js';
-export declare class AlgoliaProductSearchProvider extends ProductSearchProvider {
+import type { AlgoliaProductSearchFactory } from '../factories/product-search/product-search.factory.js';
+export declare class AlgoliaProductSearchProvider<TFactory extends ProductSearchFactory = AlgoliaProductSearchFactory> extends ProductSearchProvider<ProductSearchFactoryOutput<TFactory>> {
     protected config: AlgoliaConfiguration;
-    constructor(cache: Cache, context: RequestContext, config: AlgoliaConfiguration);
+    protected factory: ProductSearchFactoryWithOutput<TFactory>;
+    constructor(cache: Cache, context: RequestContext, config: AlgoliaConfiguration, factory: ProductSearchFactoryWithOutput<TFactory>);
     protected queryByTermPayload(payload: ProductSearchQueryByTerm): {
         indexName: string;
         query: string;
@@ -16,48 +16,6 @@ export declare class AlgoliaProductSearchProvider extends ProductSearchProvider
         facetFilters: string[];
         filters: string;
     };
-    queryByTerm(payload: ProductSearchQueryByTerm): Promise<Result<ProductSearchResult>>;
+    queryByTerm(payload: ProductSearchQueryByTerm): Promise<Result<ProductSearchFactoryOutput<TFactory>>>;
     createCategoryNavigationFilter(payload: ProductSearchQueryCreateNavigationFilter): Promise<Result<FacetValueIdentifier>>;
-    protected parseSingle(body: AlgoliaNativeRecord): {
-        identifier: {
-            key: string;
-        };
-        name: string;
-        slug: string;
-        variants: ProductSearchResultItemVariant[];
-    };
-    protected parseVariant(variant: AlgoliaNativeVariant, product: AlgoliaNativeRecord): ProductSearchResultItemVariant;
-    protected parsePaginatedResult(body: SearchResponse<AlgoliaNativeRecord>, query: ProductSearchQueryByTerm): {
-        identifier: {
-            term: string;
-            facets: {
-                facet: {
-                    key: string;
-                };
-                key: string;
-            }[];
-            filters: string[];
-            paginationOptions: {
-                pageNumber: number;
-                pageSize: number;
-            };
-            index: string;
-            key: string;
-        };
-        pageNumber: number;
-        pageSize: number;
-        totalCount: number;
-        totalPages: number;
-        items: {
-            identifier: {
-                key: string;
-            };
-            name: string;
-            slug: string;
-            variants: ProductSearchResultItemVariant[];
-        }[];
-        facets: ProductSearchResultFacet[];
-    };
-    protected parseFacet(facetIdentifier: FacetIdentifier, facetValues: Record<string, number>): ProductSearchResultFacet;
-    protected parseFacetValue(facetValueIdentifier: FacetValueIdentifier, label: string, count: number): ProductSearchResultFacetValue;
 }

package/src/schema/capabilities.schema.d.ts

@@ -1,7 +1,44 @@
-import type * as z from 'zod';
+import type { AnalyticsProvider, Cache, ProductRecommendationsProvider, ProductSearchFactory, ProductSearchFactoryWithOutput, ProductSearchProvider, RequestContext } from '@reactionary/core';
+import type { AlgoliaConfiguration } from './configuration.schema.js';
+import * as z from 'zod';
 export declare const AlgoliaCapabilitiesSchema: z.ZodObject<{
-    analytics: z.ZodOptional<z.ZodBoolean>;
-    productSearch: z.ZodOptional<z.ZodBoolean>;
-    productRecommendations: z.ZodOptional<z.ZodBoolean>;
+    productSearch: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        provider: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    analytics: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        provider: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    productRecommendations: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        provider: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
 }, z.core.$loose>;
-export type AlgoliaCapabilities = z.infer<typeof AlgoliaCapabilitiesSchema>;
+export interface AlgoliaProviderFactoryArgs {
+    cache: Cache;
+    context: RequestContext;
+    config: AlgoliaConfiguration;
+}
+export interface AlgoliaProductSearchProviderFactoryArgs<TFactory extends ProductSearchFactory = ProductSearchFactory> extends AlgoliaProviderFactoryArgs {
+    factory: ProductSearchFactoryWithOutput<TFactory>;
+}
+export interface AlgoliaProductSearchCapabilityConfig<TFactory extends ProductSearchFactory = ProductSearchFactory, TProvider extends ProductSearchProvider = ProductSearchProvider> {
+    enabled: boolean;
+    factory?: ProductSearchFactoryWithOutput<TFactory>;
+    provider?: (args: AlgoliaProductSearchProviderFactoryArgs<TFactory>) => TProvider;
+}
+export interface AlgoliaAnalyticsCapabilityConfig<TProvider extends AnalyticsProvider = AnalyticsProvider> {
+    enabled: boolean;
+    provider?: (args: AlgoliaProviderFactoryArgs) => TProvider;
+}
+export interface AlgoliaProductRecommendationsCapabilityConfig<TProvider extends ProductRecommendationsProvider = ProductRecommendationsProvider> {
+    enabled: boolean;
+    provider?: (args: AlgoliaProviderFactoryArgs) => TProvider;
+}
+export type AlgoliaCapabilities<TProductSearchFactory extends ProductSearchFactory = ProductSearchFactory, TProductSearchProvider extends ProductSearchProvider = ProductSearchProvider, TAnalyticsProvider extends AnalyticsProvider = AnalyticsProvider, TProductRecommendationsProvider extends ProductRecommendationsProvider = ProductRecommendationsProvider> = {
+    productSearch?: AlgoliaProductSearchCapabilityConfig<TProductSearchFactory, TProductSearchProvider>;
+    analytics?: AlgoliaAnalyticsCapabilityConfig<TAnalyticsProvider>;
+    productRecommendations?: AlgoliaProductRecommendationsCapabilityConfig<TProductRecommendationsProvider>;
+};

package/src/test/client-builder-product-search-extension.example.d.ts

@@ -0,0 +1 @@
+export {};

package/test/client-builder-product-search-extension.example.js

@@ -0,0 +1,61 @@
+import {
+  ClientBuilder,
+  NoOpCache,
+  createInitialRequestContext
+} from "@reactionary/core";
+import * as z from "zod";
+import { withAlgoliaCapabilities } from "../core/initialize.js";
+import { AlgoliaProductSearchFactory } from "../factories/product-search/product-search.factory.js";
+import { AlgoliaProductSearchResultSchema } from "../schema/search.schema.js";
+const assertType = (_value) => {
+};
+const assertNotAny = (_value) => {
+};
+const ExtendedProductSearchResultSchema = AlgoliaProductSearchResultSchema.safeExtend(
+  {
+    extendedMeta: z.string()
+  }
+);
+class ExtendedAlgoliaProductSearchFactory extends AlgoliaProductSearchFactory {
+  constructor() {
+    super(ExtendedProductSearchResultSchema);
+  }
+  parseSearchResult(context, data, query) {
+    const base = super.parseSearchResult(context, data, query);
+    return this.productSearchResultSchema.parse({
+      ...base,
+      extendedMeta: "from-factory"
+    });
+  }
+}
+const config = {
+  appId: "ALGOLIA_APP_ID",
+  apiKey: "ALGOLIA_API_KEY",
+  indexName: "ALGOLIA_INDEX"
+};
+const client = new ClientBuilder(createInitialRequestContext()).withCache(new NoOpCache()).withCapability(
+  withAlgoliaCapabilities(config, {
+    productSearch: {
+      enabled: true,
+      factory: new ExtendedAlgoliaProductSearchFactory()
+    }
+  })
+).build();
+client.productSearch.queryByTerm({
+  search: {
+    term: "test",
+    facets: [],
+    filters: [],
+    paginationOptions: {
+      pageNumber: 1,
+      pageSize: 10
+    }
+  }
+}).then((result) => {
+  assertNotAny(result);
+  if (result.success) {
+    assertNotAny(result.value);
+    assertNotAny(result.value.extendedMeta);
+    assertType(result.value.extendedMeta);
+  }
+});