@reactionary/provider-algolia 0.0.30 → 0.0.32

package/index.js

@@ -1,244 +1,16 @@
 // core/src/cache/redis-cache.ts
 import { Redis } from "@upstash/redis";
 
-// otel/src/trpc-middleware.ts
-import { TRPCError } from "@trpc/server";
-import {
-  SpanKind as SpanKind2,
-  SpanStatusCode as SpanStatusCode3
-} from "@opentelemetry/api";
-
-// otel/src/tracer.ts
-import {
-  trace,
-  SpanStatusCode,
-  context as otelContext
-} from "@opentelemetry/api";
-
-// otel/src/sdk.ts
-import { NodeSDK } from "@opentelemetry/sdk-node";
-var sdk = null;
-var isInitialized = false;
-var initializationPromise = null;
-function isBrowser() {
-  return typeof window !== "undefined" && typeof process === "undefined";
-}
-function ensureInitialized() {
-  if (isInitialized || initializationPromise) {
-    return;
-  }
-  if (isBrowser()) {
-    isInitialized = true;
-    return;
-  }
-  initializationPromise = Promise.resolve().then(() => {
-    sdk = new NodeSDK();
-    sdk.start();
-    isInitialized = true;
-    process.on("SIGTERM", async () => {
-      try {
-        await shutdownOtel();
-        if (process.env["OTEL_LOG_LEVEL"] === "debug") {
-          console.log("OpenTelemetry terminated successfully");
-        }
-      } catch (error) {
-        console.error("Error terminating OpenTelemetry", error);
-      }
-    });
-  });
-}
-async function shutdownOtel() {
-  if (sdk) {
-    await sdk.shutdown();
-    sdk = null;
-    isInitialized = false;
-  }
-}
-function isOtelInitialized() {
-  ensureInitialized();
-  return isInitialized;
-}
-
-// otel/src/tracer.ts
-import { SpanKind, SpanStatusCode as SpanStatusCode2 } from "@opentelemetry/api";
-var TRACER_NAME = "@reactionary/otel";
-var TRACER_VERSION = "0.0.1";
-var globalTracer = null;
-function getTracer() {
-  if (!globalTracer) {
-    isOtelInitialized();
-    globalTracer = trace.getTracer(TRACER_NAME, TRACER_VERSION);
-  }
-  return globalTracer;
-}
-function withSpan(name, fn, options) {
-  const tracer = getTracer();
-  return tracer.startActiveSpan(name, options || {}, async (span) => {
-    try {
-      const result = await fn(span);
-      span.setStatus({ code: SpanStatusCode.OK });
-      return result;
-    } catch (error) {
-      span.setStatus({
-        code: SpanStatusCode.ERROR,
-        message: error instanceof Error ? error.message : String(error)
-      });
-      if (error instanceof Error) {
-        span.recordException(error);
-      }
-      throw error;
-    } finally {
-      span.end();
-    }
-  });
-}
-function setSpanAttributes(span, attributes) {
-  Object.entries(attributes).forEach(([key, value]) => {
-    if (value !== void 0 && value !== null) {
-      span.setAttribute(key, value);
-    }
-  });
-}
-
-// otel/src/metrics.ts
-import { metrics } from "@opentelemetry/api";
-var METER_NAME = "@reactionary/otel";
-var METER_VERSION = "0.0.1";
-var globalMeter = null;
-function getMeter() {
-  if (!globalMeter) {
-    isOtelInitialized();
-    globalMeter = metrics.getMeter(METER_NAME, METER_VERSION);
-  }
-  return globalMeter;
-}
-var metricsInstance = null;
-function initializeMetrics() {
-  if (metricsInstance) {
-    return metricsInstance;
-  }
-  const meter = getMeter();
-  metricsInstance = {
-    requestCounter: meter.createCounter("reactionary.requests", {
-      description: "Total number of requests"
-    }),
-    requestDuration: meter.createHistogram("reactionary.request.duration", {
-      description: "Request duration in milliseconds",
-      unit: "ms"
-    }),
-    activeRequests: meter.createUpDownCounter("reactionary.requests.active", {
-      description: "Number of active requests"
-    }),
-    errorCounter: meter.createCounter("reactionary.errors", {
-      description: "Total number of errors"
-    }),
-    providerCallCounter: meter.createCounter("reactionary.provider.calls", {
-      description: "Total number of provider calls"
-    }),
-    providerCallDuration: meter.createHistogram("reactionary.provider.duration", {
-      description: "Provider call duration in milliseconds",
-      unit: "ms"
-    }),
-    cacheHitCounter: meter.createCounter("reactionary.cache.hits", {
-      description: "Total number of cache hits"
-    }),
-    cacheMissCounter: meter.createCounter("reactionary.cache.misses", {
-      description: "Total number of cache misses"
-    })
-  };
-  return metricsInstance;
-}
-function getMetrics() {
-  if (!metricsInstance) {
-    return initializeMetrics();
-  }
-  return metricsInstance;
-}
-
-// otel/src/provider-instrumentation.ts
-import { SpanKind as SpanKind3 } from "@opentelemetry/api";
-async function withProviderSpan(options, fn) {
-  const { providerName, operationType, operationName, attributes = {} } = options;
-  const metrics2 = getMetrics();
-  const spanName = `provider.${providerName}.${operationType}${operationName ? `.${operationName}` : ""}`;
-  const startTime = Date.now();
-  metrics2.providerCallCounter.add(1, {
-    "provider.name": providerName,
-    "provider.operation.type": operationType,
-    "provider.operation.name": operationName || "unknown"
-  });
-  return withSpan(
-    spanName,
-    async (span) => {
-      setSpanAttributes(span, {
-        "provider.name": providerName,
-        "provider.operation.type": operationType,
-        "provider.operation.name": operationName,
-        ...attributes
-      });
-      try {
-        const result = await fn(span);
-        const duration = Date.now() - startTime;
-        metrics2.providerCallDuration.record(duration, {
-          "provider.name": providerName,
-          "provider.operation.type": operationType,
-          "provider.operation.name": operationName || "unknown",
-          "status": "success"
-        });
-        return result;
-      } catch (error) {
-        const duration = Date.now() - startTime;
-        metrics2.providerCallDuration.record(duration, {
-          "provider.name": providerName,
-          "provider.operation.type": operationType,
-          "provider.operation.name": operationName || "unknown",
-          "status": "error"
-        });
-        metrics2.errorCounter.add(1, {
-          "provider.name": providerName,
-          "provider.operation.type": operationType,
-          "provider.operation.name": operationName || "unknown"
-        });
-        throw error;
-      }
-    },
-    { kind: SpanKind3.CLIENT }
-  );
-}
-function createProviderInstrumentation(providerName) {
-  return {
-    traceQuery: (operationName, fn, attributes) => {
-      return withProviderSpan(
-        {
-          providerName,
-          operationType: "query",
-          operationName,
-          attributes
-        },
-        fn
-      );
-    },
-    traceMutation: (operationName, fn, attributes) => {
-      return withProviderSpan(
-        {
-          providerName,
-          operationType: "mutation",
-          operationName,
-          attributes
-        },
-        fn
-      );
-    }
-  };
-}
+// core/src/decorators/trpc.decorators.ts
+import "reflect-metadata";
+var TRPC_QUERY_METADATA_KEY = Symbol("trpc:query");
+var TRPC_MUTATION_METADATA_KEY = Symbol("trpc:mutation");
 
 // core/src/providers/base.provider.ts
 var BaseProvider = class {
-  constructor(schema, querySchema, mutationSchema) {
+  constructor(schema, cache) {
     this.schema = schema;
-    this.querySchema = querySchema;
-    this.mutationSchema = mutationSchema;
-    this.instrumentation = createProviderInstrumentation(this.constructor.name);
+    this.cache = cache;
   }
   /**
    * Validates that the final domain model constructed by the provider
@@ -254,41 +26,12 @@ var BaseProvider = class {
     return this.schema.parse({});
   }
   /**
-   * Retrieves a set of entities matching the list of queries. The size of
-   * the resulting list WILL always match the size of the query list. The
-   * result list will never contain nulls or undefined. The order
-   * of the results will match the order of the queries.
+   * Handler for parsing a response from a remote provider and converting it
+   * into the typed domain model.
    */
-  async query(queries, session) {
-    return this.instrumentation.traceQuery(
-      "query",
-      async (span) => {
-        span.setAttribute("provider.query.count", queries.length);
-        const results = await this.fetch(queries, session);
-        for (const result of results) {
-          this.assert(result);
-        }
-        span.setAttribute("provider.result.count", results.length);
-        return results;
-      },
-      { queryCount: queries.length }
-    );
-  }
-  /**
-   * Executes the listed mutations in order and returns the final state
-   * resulting from that set of operations.
-   */
-  async mutate(mutations, session) {
-    return this.instrumentation.traceMutation(
-      "mutate",
-      async (span) => {
-        span.setAttribute("provider.mutation.count", mutations.length);
-        const result = await this.process(mutations, session);
-        this.assert(result);
-        return result;
-      },
-      { mutationCount: mutations.length }
-    );
+  parseSingle(_body) {
+    const model = this.newModel();
+    return this.assert(model);
   }
 };
 
@@ -645,42 +388,32 @@ var SearchResultSchema = BaseModelSchema.extend({
 
 // core/src/schemas/mutations/base.mutation.ts
 import { z as z12 } from "zod";
-var BaseMutationSchema = z12.looseInterface({
-  mutation: z12.ZodLiteral
-});
+var BaseMutationSchema = z12.looseInterface({});
 
 // core/src/schemas/mutations/cart.mutation.ts
 import { z as z13 } from "zod";
 var CartMutationItemAddSchema = BaseMutationSchema.extend({
-  mutation: z13.literal("add"),
   cart: CartIdentifierSchema.required(),
   product: ProductIdentifierSchema.required(),
   quantity: z13.number()
 });
 var CartMutationItemRemoveSchema = BaseMutationSchema.extend({
-  mutation: z13.literal("remove"),
   cart: CartIdentifierSchema.required(),
   item: CartItemIdentifierSchema.required()
 });
 var CartMutationItemQuantityChangeSchema = BaseMutationSchema.extend({
-  mutation: z13.literal("adjustQuantity"),
   cart: CartIdentifierSchema.required(),
   item: CartItemIdentifierSchema.required(),
   quantity: z13.number()
 });
-var CartMutationSchema = z13.union([CartMutationItemAddSchema, CartMutationItemRemoveSchema, CartMutationItemQuantityChangeSchema]);
 
 // core/src/schemas/mutations/identity.mutation.ts
 import { z as z14 } from "zod";
 var IdentityMutationLoginSchema = BaseMutationSchema.extend({
-  mutation: z14.literal("login"),
   username: z14.string(),
   password: z14.string()
 });
-var IdentityMutationLogoutSchema = BaseMutationSchema.extend({
-  mutation: z14.literal("logout")
-});
-var IdentityMutationSchema = z14.union([IdentityMutationLoginSchema, IdentityMutationLogoutSchema]);
+var IdentityMutationLogoutSchema = BaseMutationSchema.extend({});
 
 // core/src/schemas/mutations/inventory.mutation.ts
 import { z as z15 } from "zod";
@@ -700,162 +433,154 @@ var SearchMutationSchema = z18.union([]);
 
 // core/src/schemas/queries/base.query.ts
 import { z as z19 } from "zod";
-var BaseQuerySchema = z19.looseInterface({
-  query: z19.ZodLiteral
-});
+var BaseQuerySchema = z19.looseInterface({});
 
 // core/src/schemas/queries/cart.query.ts
 import { z as z20 } from "zod";
 var CartQueryByIdSchema = BaseQuerySchema.extend({
-  query: z20.literal("id"),
   cart: CartIdentifierSchema.required()
 });
 var CartQuerySchema = z20.union([CartQueryByIdSchema]);
 
 // core/src/schemas/queries/identity.query.ts
-import { z as z21 } from "zod";
-var IdentityQuerySelfSchema = BaseQuerySchema.extend({
-  query: z21.literal("self")
-});
-var IdentityQuerySchema = z21.union([IdentityQuerySelfSchema]);
+var IdentityQuerySelfSchema = BaseQuerySchema.extend({});
 
 // core/src/schemas/queries/inventory.query.ts
-import { z as z22 } from "zod";
+import { z as z21 } from "zod";
 var InventoryQuerySchema = BaseQuerySchema.extend({
-  query: z22.literal("sku"),
-  sku: z22.string()
+  sku: z21.string()
 });
 
 // core/src/schemas/queries/price.query.ts
-import { z as z23 } from "zod";
 var PriceQueryBySkuSchema = BaseQuerySchema.extend({
-  query: z23.literal("sku"),
   sku: SKUIdentifierSchema.required()
 });
-var PriceQuerySchema = z23.union([PriceQueryBySkuSchema]);
 
 // core/src/schemas/queries/product.query.ts
-import { z as z24 } from "zod";
+import { z as z22 } from "zod";
 var ProductQueryBySlugSchema = BaseQuerySchema.extend({
-  query: z24.literal("slug"),
-  slug: z24.string()
+  slug: z22.string()
 });
 var ProductQueryByIdSchema = BaseQuerySchema.extend({
-  query: z24.literal("id"),
-  id: z24.string()
+  id: z22.string()
 });
-var ProductQuerySchema = z24.union([ProductQueryBySlugSchema, ProductQueryByIdSchema]);
 
 // core/src/schemas/queries/search.query.ts
-import { z as z25 } from "zod";
 var SearchQueryByTermSchema = BaseQuerySchema.extend({
-  query: z25.literal("term"),
   search: SearchIdentifierSchema.required()
 });
-var SearchQuerySchema = z25.union([SearchQueryByTermSchema]);
 
 // providers/algolia/src/providers/product.provider.ts
 var AlgoliaProductProvider = class extends ProductProvider {
-  constructor(config, schema, querySchema, mutationSchema) {
-    super(schema, querySchema, mutationSchema);
+  constructor(config, schema, cache) {
+    super(schema, cache);
     this.config = config;
   }
-  async fetch(queries, session) {
-    return [];
+  async getById(payload, _session) {
+    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);
   }
-  process(mutation, session) {
-    throw new Error("Method not implemented.");
+  async getBySlug(payload, _session) {
+    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);
   }
 };
 
 // providers/algolia/src/providers/search.provider.ts
 import { algoliasearch } from "algoliasearch";
 var AlgoliaSearchProvider = class extends SearchProvider {
-  constructor(config, schema, querySchema, mutationSchema) {
-    super(schema, querySchema, mutationSchema);
+  constructor(config, schema, cache) {
+    super(schema, cache);
     this.config = config;
   }
-  async fetch(queries, session) {
-    const results = [];
-    for (const query of queries) {
-      const result = await this.get(query.search);
-      results.push(result);
-    }
-    return results;
-  }
-  process(mutations, session) {
-    throw new Error("Method not implemented.");
-  }
-  async get(identifier) {
+  async queryByTerm(payload, _session) {
     const client = algoliasearch(this.config.appId, this.config.apiKey);
     const remote = await client.search({
       requests: [
         {
           indexName: this.config.indexName,
-          query: identifier.term,
-          page: identifier.page,
-          hitsPerPage: identifier.pageSize,
+          query: payload.search.term,
+          page: payload.search.page,
+          hitsPerPage: payload.search.pageSize,
           facets: ["*"],
           analytics: true,
           clickAnalytics: true,
-          facetFilters: identifier.facets.map(
+          facetFilters: payload.search.facets.map(
             (x) => `${encodeURIComponent(x.facet.key)}:${x.key}`
           )
         }
       ]
     });
-    const parsed = this.parse(remote, identifier);
-    return parsed;
+    return this.parseSearchResult(remote, payload);
   }
-  parse(remote, query) {
+  parseSearchResult(remote, payload) {
     const result = this.newModel();
-    const remoteProducts = remote.results[0];
+    const remoteData = remote;
+    const remoteProducts = remoteData.results[0];
     for (const id in remoteProducts.facets) {
       const f = remoteProducts.facets[id];
-      const facet = SearchResultFacetSchema.parse({});
-      facet.identifier.key = id;
-      facet.name = id;
+      const facet = {
+        identifier: { key: id },
+        name: id,
+        values: []
+      };
       for (const vid in f) {
         const fv = f[vid];
-        const facetValue = SearchResultFacetValueSchema.parse({});
-        facetValue.count = fv;
-        facetValue.name = vid;
-        facetValue.identifier.key = vid;
-        facetValue.identifier.facet = facet.identifier;
-        if (query.facets.find(
-          (x) => x.facet.key == facetValue.identifier.facet.key && x.key == facetValue.identifier.key
-        )) {
-          facetValue.active = true;
-        }
-        facet.values.push(facetValue);
+        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
-        },
+        identifier: { key: p.objectID },
         slug: p.slug,
         name: p.name,
         image: p.image
       });
     }
     result.identifier = {
-      ...query,
+      ...payload.search,
       index: remoteProducts.index,
       key: remoteProducts.queryID
     };
     result.pages = remoteProducts.nbPages;
-    return result;
+    result.meta = {
+      cache: { hit: false, key: payload.search.term },
+      placeholder: false
+    };
+    return this.assert(result);
   }
 };
 
 // providers/algolia/src/schema/search.schema.ts
-import { z as z26 } from "zod";
+import { z as z23 } from "zod";
 var AlgoliaSearchIdentifierSchema = SearchIdentifierSchema.extend({
-  key: z26.string().default(""),
-  index: z26.string().default("")
+  key: z23.string().default(""),
+  index: z23.string().default("")
 });
 var AlgoliaSearchResultSchema = SearchResultSchema.extend({
   identifier: AlgoliaSearchIdentifierSchema.default(() => AlgoliaSearchIdentifierSchema.parse({}))
@@ -863,22 +588,24 @@ var AlgoliaSearchResultSchema = SearchResultSchema.extend({
 
 // providers/algolia/src/core/initialize.ts
 function withAlgoliaCapabilities(configuration, capabilities) {
-  const client = {};
-  if (capabilities.product) {
-    client.product = new AlgoliaProductProvider(configuration, ProductSchema, ProductQuerySchema, ProductMutationSchema);
-  }
-  if (capabilities.search) {
-    client.search = new AlgoliaSearchProvider(configuration, AlgoliaSearchResultSchema, SearchQuerySchema, SearchMutationSchema);
-  }
-  return client;
+  return (cache) => {
+    const client = {};
+    if (capabilities.product) {
+      client.product = new AlgoliaProductProvider(configuration, ProductSchema, cache);
+    }
+    if (capabilities.search) {
+      client.search = new AlgoliaSearchProvider(configuration, AlgoliaSearchResultSchema, cache);
+    }
+    return client;
+  };
 }
 
 // providers/algolia/src/schema/configuration.schema.ts
-import { z as z27 } from "zod";
-var AlgoliaConfigurationSchema = z27.looseInterface({
-  appId: z27.string(),
-  apiKey: z27.string(),
-  indexName: z27.string()
+import { z as z24 } from "zod";
+var AlgoliaConfigurationSchema = z24.looseInterface({
+  appId: z24.string(),
+  apiKey: z24.string(),
+  indexName: z24.string()
 });
 
 // providers/algolia/src/schema/capabilities.schema.ts

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@reactionary/provider-algolia",
-  "version": "0.0.30",
+  "version": "0.0.32",
   "dependencies": {
-    "@reactionary/core": "0.0.30",
+    "@reactionary/core": "0.0.32",
     "algoliasearch": "^5.23.4",
     "zod": "4.0.0-beta.20250430T185432"
   }

package/src/core/initialize.d.ts

@@ -1,4 +1,4 @@
-import { Client } from "@reactionary/core";
+import { Client, Cache } from "@reactionary/core";
 import { AlgoliaCapabilities } from "../schema/capabilities.schema";
 import { AlgoliaConfiguration } from "../schema/configuration.schema";
-export declare function withAlgoliaCapabilities(configuration: AlgoliaConfiguration, capabilities: AlgoliaCapabilities): Partial<Client>;
+export declare function withAlgoliaCapabilities(configuration: AlgoliaConfiguration, capabilities: AlgoliaCapabilities): (cache: Cache) => Partial<Client>;

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

@@ -1,9 +1,9 @@
-import { BaseMutation, Product, ProductMutation, ProductProvider, ProductQuery, Session } from '@reactionary/core';
+import { Product, ProductProvider, ProductQueryById, ProductQueryBySlug, Session, Cache } from '@reactionary/core';
 import { z } from 'zod';
 import { AlgoliaConfiguration } from '../schema/configuration.schema';
-export declare class AlgoliaProductProvider<T extends Product = Product, Q extends ProductQuery = ProductQuery, M extends ProductMutation = ProductMutation> extends ProductProvider<T, Q, M> {
+export declare class AlgoliaProductProvider<T extends Product = Product> extends ProductProvider<T> {
     protected config: AlgoliaConfiguration;
-    constructor(config: AlgoliaConfiguration, schema: z.ZodType<T>, querySchema: z.ZodType<Q, Q>, mutationSchema: z.ZodType<M, M>);
-    protected fetch(queries: Q[], session: Session): Promise<T[]>;
-    protected process(mutation: BaseMutation[], session: Session): Promise<T>;
+    constructor(config: AlgoliaConfiguration, schema: z.ZodType<T>, cache: Cache);
+    getById(payload: ProductQueryById, _session: Session): Promise<T>;
+    getBySlug(payload: ProductQueryBySlug, _session: Session): Promise<T>;
 }

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

@@ -1,11 +1,9 @@
-import { SearchIdentifier, SearchMutation, SearchProvider, SearchQuery, SearchResult, Session } from '@reactionary/core';
+import { SearchProvider, SearchQueryByTerm, SearchResult, Session, Cache } from '@reactionary/core';
 import { z } from 'zod';
 import { AlgoliaConfiguration } from '../schema/configuration.schema';
-export declare class AlgoliaSearchProvider<T extends SearchResult = SearchResult, Q extends SearchQuery = SearchQuery, M extends SearchMutation = SearchMutation> extends SearchProvider<T, Q, M> {
+export declare class AlgoliaSearchProvider<T extends SearchResult = SearchResult> extends SearchProvider<T> {
     protected config: AlgoliaConfiguration;
-    constructor(config: AlgoliaConfiguration, schema: z.ZodType<T>, querySchema: z.ZodType<Q, Q>, mutationSchema: z.ZodType<M, M>);
-    protected fetch(queries: Q[], session: Session): Promise<T[]>;
-    protected process(mutations: M[], session: Session): Promise<T>;
-    protected get(identifier: SearchIdentifier): Promise<T>;
-    protected parse(remote: any, query: SearchIdentifier): T;
+    constructor(config: AlgoliaConfiguration, schema: z.ZodType<T>, cache: Cache);
+    queryByTerm(payload: SearchQueryByTerm, _session: Session): Promise<SearchResult>;
+    protected parseSearchResult(remote: unknown, payload: SearchQueryByTerm): T;
 }