@reactionary/source 0.6.1 → 0.6.2

package/providers/algolia/src/core/initialize.types.ts

@@ -0,0 +1,107 @@
+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 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 {
+  const factory = capability?.factory ?? defaults.factory;
+  const provider = capability?.provider ?? defaults.provider;
+
+  return provider(buildProviderArgs(factory));
+}
+
+export function resolveProviderOnlyCapability<TProvider, TProviderArgs>(
+  capability:
+    | {
+        provider?: (args: TProviderArgs) => TProvider;
+      }
+    | undefined,
+  defaultProvider: (args: TProviderArgs) => TProvider,
+  args: TProviderArgs,
+): TProvider {
+  const provider = capability?.provider ?? defaultProvider;
+  return provider(args);
+}

package/providers/algolia/src/factories/index.ts

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

package/providers/algolia/src/factories/product-search/product-search.factory.ts

@@ -0,0 +1,182 @@
+import type {
+  AnyProductSearchResultSchema,
+  FacetIdentifier,
+  FacetValueIdentifier,
+  ProductSearchFactory,
+  ProductSearchQueryByTerm,
+  ProductSearchResultFacet,
+  ProductSearchResultFacetValue,
+  ProductSearchResultItem,
+  ProductSearchResultItemVariant,
+  RequestContext,
+} from '@reactionary/core';
+import {
+  FacetIdentifierSchema,
+  FacetValueIdentifierSchema,
+  ImageSchema,
+  ProductSearchResultFacetSchema,
+  ProductSearchResultFacetValueSchema,
+  ProductSearchResultItemVariantSchema,
+} from '@reactionary/core';
+import type * as z from 'zod';
+import type { SearchResponse } from 'algoliasearch';
+import type {
+  AlgoliaNativeRecord,
+  AlgoliaNativeVariant,
+  AlgoliaProductSearchResult,
+} from '../../schema/search.schema.js';
+import type { AlgoliaProductSearchResultSchema } from '../../schema/search.schema.js';
+
+export class AlgoliaProductSearchFactory<
+  TProductSearchResultSchema extends AnyProductSearchResultSchema = typeof AlgoliaProductSearchResultSchema,
+> implements ProductSearchFactory<TProductSearchResultSchema>
+{
+  public readonly productSearchResultSchema: TProductSearchResultSchema;
+
+  constructor(productSearchResultSchema: TProductSearchResultSchema) {
+    this.productSearchResultSchema = productSearchResultSchema;
+  }
+
+  public parseSearchResult(
+    _context: RequestContext,
+    data: unknown,
+    query: ProductSearchQueryByTerm,
+  ): z.output<TProductSearchResultSchema> {
+    const body = this.parseInput(data);
+    const items = body.hits.map((hit) => this.parseSingle(hit));
+
+    let facets: ProductSearchResultFacet[] = [];
+    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,
+    } satisfies AlgoliaProductSearchResult;
+
+    return this.productSearchResultSchema.parse(result);
+  }
+
+  protected parseSingle(body: AlgoliaNativeRecord): ProductSearchResultItem {
+    return {
+      identifier: { key: body.objectID },
+      name: body.name || body.objectID,
+      slug: body.slug || body.objectID,
+      variants: [...(body.variants || [])].map((variant) =>
+        this.parseVariant(variant, body),
+      ),
+    } satisfies ProductSearchResultItem;
+  }
+
+  protected parseVariant(
+    variant: AlgoliaNativeVariant,
+    product: AlgoliaNativeRecord,
+  ): ProductSearchResultItemVariant {
+    return ProductSearchResultItemVariantSchema.parse({
+      variant: {
+        sku: variant.sku,
+      },
+      image: ImageSchema.parse({
+        sourceUrl: variant.image,
+        altText: product.name || '',
+      }),
+    } satisfies Partial<ProductSearchResultItemVariant>);
+  }
+
+  protected parseFacet(
+    facetIdentifier: FacetIdentifier,
+    facetValues: Record<string, number>,
+  ): ProductSearchResultFacet {
+    const result = ProductSearchResultFacetSchema.parse({
+      identifier: facetIdentifier,
+      name: facetIdentifier.key,
+      values: [],
+    } satisfies Partial<ProductSearchResultFacet>);
+
+    for (const valueId in facetValues) {
+      const count = facetValues[valueId];
+      const facetValueIdentifier = FacetValueIdentifierSchema.parse({
+        facet: facetIdentifier,
+        key: valueId,
+      } satisfies Partial<FacetValueIdentifier>);
+
+      result.values.push(this.parseFacetValue(facetValueIdentifier, valueId, count));
+    }
+
+    return result;
+  }
+
+  protected parseFacetValue(
+    facetValueIdentifier: FacetValueIdentifier,
+    label: string,
+    count: number,
+  ): ProductSearchResultFacetValue {
+    return ProductSearchResultFacetValueSchema.parse({
+      identifier: facetValueIdentifier,
+      name: label,
+      count,
+      active: false,
+    } satisfies Partial<ProductSearchResultFacetValue>);
+  }
+
+  protected parseInput(data: unknown): SearchResponse<AlgoliaNativeRecord> {
+    if (!this.isSearchResponse(data)) {
+      throw new Error('Invalid Algolia search response');
+    }
+
+    return data;
+  }
+
+  protected isSearchResponse(data: unknown): data is SearchResponse<AlgoliaNativeRecord> {
+    if (!data || typeof data !== 'object') {
+      return false;
+    }
+
+    if (!('hits' in data) || !Array.isArray(data.hits)) {
+      return false;
+    }
+
+    return true;
+  }
+}

