@reactionary/provider-fake 0.0.29 → 0.0.31

package/index.js

@@ -1,181 +1,38 @@
 // core/src/cache/redis-cache.ts
 import { Redis } from "@upstash/redis";
 
-// otel/src/sdk.ts
-import { NodeSDK } from "@opentelemetry/sdk-node";
-import { resourceFromAttributes, defaultResource } from "@opentelemetry/resources";
-import { SEMRESATTRS_SERVICE_NAME, SEMRESATTRS_SERVICE_VERSION, SEMRESATTRS_DEPLOYMENT_ENVIRONMENT } from "@opentelemetry/semantic-conventions";
+// otel/src/trpc-middleware.ts
+import { TRPCError } from "@trpc/server";
 import {
-  BatchSpanProcessor
-} from "@opentelemetry/sdk-trace-base";
-import { HttpInstrumentation } from "@opentelemetry/instrumentation-http";
-import { ExpressInstrumentation } from "@opentelemetry/instrumentation-express";
+  SpanKind as SpanKind2,
+  SpanStatusCode as SpanStatusCode3
+} from "@opentelemetry/api";
 
-// otel/src/config.ts
-import { ConsoleSpanExporter } from "@opentelemetry/sdk-trace-base";
-import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
-import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
-import { PeriodicExportingMetricReader, ConsoleMetricExporter } from "@opentelemetry/sdk-metrics";
-function isBrowser() {
-  return typeof window !== "undefined" && typeof process === "undefined";
-}
-function getConfigFromEnv() {
-  if (isBrowser()) {
-    return {
-      serviceName: "browser-service",
-      serviceVersion: void 0,
-      environment: "browser",
-      otlpEndpoint: void 0,
-      otlpHeaders: void 0,
-      traceEnabled: false,
-      metricsEnabled: false,
-      metricExportIntervalMillis: 6e4
-    };
-  }
-  const tracesExporter = process.env["OTEL_TRACES_EXPORTER"] || "console";
-  const metricsExporter = process.env["OTEL_METRICS_EXPORTER"] || "console";
-  return {
-    serviceName: process.env["OTEL_SERVICE_NAME"] || "unknown_service",
-    serviceVersion: process.env["OTEL_SERVICE_VERSION"],
-    environment: process.env["DEPLOYMENT_ENVIRONMENT"] || process.env["NODE_ENV"] || "development",
-    otlpEndpoint: process.env["OTEL_EXPORTER_OTLP_ENDPOINT"],
-    otlpHeaders: process.env["OTEL_EXPORTER_OTLP_HEADERS"] ? parseHeaders(process.env["OTEL_EXPORTER_OTLP_HEADERS"]) : void 0,
-    traceEnabled: tracesExporter !== "none",
-    metricsEnabled: metricsExporter !== "none",
-    metricExportIntervalMillis: process.env["OTEL_METRIC_EXPORT_INTERVAL"] ? parseInt(process.env["OTEL_METRIC_EXPORT_INTERVAL"], 10) : 6e4
-    // Default 60 seconds per OTEL spec
-  };
-}
-function parseHeaders(headerString) {
-  const headers = {};
-  headerString.split(",").forEach((header) => {
-    const [key, value] = header.split("=");
-    if (key && value) {
-      headers[key.trim()] = value.trim();
-    }
-  });
-  return headers;
-}
-function createTraceExporter(config) {
-  if (!config.traceEnabled) {
-    return void 0;
-  }
-  const tracesExporter = process.env["OTEL_TRACES_EXPORTER"] || "console";
-  switch (tracesExporter) {
-    case "otlp":
-    case "otlp/http": {
-      if (!config.otlpEndpoint) {
-        console.warn("OTEL_EXPORTER_OTLP_ENDPOINT not set, falling back to console");
-        return new ConsoleSpanExporter();
-      }
-      const tracesEndpoint = process.env["OTEL_EXPORTER_OTLP_TRACES_ENDPOINT"] || `${config.otlpEndpoint}/v1/traces`;
-      return new OTLPTraceExporter({
-        url: tracesEndpoint,
-        headers: config.otlpHeaders
-      });
-    }
-    case "console":
-      return new ConsoleSpanExporter();
-    case "none":
-    default:
-      return void 0;
-  }
-}
-function createMetricReader(config) {
-  if (!config.metricsEnabled) {
-    return void 0;
-  }
-  const metricsExporter = process.env["OTEL_METRICS_EXPORTER"] || "console";
-  let exporter;
-  switch (metricsExporter) {
-    case "otlp":
-    case "otlp/http": {
-      if (!config.otlpEndpoint) {
-        console.warn("OTEL_EXPORTER_OTLP_ENDPOINT not set, falling back to console");
-        exporter = new ConsoleMetricExporter();
-      } else {
-        const metricsEndpoint = process.env["OTEL_EXPORTER_OTLP_METRICS_ENDPOINT"] || `${config.otlpEndpoint}/v1/metrics`;
-        exporter = new OTLPMetricExporter({
-          url: metricsEndpoint,
-          headers: config.otlpHeaders
-        });
-      }
-      break;
-    }
-    case "console":
-      exporter = new ConsoleMetricExporter();
-      break;
-    case "none":
-    default:
-      return void 0;
-  }
-  return new PeriodicExportingMetricReader({
-    exporter,
-    exportIntervalMillis: config.metricExportIntervalMillis
-  });
-}
+// 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 isBrowser2() {
+function isBrowser() {
   return typeof window !== "undefined" && typeof process === "undefined";
 }
 function ensureInitialized() {
   if (isInitialized || initializationPromise) {
     return;
   }
-  if (isBrowser2()) {
+  if (isBrowser()) {
     isInitialized = true;
     return;
   }
   initializationPromise = Promise.resolve().then(() => {
-    const config = getConfigFromEnv();
-    if (process.env["OTEL_LOG_LEVEL"] === "debug") {
-      console.log("OpenTelemetry auto-initializing with config:", {
-        serviceName: config.serviceName,
-        environment: config.environment,
-        tracesExporter: process.env["OTEL_TRACES_EXPORTER"] || "console",
-        metricsExporter: process.env["OTEL_METRICS_EXPORTER"] || "console"
-      });
-    }
-    const attributes = {
-      [SEMRESATTRS_SERVICE_NAME]: config.serviceName
-    };
-    if (config.serviceVersion) {
-      attributes[SEMRESATTRS_SERVICE_VERSION] = config.serviceVersion;
-    }
-    if (config.environment) {
-      attributes[SEMRESATTRS_DEPLOYMENT_ENVIRONMENT] = config.environment;
-    }
-    const customResource = resourceFromAttributes(attributes);
-    const resource = defaultResource().merge(customResource);
-    const traceExporter = createTraceExporter(config);
-    const metricReader = createMetricReader(config);
-    const instrumentations = [
-      new HttpInstrumentation({
-        requestHook: (span, request) => {
-          const req = request;
-          if (req.headers) {
-            span.setAttribute("http.request.body.size", req.headers["content-length"] || 0);
-          }
-        },
-        responseHook: (span, response) => {
-          const res = response;
-          if (res.headers) {
-            span.setAttribute("http.response.body.size", res.headers["content-length"] || 0);
-          }
-        }
-      }),
-      new ExpressInstrumentation()
-    ];
-    sdk = new NodeSDK({
-      resource,
-      spanProcessors: traceExporter ? [new BatchSpanProcessor(traceExporter)] : [],
-      metricReader,
-      instrumentations
-    });
+    sdk = new NodeSDK();
     sdk.start();
     isInitialized = true;
     process.on("SIGTERM", async () => {
@@ -203,11 +60,6 @@ function isOtelInitialized() {
 }
 
 // otel/src/tracer.ts
-import {
-  trace,
-  SpanStatusCode,
-  context as otelContext
-} from "@opentelemetry/api";
 import { SpanKind, SpanStatusCode as SpanStatusCode2 } from "@opentelemetry/api";
 var TRACER_NAME = "@reactionary/otel";
 var TRACER_VERSION = "0.0.1";
@@ -303,13 +155,6 @@ function getMetrics() {
   return metricsInstance;
 }
 
-// otel/src/trpc-middleware.ts
-import { TRPCError } from "@trpc/server";
-import {
-  SpanKind as SpanKind2,
-  SpanStatusCode as SpanStatusCode3
-} from "@opentelemetry/api";
-
 // otel/src/provider-instrumentation.ts
 import { SpanKind as SpanKind3 } from "@opentelemetry/api";
 async function withProviderSpan(options, fn) {
@@ -387,16 +232,15 @@ function createProviderInstrumentation(providerName) {
   };
 }
 
-// otel/src/index.ts
-import { trace as trace2, context, SpanKind as SpanKind4, SpanStatusCode as SpanStatusCode4 } from "@opentelemetry/api";
-
 // core/src/providers/base.provider.ts
+import * as crypto from "crypto";
 var BaseProvider = class {
-  constructor(schema, querySchema, mutationSchema) {
+  constructor(schema, querySchema, mutationSchema, 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
@@ -422,11 +266,44 @@ var BaseProvider = class {
       "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);
+        let cacheHits = 0;
+        let cacheMisses = 0;
+        const results = [];
+        for (const query of queries) {
+          let result = null;
+          const cacheInfo = this.getCacheEvaluation(query, session);
+          if (cacheInfo.canCache && cacheInfo.key) {
+            try {
+              result = await this.cache.get(cacheInfo.key, this.schema);
+              if (result) {
+                cacheHits++;
+                span.setAttribute("provider.cache.hit", true);
+              }
+            } catch (error) {
+              console.warn(`Cache get error for ${this.constructor.name}:`, error);
+            }
+          }
+          if (!result) {
+            const singleResult = await this.fetch([query], session);
+            result = singleResult[0];
+            cacheMisses++;
+            if (result && cacheInfo.canCache && cacheInfo.key) {
+              try {
+                await this.cache.put(cacheInfo.key, result, cacheInfo.cacheDurationInSeconds);
+              } catch (error) {
+                console.warn(`Cache put error for ${this.constructor.name}:`, error);
+              }
+            }
+          }
+          if (result) {
+            this.assert(result);
+            results.push(result);
+          }
         }
         span.setAttribute("provider.result.count", results.length);
+        span.setAttribute("provider.cache.hits", cacheHits);
+        span.setAttribute("provider.cache.misses", cacheMisses);
+        span.setAttribute("provider.cache.hit_ratio", cacheHits / (cacheHits + cacheMisses));
         return results;
       },
       { queryCount: queries.length }
@@ -448,18 +325,75 @@ var BaseProvider = class {
       { mutationCount: mutations.length }
     );
   }
+  /**
+   * Provider-specific cache evaluation logic.
+   * Returns information about how this query should be cached.
+   * Override this method to enable caching with custom keys and TTL.
+   * Default implementation returns no caching.
+   */
+  getCacheEvaluation(query, session) {
+    const providerName = this.constructor.name.toLowerCase();
+    const userId = session.identity?.id || "anonymous";
+    const queryHash = crypto.createHash("md5").update(JSON.stringify(query)).digest("hex").substring(0, 12);
+    const key = `${providerName}:${userId}:${queryHash}`;
+    return {
+      key,
+      cacheDurationInSeconds: 0,
+      canCache: false
+    };
+  }
 };
 
 // core/src/providers/identity.provider.ts
 var IdentityProvider = class extends BaseProvider {
+  getCacheEvaluation(_query, session) {
+    const providerName = this.constructor.name.toLowerCase();
+    const userId = session.identity?.id;
+    const key = userId ? `${providerName}:identity:${userId}` : `${providerName}:identity:anonymous`;
+    return {
+      key,
+      cacheDurationInSeconds: 0,
+      canCache: false
+    };
+  }
 };
 
 // core/src/providers/product.provider.ts
+import * as crypto2 from "crypto";
 var ProductProvider = class extends BaseProvider {
+  getCacheEvaluation(query, _session) {
+    const providerName = this.constructor.name.toLowerCase();
+    let key;
+    if (query.query === "slug") {
+      key = `${providerName}:product:slug:${query.slug}`;
+    } else if (query.query === "id") {
+      key = `${providerName}:product:id:${query.id}`;
+    } else {
+      const queryHash = crypto2.createHash("md5").update(JSON.stringify(query)).digest("hex").substring(0, 12);
+      key = `${providerName}:product:${queryHash}`;
+    }
+    return {
+      key,
+      cacheDurationInSeconds: 300,
+      // Products are moderately stable - 5 minutes
+      canCache: true
+    };
+  }
 };
 
 // core/src/providers/search.provider.ts
+import * as crypto3 from "crypto";
 var SearchProvider = class extends BaseProvider {
+  getCacheEvaluation(query, _session) {
+    const providerName = this.constructor.name.toLowerCase();
+    const searchHash = crypto3.createHash("md5").update(JSON.stringify(query.search)).digest("hex").substring(0, 12);
+    const key = `${providerName}:search:${searchHash}`;
+    return {
+      key,
+      cacheDurationInSeconds: 0,
+      canCache: false
+    };
+  }
 };
 
 // core/src/schemas/capabilities.schema.ts
@@ -919,8 +853,8 @@ var SearchQuerySchema = z25.union([SearchQueryByTermSchema]);
 // providers/fake/src/providers/product.provider.ts
 import { base, en, Faker } from "@faker-js/faker";
 var FakeProductProvider = class extends ProductProvider {
-  constructor(config, schema, querySchema, mutationSchema) {
-    super(schema, querySchema, mutationSchema);
+  constructor(config, schema, querySchema, mutationSchema, cache) {
+    super(schema, querySchema, mutationSchema, cache);
     this.config = config;
   }
   async fetch(queries, session) {
@@ -980,8 +914,8 @@ function gaussianRandom(mean, deviation) {
 
 // providers/fake/src/providers/search.provider.ts
 var FakeSearchProvider = class extends SearchProvider {
-  constructor(config, schema, querySchema, mutationSchema) {
-    super(schema, querySchema, mutationSchema);
+  constructor(config, schema, querySchema, mutationSchema, cache) {
+    super(schema, querySchema, mutationSchema, cache);
     this.config = config;
   }
   async fetch(queries, session) {
@@ -1082,8 +1016,8 @@ var FakeSearchProvider = class extends SearchProvider {
 // providers/fake/src/providers/identity.provider.ts
 import { faker } from "@faker-js/faker";
 var FakeIdentityProvider = class extends IdentityProvider {
-  constructor(config, schema, querySchema, mutationSchema) {
-    super(schema, querySchema, mutationSchema);
+  constructor(config, schema, querySchema, mutationSchema, cache) {
+    super(schema, querySchema, mutationSchema, cache);
     this.config = config;
   }
   async fetch(queries, session) {
@@ -1130,17 +1064,19 @@ var FakeIdentityProvider = class extends IdentityProvider {
 
 // providers/fake/src/core/initialize.ts
 function withFakeCapabilities(configuration, capabilities) {
-  const client = {};
-  if (capabilities.product) {
-    client.product = new FakeProductProvider(configuration, ProductSchema, ProductQuerySchema, ProductMutationSchema);
-  }
-  if (capabilities.search) {
-    client.search = new FakeSearchProvider(configuration, SearchResultSchema, SearchQuerySchema, SearchMutationSchema);
-  }
-  if (capabilities.identity) {
-    client.identity = new FakeIdentityProvider(configuration, IdentitySchema, IdentityQuerySchema, IdentityMutationSchema);
-  }
-  return client;
+  return (cache) => {
+    const client = {};
+    if (capabilities.product) {
+      client.product = new FakeProductProvider(configuration, ProductSchema, ProductQuerySchema, ProductMutationSchema, cache);
+    }
+    if (capabilities.search) {
+      client.search = new FakeSearchProvider(configuration, SearchResultSchema, SearchQuerySchema, SearchMutationSchema, cache);
+    }
+    if (capabilities.identity) {
+      client.identity = new FakeIdentityProvider(configuration, IdentitySchema, IdentityQuerySchema, IdentityMutationSchema, cache);
+    }
+    return client;
+  };
 }
 
 // providers/fake/src/schema/capabilities.schema.ts

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@reactionary/provider-fake",
-  "version": "0.0.29",
+  "version": "0.0.31",
   "dependencies": {
-    "@reactionary/core": "0.0.29",
+    "@reactionary/core": "0.0.31",
     "zod": "4.0.0-beta.20250430T185432",
     "@faker-js/faker": "^9.8.0"
   }

package/src/core/initialize.d.ts

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

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

@@ -3,7 +3,7 @@ import { FakeConfiguration } from '../schema/configuration.schema';
 import z from 'zod';
 export declare class FakeIdentityProvider<T extends Identity = Identity, Q extends IdentityQuery = IdentityQuery, M extends IdentityMutation = IdentityMutation> extends IdentityProvider<T, Q, M> {
     protected config: FakeConfiguration;
-    constructor(config: FakeConfiguration, schema: z.ZodType<T>, querySchema: z.ZodType<Q, Q>, mutationSchema: z.ZodType<M, M>);
+    constructor(config: FakeConfiguration, schema: z.ZodType<T>, querySchema: z.ZodType<Q, Q>, mutationSchema: z.ZodType<M, M>, cache: any);
     protected fetch(queries: Q[], session: Session): Promise<T[]>;
     protected process(mutations: M[], session: Session): Promise<T>;
     protected login(payload: IdentityMutationLogin, session: Session): Promise<T>;

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

@@ -3,7 +3,7 @@ import z from 'zod';
 import { FakeConfiguration } from '../schema/configuration.schema';
 export declare class FakeProductProvider<T extends Product = Product, Q extends ProductQuery = ProductQuery, M extends ProductMutation = ProductMutation> extends ProductProvider<T, Q, M> {
     protected config: FakeConfiguration;
-    constructor(config: FakeConfiguration, schema: z.ZodType<T>, querySchema: z.ZodType<Q, Q>, mutationSchema: z.ZodType<M, M>);
+    constructor(config: FakeConfiguration, schema: z.ZodType<T>, querySchema: z.ZodType<Q, Q>, mutationSchema: z.ZodType<M, M>, cache: any);
     protected fetch(queries: Q[], session: Session): Promise<T[]>;
     protected process(mutation: BaseMutation[], session: Session): Promise<T>;
 }

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

@@ -3,7 +3,7 @@ import z from 'zod';
 import { FakeConfiguration } from '../schema/configuration.schema';
 export declare class FakeSearchProvider<T extends SearchResult = SearchResult, Q extends SearchQuery = SearchQuery, M extends SearchMutation = SearchMutation> extends SearchProvider<T, Q, M> {
     protected config: FakeConfiguration;
-    constructor(config: FakeConfiguration, schema: z.ZodType<T>, querySchema: z.ZodType<Q, Q>, mutationSchema: z.ZodType<M, M>);
+    constructor(config: FakeConfiguration, schema: z.ZodType<T>, querySchema: z.ZodType<Q, Q>, mutationSchema: z.ZodType<M, M>, cache: any);
     protected fetch(queries: Q[], session: Session): Promise<T[]>;
     protected process(mutations: M[], session: Session): Promise<T>;
     get(identifier: SearchIdentifier): Promise<T>;

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

@@ -1,10 +1,10 @@
 import { z } from 'zod';
 export declare const FakeCapabilitiesSchema: z.ZodInterface<{
-    identity: z.ZodOptional<z.ZodBoolean>;
     search: z.ZodOptional<z.ZodBoolean>;
     product: z.ZodOptional<z.ZodBoolean>;
+    identity: z.ZodOptional<z.ZodBoolean>;
 }, {
-    optional: "identity" | "search" | "product";
+    optional: "search" | "product" | "identity";
     defaulted: never;
     extra: Record<string, unknown>;
 }>;