@reactionary/provider-algolia 0.0.59 → 0.0.61

package/README.md

@@ -1,6 +1,43 @@
-# provider-algolia
+# Algolia provider for Reactionary
+
+## Supports
+
+
+| Feature | Support | Notes |
+| -----------   | ----------- | --------- |
+| product       | Full      |          |
+| productSearch | Full     |  |
+| identity | N/A     | |
+| cart |  N/A     |  |
+| checkout | N/A     |  |
+| order | N/A    | Possibly later |
+| inventory | N/A     |  |
+| price | N/A  |  |
+| category | N/A     | Possibly later |
+| store | N/A    | Possibly later |
+
+
+## Notes
+The expected Algolia schema must contain at least these fields
+
+```json
+{
+  objectID: string;
+  slug:string;
+  name: string;
+  variants: [
+    { 
+      variantID: string; 
+      image: string;
+    }
+  ]
+}
+```
+
+You can have more, for use with facets, and additional searchable fields, but these must be in the index, and constitutes what we are expecting to get back.
+
+The `objectID` corrosponds to your productIdentifier, and `variantID` should match your SKU
 
-This library was generated with [Nx](https://nx.dev).
 
 ## Building
 

package/core/initialize.js

@@ -1,6 +1,6 @@
-import { ProductSchema } from "@reactionary/core";
+import { ProductSchema, ProductSearchResultItemSchema } from "@reactionary/core";
 import { AlgoliaProductProvider } from "../providers/product.provider.js";
-import { AlgoliaSearchProvider } from "../providers/search.provider.js";
+import { AlgoliaSearchProvider } from "../providers/product-search.provider.js";
 import { AlgoliaSearchResultSchema } from "../schema/search.schema.js";
 function withAlgoliaCapabilities(configuration, capabilities) {
   return (cache) => {
@@ -8,8 +8,8 @@ function withAlgoliaCapabilities(configuration, capabilities) {
     if (capabilities.product) {
       client.product = new AlgoliaProductProvider(configuration, ProductSchema, cache);
     }
-    if (capabilities.search) {
-      client.search = new AlgoliaSearchProvider(configuration, AlgoliaSearchResultSchema, cache);
+    if (capabilities.productSearch) {
+      client.productSearch = new AlgoliaSearchProvider(configuration, ProductSearchResultItemSchema, cache);
     }
     return client;
   };

package/index.js

@@ -1,5 +1,5 @@
 export * from "./core/initialize.js";
 export * from "./providers/product.provider.js";
-export * from "./providers/search.provider.js";
+export * from "./providers/product-search.provider.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.0.59",
+  "version": "0.0.61",
   "main": "index.js",
   "types": "src/index.d.ts",
   "dependencies": {
-    "@reactionary/core": "0.0.59",
+    "@reactionary/core": "0.0.61",
     "algoliasearch": "^5.23.4",
     "zod": "4.1.9"
   },

package/providers/index.js

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

package/providers/product-search.provider.js

@@ -0,0 +1,132 @@
+import {
+  createPaginatedResponseSchema,
+  FacetIdentifierSchema,
+  FacetValueIdentifierSchema,
+  ImageSchema,
+  ProductSearchProvider,
+  ProductSearchResultFacetSchema,
+  ProductSearchResultFacetValueSchema,
+  ProductSearchResultItemVariantSchema
+} from "@reactionary/core";
+import { algoliasearch } from "algoliasearch";
+import { AlgoliaSearchIdentifierSchema } from "../schema/search.schema.js";
+class AlgoliaSearchProvider extends ProductSearchProvider {
+  constructor(config, schema, cache) {
+    super(schema, cache);
+    this.config = config;
+  }
+  async queryByTerm(payload, reqCtx) {
+    const client = algoliasearch(this.config.appId, this.config.apiKey);
+    const remote = await client.search({
+      requests: [
+        {
+          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: payload.search.facets.map(
+            (x) => `${encodeURIComponent(x.facet.key)}:${x.key}`
+          ),
+          filters: (payload.search.filters || []).map((x) => `${encodeURIComponent(x)}`).join(" AND ")
+        }
+      ]
+    });
+    const input = remote.results[0];
+    const identifier = AlgoliaSearchIdentifierSchema.parse({
+      ...payload.search,
+      index: input.index,
+      key: input.queryID
+    });
+    const result = this.parsePaginatedResult(input, reqCtx);
+    result.identifier = identifier;
+    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;
+        }
+      }
+    }
+    result.meta = {
+      cache: { hit: false, key: "" },
+      placeholder: false
+    };
+    return result;
+  }
+  parseSingle(body, reqCtx) {
+    const product = this.newModel();
+    product.identifier = { key: body.objectID };
+    product.name = body.name || body.objectID;
+    product.slug = body.slug || body.objectID;
+    product.variants = [...body.variants || []].map((variant) => this.parseVariant(variant, body, reqCtx));
+    return this.assert(product);
+  }
+  parseVariant(variant, product, reqCtx) {
+    const result = ProductSearchResultItemVariantSchema.parse({
+      variant: {
+        sku: variant.variantID
+      },
+      image: ImageSchema.parse({
+        sourceUrl: variant.image,
+        altText: product.name || ""
+      })
+    });
+    return result;
+  }
+  parsePaginatedResult(body, reqCtx) {
+    const items = body.hits.map((hit) => this.parseSingle(hit, reqCtx));
+    const facets = [];
+    for (const id in body.facets) {
+      const f = body.facets[id];
+      const facetId = FacetIdentifierSchema.parse({
+        key: id
+      });
+      const facet = this.parseFacet(facetId, f, reqCtx);
+      facets.push(facet);
+    }
+    const result = createPaginatedResponseSchema(this.schema).parse({
+      meta: {
+        cache: { hit: false, key: "unknown" },
+        placeholder: false
+      },
+      pageNumber: (body.page || 0) + 1,
+      pageSize: body.hitsPerPage,
+      totalCount: body.nbHits,
+      totalPages: body.nbPages,
+      items
+    });
+    result.facets = facets;
+    return result;
+  }
+  parseFacet(facetIdentifier, facetValues, reqCtx) {
+    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, reqCtx));
+    }
+    return result;
+  }
+  parseFacetValue(facetValueIdentifier, label, count, reqCtx) {
+    return ProductSearchResultFacetValueSchema.parse({
+      identifier: facetValueIdentifier,
+      name: label,
+      count,
+      active: false
+    });
+  }
+}
+export {
+  AlgoliaSearchProvider
+};

