@reactionary/source 0.3.18 → 0.6.2

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

@@ -1,27 +1,82 @@
-import type { Cache, ClientFromCapabilities, RequestContext } from "@reactionary/core";
-import { AlgoliaProductSearchProvider } from "../providers/product-search.provider.js";
-import type { AlgoliaCapabilities } from "../schema/capabilities.schema.js";
-import type { AlgoliaConfiguration } from "../schema/configuration.schema.js";
-import { AlgoliaAnalyticsProvider } from "../providers/analytics.provider.js";
-import { AlgoliaProductRecommendationsProvider } from "../providers/product-recommendations.provider.js";
+import type { Cache, RequestContext } from '@reactionary/core';
+import { AlgoliaProductSearchProvider } from '../providers/product-search.provider.js';
+import type { AlgoliaCapabilities } from '../schema/capabilities.schema.js';
+import type { AlgoliaConfiguration } from '../schema/configuration.schema.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 {
+  type AlgoliaClientFromCapabilities,
+  resolveCapabilityProvider,
+  resolveProviderOnlyCapability,
+} from './initialize.types.js';
 
-export function withAlgoliaCapabilities<T extends AlgoliaCapabilities>(configuration: AlgoliaConfiguration, capabilities: T) {
-    return (cache: Cache, context: RequestContext): ClientFromCapabilities<T> => {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const client: any = {};
+export function withAlgoliaCapabilities<T extends AlgoliaCapabilities>(
+  configuration: AlgoliaConfiguration,
+  capabilities: T,
+) {
+  return (
+    cache: Cache,
+    context: RequestContext,
+  ): AlgoliaClientFromCapabilities<T> => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const client: any = {};
 
-        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;
-    };
+    return client;
+  };
 }

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],
     });
   }