@reactionary/core 0.0.30 → 0.0.32

package/index.js

@@ -1,47 +1,95 @@
-// core/src/cache/caching-strategy.ts
-var BaseCachingStrategy = class {
-  get(query, session) {
-    const q = query;
-    return {
-      key: q.sku,
-      cacheDurationInSeconds: 300,
-      canCache: true
-    };
-  }
-};
-
 // core/src/cache/redis-cache.ts
 import { Redis } from "@upstash/redis";
 var RedisCache = class {
-  constructor(strategy) {
-    this.strategy = strategy;
+  constructor() {
     this.redis = Redis.fromEnv();
   }
-  async get(query, session, schema) {
-    let result = null;
-    const cacheInformation = this.strategy.get(query, session);
-    if (cacheInformation.canCache && cacheInformation.key) {
-      const unvalidated = await this.redis.get(cacheInformation.key);
-      const parsed = schema.safeParse(unvalidated);
-      if (parsed.success) {
-        result = parsed.data;
+  async get(key, schema) {
+    if (!key) {
+      return null;
+    }
+    const unvalidated = await this.redis.get(key);
+    const parsed = schema.safeParse(unvalidated);
+    if (parsed.success) {
+      return parsed.data;
+    }
+    return null;
+  }
+  async put(key, value, ttlSeconds) {
+    if (!key) {
+      return;
+    }
+    const options = ttlSeconds ? { ex: ttlSeconds } : void 0;
+    await this.redis.set(key, value, options);
+  }
+  async del(keys) {
+    const keyArray = Array.isArray(keys) ? keys : [keys];
+    for (const key of keyArray) {
+      if (key.includes("*")) {
+        const matchingKeys = await this.redis.keys(key);
+        if (matchingKeys.length > 0) {
+          await this.redis.del(...matchingKeys);
+        }
+      } else {
+        await this.redis.del(key);
       }
     }
-    return result;
   }
-  put(query, session, value) {
-    const cacheInformation = this.strategy.get(query, session);
-    if (cacheInformation.canCache && cacheInformation.key) {
-      this.redis.set(cacheInformation.key, value, { ex: cacheInformation.cacheDurationInSeconds });
+  async keys(pattern) {
+    return await this.redis.keys(pattern);
+  }
+  async clear(pattern) {
+    const searchPattern = pattern || "*";
+    const keys = await this.redis.keys(searchPattern);
+    if (keys.length > 0) {
+      await this.redis.del(...keys);
     }
   }
+  async getStats() {
+    const keys = await this.redis.keys("*");
+    return {
+      hits: 0,
+      // Would need to track this separately
+      misses: 0,
+      // Would need to track this separately  
+      size: keys.length
+    };
+  }
+};
+
+// core/src/cache/noop-cache.ts
+var NoOpCache = class {
+  async get(_key, _schema) {
+    return null;
+  }
+  async put(_key, _value, _ttlSeconds) {
+    return;
+  }
+  async del(_keys) {
+    return;
+  }
+  async keys(_pattern) {
+    return [];
+  }
+  async clear(_pattern) {
+    return;
+  }
+  async getStats() {
+    return {
+      hits: 0,
+      misses: 0,
+      size: 0
+    };
+  }
 };
 
 // core/src/client/client.ts
-function buildClient(providers) {
+function buildClient(providerFactories, options = {}) {
   let client = {};
+  const sharedCache = options.cache || new RedisCache();
   const mergedAnalytics = [];
-  for (const provider of providers) {
+  for (const factory of providerFactories) {
+    const provider = factory(sharedCache);
     client = {
       ...client,
       ...provider
@@ -51,247 +99,119 @@ function buildClient(providers) {
     }
   }
   client.analytics = mergedAnalytics;
-  return client;
+  const completeClient = {
+    ...client,
+    cache: sharedCache
+  };
+  return completeClient;
 }
-
-// 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 createCache() {
+  return new RedisCache();
 }
-function ensureInitialized() {
-  if (isInitialized || initializationPromise) {
-    return;
-  }
-  if (isBrowser()) {
-    isInitialized = true;
-    return;
+
+// core/src/client/client-builder.ts
+var ClientBuilder = class _ClientBuilder {
+  constructor() {
+    this.factories = [];
   }
-  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;
+  withCapability(factory) {
+    const newBuilder = new _ClientBuilder();
+    newBuilder.factories = [...this.factories, factory];
+    newBuilder.cache = this.cache;
+    return newBuilder;
   }
-}
-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);
+  withCache(cache) {
+    const newBuilder = new _ClientBuilder();
+    newBuilder.factories = [...this.factories];
+    newBuilder.cache = cache;
+    return newBuilder;
   }
-  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);
+  build() {
+    let client = {};
+    const sharedCache = this.cache || new NoOpCache();
+    const mergedAnalytics = [];
+    for (const factory of this.factories) {
+      const provider = factory(sharedCache);
+      client = {
+        ...client,
+        ...provider
+      };
+      if (provider.analytics) {
+        mergedAnalytics.push(...provider.analytics);
       }
-      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);
+    if (mergedAnalytics.length > 0) {
+      client["analytics"] = mergedAnalytics;
     }
-  });
-}
-
-// 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);
+    const completeClient = {
+      ...client,
+      cache: sharedCache
+    };
+    return completeClient;
   }
-  return globalMeter;
+};
+
+// 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");
+function trpcQuery(options = {}) {
+  return function(target, propertyKey, descriptor) {
+    const metadata = {
+      methodName: String(propertyKey),
+      isQuery: true,
+      isMutation: false,
+      options
+    };
+    Reflect.defineMetadata(TRPC_QUERY_METADATA_KEY, metadata, target, propertyKey);
+    const existingMethods = Reflect.getMetadata(TRPC_QUERY_METADATA_KEY, target.constructor) || [];
+    existingMethods.push({ propertyKey, metadata });
+    Reflect.defineMetadata(TRPC_QUERY_METADATA_KEY, existingMethods, target.constructor);
+  };
 }
-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"
-    })
+function trpcMutation(options = {}) {
+  return function(target, propertyKey, descriptor) {
+    const metadata = {
+      methodName: String(propertyKey),
+      isQuery: false,
+      isMutation: true,
+      options
+    };
+    Reflect.defineMetadata(TRPC_MUTATION_METADATA_KEY, metadata, target, propertyKey);
+    const existingMethods = Reflect.getMetadata(TRPC_MUTATION_METADATA_KEY, target.constructor) || [];
+    existingMethods.push({ propertyKey, metadata });
+    Reflect.defineMetadata(TRPC_MUTATION_METADATA_KEY, existingMethods, target.constructor);
   };
-  return metricsInstance;
 }
-function getMetrics() {
-  if (!metricsInstance) {
-    return initializeMetrics();
-  }
-  return metricsInstance;
+function getTRPCQueryMethods(target) {
+  const constructor = typeof target === "function" ? target : target.constructor;
+  return Reflect.getMetadata(TRPC_QUERY_METADATA_KEY, constructor) || [];
 }
-
-// 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 getTRPCMutationMethods(target) {
+  const constructor = typeof target === "function" ? target : target.constructor;
+  return Reflect.getMetadata(TRPC_MUTATION_METADATA_KEY, constructor) || [];
 }
-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
-      );
-    }
-  };
+function getAllTRPCMethods(target) {
+  return [
+    ...getTRPCQueryMethods(target),
+    ...getTRPCMutationMethods(target)
+  ];
+}
+function isTRPCQuery(target, methodName) {
+  return !!Reflect.getMetadata(TRPC_QUERY_METADATA_KEY, target, methodName);
+}
+function isTRPCMutation(target, methodName) {
+  return !!Reflect.getMetadata(TRPC_MUTATION_METADATA_KEY, target, methodName);
+}
+function isTRPCMethod(target, methodName) {
+  return isTRPCQuery(target, methodName) || isTRPCMutation(target, methodName);
 }
 
 // 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
