@reactionary/source 0.3.18 → 0.6.2

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

package/providers/algolia/src/schema/capabilities.schema.ts

@@ -1,10 +1,84 @@
-import { CapabilitiesSchema } from "@reactionary/core";
-import type * as z from 'zod';
+import type {
+  AnalyticsProvider,
+  Cache,
+  ProductRecommendationsProvider,
+  ProductSearchFactory,
+  ProductSearchFactoryWithOutput,
+  ProductSearchProvider,
+  RequestContext,
+} from '@reactionary/core';
+import { CapabilitiesSchema } from '@reactionary/core';
+import type { AlgoliaConfiguration } from './configuration.schema.js';
+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(),
+});
 
 export const AlgoliaCapabilitiesSchema = CapabilitiesSchema.pick({
-    productSearch: true,
-    analytics: true,
-    productRecommendations: true
-}).partial();
+  productSearch: true,
+  analytics: true,
+  productRecommendations: true,
+})
+  .extend({
+    productSearch: ProductSearchCapabilitySchema.optional(),
+    analytics: ProviderCapabilitySchema.optional(),
+    productRecommendations: ProviderCapabilitySchema.optional(),
+  })
+  .partial();
+
+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 = z.infer<typeof AlgoliaCapabilitiesSchema>;
+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/providers/algolia/src/test/analytics.spec.ts

@@ -3,6 +3,8 @@ import { AlgoliaAnalyticsProvider } from '../providers/analytics.provider.js';
 import { createInitialRequestContext, NoOpCache } from '@reactionary/core';
 import type { AlgoliaConfiguration } from '../schema/configuration.schema.js';
 import { AlgoliaProductSearchProvider } from '../providers/product-search.provider.js';
+import { AlgoliaProductSearchFactory } from '../factories/product-search/product-search.factory.js';
+import { AlgoliaProductSearchResultSchema } from '../schema/search.schema.js';
 
 describe('Analytics event tracking', async () => {
   const config = {
@@ -13,7 +15,13 @@ describe('Analytics event tracking', async () => {
   const cache = new NoOpCache();
   const context = createInitialRequestContext();
 
-  const search = new AlgoliaProductSearchProvider(cache, context, config);
+  const searchFactory = new AlgoliaProductSearchFactory(AlgoliaProductSearchResultSchema);
+  const search = new AlgoliaProductSearchProvider<typeof searchFactory>(
+    cache,
+    context,
+    config,
+    searchFactory,
+  );
   const analytics = new AlgoliaAnalyticsProvider(cache, context, config);
   const searchResult = await search.queryByTerm({
     search: {

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

@@ -0,0 +1,85 @@
+import {
+  ClientBuilder,
+  NoOpCache,
+  createInitialRequestContext,
+  type ProductSearchQueryByTerm,
+  type RequestContext,
+} from '@reactionary/core';
+import * as z from 'zod';
+import type { AlgoliaConfiguration } from '../schema/configuration.schema.js';
+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 = <T>(_value: T) => {
+  void _value;
+};
+type IsAny<T> = 0 extends (1 & T) ? true : false;
+const assertNotAny = <T>(_value: IsAny<T> extends true ? never : T) => {
+  void _value;
+};
+
+const ExtendedProductSearchResultSchema = AlgoliaProductSearchResultSchema.safeExtend(
+  {
+    extendedMeta: z.string(),
+  },
+);
+
+class ExtendedAlgoliaProductSearchFactory extends AlgoliaProductSearchFactory<
+  typeof ExtendedProductSearchResultSchema
+> {
+  constructor() {
+    super(ExtendedProductSearchResultSchema);
+  }
+
+  public override parseSearchResult(
+    context: RequestContext,
+    data: unknown,
+    query: ProductSearchQueryByTerm,
+  ) {
+    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',
+} satisfies AlgoliaConfiguration;
+
+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<string>(result.value.extendedMeta);
+    }
+  });