package/providers/algolia/src/index.ts

@@ -1,6 +1,6 @@
 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/providers/algolia/src/providers/analytics.provider.ts

@@ -48,7 +48,7 @@ export class AlgoliaAnalyticsProvider extends AnalyticsProvider {
           .key,
       } satisfies AddedToCartObjectIDsAfterSearch;
 
-      const response = await this.client.pushEvents({
+      await this.client.pushEvents({
         events: [algoliaEvent],
       });
     }
@@ -69,7 +69,7 @@ export class AlgoliaAnalyticsProvider extends AnalyticsProvider {
           .key,
       } satisfies ClickedObjectIDsAfterSearch;
 
-      const response = await this.client.pushEvents({
+      await this.client.pushEvents({
         events: [algoliaEvent],
       });
     }
@@ -87,7 +87,7 @@ export class AlgoliaAnalyticsProvider extends AnalyticsProvider {
         userToken: this.context.session.identityContext.personalizationKey,
       } satisfies ViewedObjectIDs;
 
-      const response = await this.client.pushEvents({
+      await this.client.pushEvents({
         events: [algoliaEvent],
       });
     }
@@ -107,7 +107,7 @@ export class AlgoliaAnalyticsProvider extends AnalyticsProvider {
       userToken: this.context.session.identityContext.personalizationKey,
     } satisfies PurchasedObjectIDs;
 
-    const response = await this.client.pushEvents({
+    await this.client.pushEvents({
       events: [algoliaEvent],
     });
   }

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

@@ -4,233 +4,116 @@ import {
   FacetIdentifierSchema,
   type FacetValueIdentifier,
   FacetValueIdentifierSchema,
-  ImageSchema,
   ProductSearchProvider,
+  type ProductSearchFactory,
+  type ProductSearchFactoryOutput,
+  type ProductSearchFactoryWithOutput,
   type ProductSearchQueryByTerm,
   ProductSearchQueryByTermSchema,
   type ProductSearchQueryCreateNavigationFilter,
-  type ProductSearchResult,
-  type ProductSearchResultFacet,
-  ProductSearchResultFacetSchema,
-  type ProductSearchResultFacetValue,
-  ProductSearchResultFacetValueSchema,
-  type ProductSearchResultItem,
-  type ProductSearchResultItemVariant,
-  ProductSearchResultItemVariantSchema,
-  ProductSearchResultSchema,
-  Reactionary,
   type RequestContext,
   type Result,
-  success
+  ProductSearchResultSchema,
+  Reactionary,
+  success,
 } from '@reactionary/core';
-import { algoliasearch, type SearchResponse } from 'algoliasearch';
+import { algoliasearch } from 'algoliasearch';
 import type { AlgoliaConfiguration } from '../schema/configuration.schema.js';
-import type { AlgoliaNativeRecord, AlgoliaNativeVariant, AlgoliaProductSearchResult } from '../schema/search.schema.js';
+import type { AlgoliaNativeRecord } from '../schema/search.schema.js';
+import type { AlgoliaProductSearchFactory } from '../factories/product-search/product-search.factory.js';
 
-
-
-export class AlgoliaProductSearchProvider extends ProductSearchProvider {
+export 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>,
+  ) {
     super(cache, context);
     this.config = config;
+    this.factory = factory;
   }
 
   protected queryByTermPayload(payload: ProductSearchQueryByTerm) {
+    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 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 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}"`);
     }
+
     return {
-          indexName: this.config.indexName,
-          query: payload.search.term,
-          page: payload.search.paginationOptions.pageNumber - 1,
-          hitsPerPage: payload.search.paginationOptions.pageSize,
-          facets: ['*'],
-          analytics: true,
-          clickAnalytics: true,
-          facetFilters: finalFacetFilters,
-          filters: (finalFilters || [])
-            .join(' AND '),
-        };
+      indexName: this.config.indexName,
+      query: payload.search.term,
+      page: payload.search.paginationOptions.pageNumber - 1,
+      hitsPerPage: payload.search.paginationOptions.pageSize,
+      facets: ['*'],
+      analytics: true,
+      clickAnalytics: true,
+      facetFilters: finalFacetFilters,
+      filters: finalFilters.join(' AND '),
+    };
   }
 
   @Reactionary({
     inputSchema: ProductSearchQueryByTermSchema,
-    outputSchema: ProductSearchResultSchema
+    outputSchema: ProductSearchResultSchema,
   })
   public override async queryByTerm(
-    payload: ProductSearchQueryByTerm
-  ): Promise<Result<ProductSearchResult>> {
+    payload: ProductSearchQueryByTerm,
+  ): Promise<Result<ProductSearchFactoryOutput<TFactory>>> {
     const client = algoliasearch(this.config.appId, this.config.apiKey);
 
-
-
     const remote = await client.search<AlgoliaNativeRecord>({
-      requests: [
-        this.queryByTermPayload(payload)
-      ],
+      requests: [this.queryByTermPayload(payload)],
     });
 
-    const input = remote.results[0] as SearchResponse<AlgoliaNativeRecord>;
-    const result = this.parsePaginatedResult(input, payload) as AlgoliaProductSearchResult;
+    const input = remote.results[0];
+    const result = this.factory.parseSearchResult(this.context, input, payload);
 
-    // mark selected facets as active
-    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;
-          }
+    for (const selectedFacet of payload.search.facets) {
+      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);
   }
 