@@ -307,41 +227,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.
-   */
-  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.
+   * Handler for parsing a response from a remote provider and converting it
+   * into the typed domain model.
    */
-  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);
   }
 };
 
@@ -718,42 +609,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";
@@ -773,62 +654,44 @@ 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]);
 export {
   AnalyticsProvider,
-  BaseCachingStrategy,
   BaseModelSchema,
   BaseMutationSchema,
   BaseProvider,
@@ -841,19 +704,17 @@ export {
   CartMutationItemAddSchema,
   CartMutationItemQuantityChangeSchema,
   CartMutationItemRemoveSchema,
-  CartMutationSchema,
   CartProvider,
   CartQueryByIdSchema,
   CartQuerySchema,
   CartSchema,
+  ClientBuilder,
   CurrencySchema,
   FacetIdentifierSchema,
   FacetValueIdentifierSchema,
   IdentityMutationLoginSchema,
   IdentityMutationLogoutSchema,
-  IdentityMutationSchema,
   IdentityProvider,
-  IdentityQuerySchema,
   IdentityQuerySelfSchema,
   IdentitySchema,
   IdentityTypeSchema,
@@ -863,11 +724,11 @@ export {
   InventorySchema,
   MetaSchema,
   MonetaryAmountSchema,
+  NoOpCache,
   PriceIdentifierSchema,
   PriceMutationSchema,
   PriceProvider,
   PriceQueryBySkuSchema,
-  PriceQuerySchema,
   PriceSchema,
   ProductAttributeSchema,
   ProductIdentifierSchema,
@@ -875,7 +736,6 @@ export {
   ProductProvider,
   ProductQueryByIdSchema,
   ProductQueryBySlugSchema,
-  ProductQuerySchema,
   ProductSchema,
   RedisCache,
   SKUIdentifierSchema,
@@ -884,11 +744,21 @@ export {
   SearchMutationSchema,
   SearchProvider,
   SearchQueryByTermSchema,
-  SearchQuerySchema,
   SearchResultFacetSchema,
   SearchResultFacetValueSchema,
   SearchResultProductSchema,
   SearchResultSchema,
   SessionSchema,
-  buildClient
+  TRPC_MUTATION_METADATA_KEY,
+  TRPC_QUERY_METADATA_KEY,
+  buildClient,
+  createCache,
+  getAllTRPCMethods,
+  getTRPCMutationMethods,
+  getTRPCQueryMethods,
+  isTRPCMethod,
+  isTRPCMutation,
+  isTRPCQuery,
+  trpcMutation,
+  trpcQuery
 };