package/schema/capabilities.schema.js

@@ -1,7 +1,7 @@
 import { CapabilitiesSchema } from "@reactionary/core";
 const AlgoliaCapabilitiesSchema = CapabilitiesSchema.pick({
   product: true,
-  search: true,
+  productSearch: true,
   analytics: true
 }).partial();
 export {

package/schema/index.js

@@ -0,0 +1,3 @@
+export * from "./capabilities.schema.js";
+export * from "./configuration.schema.js";
+export * from "./search.schema.js";

package/schema/search.schema.js

@@ -1,10 +1,10 @@
-import { SearchIdentifierSchema, SearchResultSchema } from "@reactionary/core";
+import { ProductSearchIdentifierSchema, ProductSearchResultSchema } from "@reactionary/core";
 import { z } from "zod";
-const AlgoliaSearchIdentifierSchema = SearchIdentifierSchema.extend({
+const AlgoliaSearchIdentifierSchema = ProductSearchIdentifierSchema.extend({
   key: z.string().default(""),
   index: z.string().default("")
 });
-const AlgoliaSearchResultSchema = SearchResultSchema.extend({
+const AlgoliaSearchResultSchema = ProductSearchResultSchema.extend({
   identifier: AlgoliaSearchIdentifierSchema.default(() => AlgoliaSearchIdentifierSchema.parse({}))
 });
 export {

package/src/index.d.ts

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

package/src/providers/index.d.ts

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

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

@@ -0,0 +1,40 @@
+import { type Cache, type FacetIdentifier, type FacetValueIdentifier, ProductSearchProvider, type ProductSearchQueryByTerm, type ProductSearchResult, type ProductSearchResultFacet, type ProductSearchResultFacetValue, type ProductSearchResultItem, type ProductSearchResultItemVariant, type RequestContext } from '@reactionary/core';
+import { type SearchResponse } from 'algoliasearch';
+import type { z } from 'zod';
+import type { AlgoliaConfiguration } from '../schema/configuration.schema.js';
+interface AlgoliaNativeVariant {
+    variantID: string;
+    image: string;
+}
+interface AlgoliaNativeRecord {
+    objectID: string;
+    slug?: string;
+    name?: string;
+    variants: Array<AlgoliaNativeVariant>;
+}
+export declare class AlgoliaSearchProvider<T extends ProductSearchResultItem = ProductSearchResultItem> extends ProductSearchProvider<T> {
+    protected config: AlgoliaConfiguration;
+    constructor(config: AlgoliaConfiguration, schema: z.ZodType<T>, cache: Cache);
+    queryByTerm(payload: ProductSearchQueryByTerm, reqCtx: RequestContext): Promise<ProductSearchResult>;
+    protected parseSingle(body: AlgoliaNativeRecord, reqCtx: RequestContext): T;
+    protected parseVariant(variant: AlgoliaNativeVariant, product: AlgoliaNativeRecord, reqCtx: RequestContext): ProductSearchResultItemVariant;
+    protected parsePaginatedResult(body: SearchResponse<AlgoliaNativeRecord>, reqCtx: RequestContext): {
+        meta: {
+            [x: string]: unknown;
+            cache: {
+                [x: string]: unknown;
+                hit: boolean;
+                key: string;
+            };
+            placeholder: boolean;
+        };
+        pageNumber: number;
+        pageSize: number;
+        totalCount: number;
+        totalPages: number;
+        items: T[];
+    };
+    protected parseFacet(facetIdentifier: FacetIdentifier, facetValues: Record<string, number>, reqCtx: RequestContext): ProductSearchResultFacet;
+    protected parseFacetValue(facetValueIdentifier: FacetValueIdentifier, label: string, count: number, reqCtx: RequestContext): ProductSearchResultFacetValue;
+}
+export {};

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

@@ -2,6 +2,6 @@ import type { z } from 'zod';
 export declare const AlgoliaCapabilitiesSchema: z.ZodObject<{
     product: z.ZodOptional<z.ZodBoolean>;
     analytics: z.ZodOptional<z.ZodBoolean>;
-    search: z.ZodOptional<z.ZodBoolean>;
+    productSearch: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$loose>;
 export type AlgoliaCapabilities = z.infer<typeof AlgoliaCapabilitiesSchema>;

package/src/schema/index.d.ts

@@ -0,0 +1,3 @@
+export * from './capabilities.schema.js';
+export * from './configuration.schema.js';
+export * from './search.schema.js';

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

@@ -1,14 +1,17 @@
 import { z } from 'zod';
 export declare const AlgoliaSearchIdentifierSchema: z.ZodObject<{
     term: z.ZodDefault<z.ZodString>;
-    page: z.ZodDefault<z.ZodNumber>;
-    pageSize: z.ZodDefault<z.ZodNumber>;
     facets: z.ZodDefault<z.ZodArray<z.ZodObject<{
         facet: z.ZodNonOptional<z.ZodDefault<z.ZodObject<{
             key: z.ZodNonOptional<z.ZodDefault<z.ZodString>>;
         }, z.core.$loose>>>;
         key: z.ZodNonOptional<z.ZodDefault<z.ZodString>>;
-    }, z.core.$loose>>>;
+    }, z.core.$strip>>>;
+    filters: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    paginationOptions: z.ZodDefault<z.ZodObject<{
+        pageNumber: z.ZodDefault<z.ZodNumber>;
+        pageSize: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$loose>>;
     key: z.ZodDefault<z.ZodString>;
     index: z.ZodDefault<z.ZodString>;
 }, z.core.$loose>;
@@ -20,15 +23,50 @@ export declare const AlgoliaSearchResultSchema: z.ZodObject<{
         }, z.core.$loose>>;
         placeholder: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$loose>>;
-    products: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    pageNumber: z.ZodNumber;
+    pageSize: z.ZodNumber;
+    totalCount: z.ZodNumber;
+    totalPages: z.ZodNumber;
+    items: z.ZodArray<z.ZodObject<{
+        meta: z.ZodDefault<z.ZodObject<{
+            cache: z.ZodDefault<z.ZodObject<{
+                hit: z.ZodDefault<z.ZodBoolean>;
+                key: z.ZodDefault<z.ZodString>;
+            }, z.core.$loose>>;
+            placeholder: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$loose>>;
         identifier: z.ZodDefault<z.ZodObject<{
             key: z.ZodDefault<z.ZodString>;
         }, z.core.$loose>>;
         name: z.ZodDefault<z.ZodString>;
-        image: z.ZodDefault<z.ZodString>;
         slug: z.ZodDefault<z.ZodString>;
-    }, z.core.$loose>>>;
-    pages: z.ZodDefault<z.ZodNumber>;
+        variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            variant: z.ZodDefault<z.ZodObject<{
+                sku: z.ZodNonOptional<z.ZodDefault<z.ZodString>>;
+            }, z.core.$loose>>;
+            image: z.ZodDefault<z.ZodObject<{
+                sourceUrl: z.ZodDefault<z.ZodString>;
+                altText: z.ZodDefault<z.ZodString>;
+                width: z.ZodOptional<z.ZodNumber>;
+                height: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$loose>>;
+            options: z.ZodOptional<z.ZodObject<{
+                identifier: z.ZodDefault<z.ZodObject<{
+                    key: z.ZodDefault<z.ZodString>;
+                }, z.core.$loose>>;
+                name: z.ZodString;
+                value: z.ZodDefault<z.ZodObject<{
+                    identifier: z.ZodDefault<z.ZodObject<{
+                        option: z.ZodDefault<z.ZodObject<{
+                            key: z.ZodDefault<z.ZodString>;
+                        }, z.core.$loose>>;
+                        key: z.ZodDefault<z.ZodString>;
+                    }, z.core.$loose>>;
+                    label: z.ZodString;
+                }, z.core.$loose>>;
+            }, z.core.$loose>>;
+        }, z.core.$loose>>>;
+    }, z.core.$loose>>;
     facets: z.ZodDefault<z.ZodArray<z.ZodObject<{
         identifier: z.ZodDefault<z.ZodObject<{
             key: z.ZodNonOptional<z.ZodDefault<z.ZodString>>;
@@ -40,7 +78,7 @@ export declare const AlgoliaSearchResultSchema: z.ZodObject<{
                     key: z.ZodNonOptional<z.ZodDefault<z.ZodString>>;
                 }, z.core.$loose>>;
                 key: z.ZodDefault<z.ZodString>;
-            }, z.core.$loose>>;
+            }, z.core.$strip>>;
             name: z.ZodDefault<z.ZodString>;
             count: z.ZodDefault<z.ZodNumber>;
             active: z.ZodDefault<z.ZodBoolean>;
@@ -48,17 +86,20 @@ export declare const AlgoliaSearchResultSchema: z.ZodObject<{
     }, z.core.$loose>>>;
     identifier: z.ZodDefault<z.ZodObject<{
         term: z.ZodDefault<z.ZodString>;
-        page: z.ZodDefault<z.ZodNumber>;
-        pageSize: z.ZodDefault<z.ZodNumber>;
         facets: z.ZodDefault<z.ZodArray<z.ZodObject<{
             facet: z.ZodNonOptional<z.ZodDefault<z.ZodObject<{
                 key: z.ZodNonOptional<z.ZodDefault<z.ZodString>>;
             }, z.core.$loose>>>;
             key: z.ZodNonOptional<z.ZodDefault<z.ZodString>>;
-        }, z.core.$loose>>>;
+        }, z.core.$strip>>>;
+        filters: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        paginationOptions: z.ZodDefault<z.ZodObject<{
+            pageNumber: z.ZodDefault<z.ZodNumber>;
+            pageSize: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$loose>>;
         key: z.ZodDefault<z.ZodString>;
         index: z.ZodDefault<z.ZodString>;
     }, z.core.$loose>>;
-}, z.core.$loose>;
+}, z.core.$strip>;
 export type AlgoliaSearchResult = z.infer<typeof AlgoliaSearchResultSchema>;
 export type AlgoliaSearchIdentifier = z.infer<typeof AlgoliaSearchIdentifierSchema>;

package/providers/search.provider.js

@@ -1,78 +0,0 @@
-import {
-  SearchProvider
-} from "@reactionary/core";
-import { algoliasearch } from "algoliasearch";
-class AlgoliaSearchProvider extends SearchProvider {
-  constructor(config, schema, cache) {
-    super(schema, cache);
-    this.config = config;
-  }
-  async queryByTerm(payload, _reqCtx) {
-    const client = algoliasearch(this.config.appId, this.config.apiKey);
-    const remote = await client.search({
-      requests: [
-        {
-          indexName: this.config.indexName,
-          query: payload.search.term,
-          page: payload.search.page,
-          hitsPerPage: payload.search.pageSize,
-          facets: ["*"],
-          analytics: true,
-          clickAnalytics: true,
-          facetFilters: payload.search.facets.map(
-            (x) => `${encodeURIComponent(x.facet.key)}:${x.key}`
-          )
-        }
-      ]
-    });
-    return this.parseSearchResult(remote, payload);
-  }
-  parseSearchResult(remote, payload) {
-    const result = this.newModel();
-    const remoteData = remote;
-    const remoteProducts = remoteData.results[0];
-    for (const id in remoteProducts.facets) {
-      const f = remoteProducts.facets[id];
-      const facet = {
-        identifier: { key: id },
-        name: id,
-        values: []
-      };
-      for (const vid in f) {
-        const fv = f[vid];
-        const isActive = payload.search.facets.find(
-          (x) => x.facet.key === id && x.key === vid
-        );
-        facet.values.push({
-          identifier: { key: vid, facet: { key: id } },
-          count: fv,
-          name: vid,
-          active: !!isActive
-        });
-      }
-      result.facets.push(facet);
-    }
-    for (const p of remoteProducts.hits) {
-      result.products.push({
-        identifier: { key: p.objectID },
-        slug: p.slug,
-        name: p.name,
-        image: p.image
-      });
-    }
-    result.identifier = {
-      ...payload.search,
-      index: remoteProducts.index,
-      key: remoteProducts.queryID
-    };
-    result.pages = remoteProducts.nbPages;
-    result.meta = {
-      cache: { hit: false, key: payload.search.term },
-      placeholder: false
-    };
-    return this.assert(result);
-  }
-}
-export {
-  AlgoliaSearchProvider
-};

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

@@ -1,9 +0,0 @@
-import { type SearchQueryByTerm, type SearchResult, type RequestContext, type Cache, SearchProvider } from '@reactionary/core';
-import type { z } from 'zod';
-import type { AlgoliaConfiguration } from '../schema/configuration.schema.js';
-export declare class AlgoliaSearchProvider<T extends SearchResult = SearchResult> extends SearchProvider<T> {
-    protected config: AlgoliaConfiguration;
-    constructor(config: AlgoliaConfiguration, schema: z.ZodType<T>, cache: Cache);
-    queryByTerm(payload: SearchQueryByTerm, _reqCtx: RequestContext): Promise<SearchResult>;
-    protected parseSearchResult(remote: unknown, payload: SearchQueryByTerm): T;
-}