-  public override async createCategoryNavigationFilter(payload: ProductSearchQueryCreateNavigationFilter): Promise<Result<FacetValueIdentifier>> {
-
+  public override async createCategoryNavigationFilter(
+    payload: ProductSearchQueryCreateNavigationFilter,
+  ): Promise<Result<FacetValueIdentifier>> {
     const facetIdentifier = FacetIdentifierSchema.parse({
-      key: 'categories'
-    });
+      key: 'categories',
+    } satisfies Partial<FacetIdentifier>);
+
     const facetValueIdentifier = FacetValueIdentifierSchema.parse({
       facet: facetIdentifier,
-      key: payload.categoryPath.map(c => c.name).join(' > ')
-    });
-    return success(facetValueIdentifier);
-  }
+      key: payload.categoryPath.map((c) => c.name).join(' > '),
+    } satisfies Partial<FacetValueIdentifier>);
 
-
-  protected parseSingle(body: AlgoliaNativeRecord) {
-    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)),
-    } satisfies ProductSearchResultItem;
-
-    return product;
-  }
-
-  protected override parseVariant(variant: AlgoliaNativeVariant, product: AlgoliaNativeRecord): ProductSearchResultItemVariant {
-      const result = ProductSearchResultItemVariantSchema.parse({
-      variant: {
-        sku: variant.sku
-      },
-      image: ImageSchema.parse({
-        sourceUrl: variant.image,
-        altText: product.name || '',
-      })
-    } satisfies Partial<ProductSearchResultItemVariant>);
-
-    return result;
-  }
-
-  protected parsePaginatedResult(body: SearchResponse<AlgoliaNativeRecord>, query: ProductSearchQueryByTerm) {
-    const items = body.hits.map((hit) => this.parseSingle(hit));
-    let facets: ProductSearchResultFacet[] = [];
-    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);
-    }
-
-
-    // we do something to convert the hierachy.lvl.n facet values into something more usable
-    const selectedCategoryFacet = query.search.facets.find(x => x.facet.key === 'categories') || query.search.categoryFilter;
-    let subCategoryFacet;
-    if(selectedCategoryFacet) {
-      const valueDepth = selectedCategoryFacet.key.split(' > ').length;
-      // ok, so input defined a facet value from level X, we return hierarchy.lvl.(X+1) as subcategories.
-      // hierarchy counts from 0, so length is already pointing to 'lvl.(X+1)'
-      subCategoryFacet = facets.find(f => f.identifier.key === `hierarchy.lvl${valueDepth}`);
-    } else {
-      // and remap lvl0 to 'categories'
-      subCategoryFacet = facets.find(f => f.identifier.key === 'hierarchy.lvl0');
-    }
-
-    if(subCategoryFacet) {
-      // remap to 'categories' facet
-      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];
-      }
-    }
-
-    // remove other hierarchy facets
-    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: items,
-      facets,
-    } satisfies AlgoliaProductSearchResult;
-
-    return result;
-  }
-
-  protected parseFacet(facetIdentifier: FacetIdentifier,  facetValues: Record<string, number>) : ProductSearchResultFacet {
-    const result: ProductSearchResultFacet = 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
-      } satisfies Partial<FacetValueIdentifier>);
-
-      result.values.push(this.parseFacetValue(facetValueIdentifier, vid, fv));
-    }
-    return result;
-  }
-
-  protected parseFacetValue(facetValueIdentifier: FacetValueIdentifier,  label: string, count: number) : ProductSearchResultFacetValue {
-    return ProductSearchResultFacetValueSchema.parse({
-      identifier: facetValueIdentifier,
-      name: label,
-      count: count,
-      active: false,
-    } satisfies Partial<ProductSearchResultFacetValue>);
+    return success(facetValueIdentifier);
   }
-
-
 }