@reactionary/provider-algolia 0.0.61 → 0.0.63

package/core/initialize.js

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

package/index.js

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

package/providers/index.js

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

package/providers/product-search.provider.js

@@ -11,11 +11,11 @@ import {
 import { algoliasearch } from "algoliasearch";
 import { AlgoliaSearchIdentifierSchema } from "../schema/search.schema.js";
 class AlgoliaSearchProvider extends ProductSearchProvider {
-  constructor(config, schema, cache) {
-    super(schema, cache);
+  constructor(config, schema, cache, context) {
+    super(schema, cache, context);
     this.config = config;
   }
-  async queryByTerm(payload, reqCtx) {
+  async queryByTerm(payload) {
     const client = algoliasearch(this.config.appId, this.config.apiKey);
     const remote = await client.search({
       requests: [
@@ -40,7 +40,7 @@ class AlgoliaSearchProvider extends ProductSearchProvider {
       index: input.index,
       key: input.queryID
     });
-    const result = this.parsePaginatedResult(input, reqCtx);
+    const result = this.parsePaginatedResult(input);
     result.identifier = identifier;
     for (const selectedFacet of payload.search.facets) {
       const facet = result.facets.find((f) => f.identifier.key === selectedFacet.facet.key);
@@ -57,15 +57,15 @@ class AlgoliaSearchProvider extends ProductSearchProvider {
     };
     return result;
   }
-  parseSingle(body, reqCtx) {
+  parseSingle(body) {
     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));
+    product.variants = [...body.variants || []].map((variant) => this.parseVariant(variant, body));
     return this.assert(product);
   }
-  parseVariant(variant, product, reqCtx) {
+  parseVariant(variant, product) {
     const result = ProductSearchResultItemVariantSchema.parse({
       variant: {
         sku: variant.variantID
@@ -77,15 +77,15 @@ class AlgoliaSearchProvider extends ProductSearchProvider {
     });
     return result;
   }
-  parsePaginatedResult(body, reqCtx) {
-    const items = body.hits.map((hit) => this.parseSingle(hit, reqCtx));
+  parsePaginatedResult(body) {
+    const items = body.hits.map((hit) => this.parseSingle(hit));
     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);
+      const facet = this.parseFacet(facetId, f);
       facets.push(facet);
     }
     const result = createPaginatedResponseSchema(this.schema).parse({
@@ -102,7 +102,7 @@ class AlgoliaSearchProvider extends ProductSearchProvider {
     result.facets = facets;
     return result;
   }
-  parseFacet(facetIdentifier, facetValues, reqCtx) {
+  parseFacet(facetIdentifier, facetValues) {
     const result = ProductSearchResultFacetSchema.parse({
       identifier: facetIdentifier,
       name: facetIdentifier.key,
@@ -114,11 +114,11 @@ class AlgoliaSearchProvider extends ProductSearchProvider {
         facet: facetIdentifier,
         key: vid
       });
-      result.values.push(this.parseFacetValue(facetValueIdentifier, vid, fv, reqCtx));
+      result.values.push(this.parseFacetValue(facetValueIdentifier, vid, fv));
     }
     return result;
   }
-  parseFacetValue(facetValueIdentifier, label, count, reqCtx) {
+  parseFacetValue(facetValueIdentifier, label, count) {
     return ProductSearchResultFacetValueSchema.parse({
       identifier: facetValueIdentifier,
       name: label,

package/schema/capabilities.schema.js

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

package/src/core/initialize.d.ts

@@ -1,4 +1,8 @@
-import type { Client, Cache } from "@reactionary/core";
+import type { Cache, ProductSearchProvider, RequestContext } from "@reactionary/core";
 import type { AlgoliaCapabilities } from "../schema/capabilities.schema.js";
 import type { AlgoliaConfiguration } from "../schema/configuration.schema.js";
-export declare function withAlgoliaCapabilities(configuration: AlgoliaConfiguration, capabilities: AlgoliaCapabilities): (cache: Cache) => Partial<Client>;
+type AlgoliaClient<T extends AlgoliaCapabilities> = (T['productSearch'] extends true ? {
+    productSearch: ProductSearchProvider;
+} : object);
+export declare function withAlgoliaCapabilities<T extends AlgoliaCapabilities>(configuration: AlgoliaConfiguration, capabilities: T): (cache: Cache, context: RequestContext) => AlgoliaClient<T>;
+export {};

package/src/index.d.ts

@@ -1,5 +1,4 @@
 export * from './core/initialize.js';
-export * from './providers/product.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

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

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

@@ -14,11 +14,11 @@ interface AlgoliaNativeRecord {
 }
 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): {
+    constructor(config: AlgoliaConfiguration, schema: z.ZodType<T>, cache: Cache, context: RequestContext);
+    queryByTerm(payload: ProductSearchQueryByTerm): Promise<ProductSearchResult>;
+    protected parseSingle(body: AlgoliaNativeRecord): T;
+    protected parseVariant(variant: AlgoliaNativeVariant, product: AlgoliaNativeRecord): ProductSearchResultItemVariant;
+    protected parsePaginatedResult(body: SearchResponse<AlgoliaNativeRecord>): {
         meta: {
             [x: string]: unknown;
             cache: {
@@ -34,7 +34,7 @@ export declare class AlgoliaSearchProvider<T extends ProductSearchResultItem = P
         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;
+    protected parseFacet(facetIdentifier: FacetIdentifier, facetValues: Record<string, number>): ProductSearchResultFacet;
+    protected parseFacetValue(facetValueIdentifier: FacetValueIdentifier, label: string, count: number): ProductSearchResultFacetValue;
 }
 export {};

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

@@ -1,6 +1,5 @@
 import type { z } from 'zod';
 export declare const AlgoliaCapabilitiesSchema: z.ZodObject<{
-    product: z.ZodOptional<z.ZodBoolean>;
     analytics: z.ZodOptional<z.ZodBoolean>;
     productSearch: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$loose>;

package/providers/product.provider.js

@@ -1,39 +0,0 @@
-import {
-  ProductProvider
-} from "@reactionary/core";
-class AlgoliaProductProvider extends ProductProvider {
-  constructor(config, schema, cache) {
-    super(schema, cache);
-    this.config = config;
-  }
-  async getById(payload, _reqCtx) {
-    const result = this.newModel();
-    result.identifier = { key: payload.id };
-    result.name = `Algolia Product ${payload.id}`;
-    result.slug = payload.id;
-    result.description = "Product from Algolia";
-    result.meta = {
-      cache: { hit: false, key: payload.id },
-      placeholder: true
-    };
-    return this.assert(result);
-  }
-  async getBySlug(payload, _reqCtx) {
-    const result = this.newModel();
-    result.identifier = { key: payload.slug };
-    result.name = `Algolia Product ${payload.slug}`;
-    result.slug = payload.slug;
-    result.description = "Product from Algolia";
-    result.meta = {
-      cache: { hit: false, key: payload.slug },
-      placeholder: true
-    };
-    return this.assert(result);
-  }
-  getBySKU(payload, reqCtx) {
-    throw new Error("Method not implemented.");
-  }
-}
-export {
-  AlgoliaProductProvider
-};

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

@@ -1,11 +0,0 @@
-import type { Product, ProductQueryById, ProductQueryBySlug, RequestContext, Cache, ProductQueryBySKU } from '@reactionary/core';
-import { ProductProvider } from '@reactionary/core';
-import type { z } from 'zod';
-import type { AlgoliaConfiguration } from '../schema/configuration.schema.js';
-export declare class AlgoliaProductProvider<T extends Product = Product> extends ProductProvider<T> {
-    protected config: AlgoliaConfiguration;
-    constructor(config: AlgoliaConfiguration, schema: z.ZodType<T>, cache: Cache);
-    getById(payload: ProductQueryById, _reqCtx: RequestContext): Promise<T>;
-    getBySlug(payload: ProductQueryBySlug, _reqCtx: RequestContext): Promise<T>;
-    getBySKU(payload: ProductQueryBySKU, reqCtx: RequestContext): Promise<T>;
-}