@reactionary/core 0.0.32 → 0.0.34

package/cache/noop-cache.js

@@ -0,0 +1,27 @@
+class NoOpCache {
+  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
+    };
+  }
+}
+export {
+  NoOpCache
+};

package/cache/redis-cache.js

@@ -0,0 +1,60 @@
+import { Redis } from "@upstash/redis";
+class RedisCache {
+  constructor() {
+    this.redis = Redis.fromEnv();
+  }
+  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);
+      }
+    }
+  }
+  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
+    };
+  }
+}
+export {
+  RedisCache
+};

package/client/client-builder.js

@@ -0,0 +1,44 @@
+import { NoOpCache } from "../cache/noop-cache";
+class ClientBuilder {
+  constructor() {
+    this.factories = [];
+  }
+  withCapability(factory) {
+    const newBuilder = new ClientBuilder();
+    newBuilder.factories = [...this.factories, factory];
+    newBuilder.cache = this.cache;
+    return newBuilder;
+  }
+  withCache(cache) {
+    const newBuilder = new ClientBuilder();
+    newBuilder.factories = [...this.factories];
+    newBuilder.cache = cache;
+    return newBuilder;
+  }
+  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);
+      }
+    }
+    if (mergedAnalytics.length > 0) {
+      client["analytics"] = mergedAnalytics;
+    }
+    const completeClient = {
+      ...client,
+      cache: sharedCache
+    };
+    return completeClient;
+  }
+}
+export {
+  ClientBuilder
+};

package/client/client.js

@@ -0,0 +1,29 @@
+import { RedisCache } from "../cache/redis-cache";
+function buildClient(providerFactories, options = {}) {
+  let client = {};
+  const sharedCache = options.cache || new RedisCache();
+  const mergedAnalytics = [];
+  for (const factory of providerFactories) {
+    const provider = factory(sharedCache);
+    client = {
+      ...client,
+      ...provider
+    };
+    if (provider.analytics) {
+      mergedAnalytics.push(...provider.analytics);
+    }
+  }
+  client.analytics = mergedAnalytics;
+  const completeClient = {
+    ...client,
+    cache: sharedCache
+  };
+  return completeClient;
+}
+function createCache() {
+  return new RedisCache();
+}
+export {
+  buildClient,
+  createCache
+};

package/decorators/trpc.decorators.js

@@ -0,0 +1,66 @@
+import "reflect-metadata";
+const TRPC_QUERY_METADATA_KEY = Symbol("trpc:query");
+const 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);
+  };
+}
+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);
+  };
+}
+function getTRPCQueryMethods(target) {
+  const constructor = typeof target === "function" ? target : target.constructor;
+  return Reflect.getMetadata(TRPC_QUERY_METADATA_KEY, constructor) || [];
+}
+function getTRPCMutationMethods(target) {
+  const constructor = typeof target === "function" ? target : target.constructor;
+  return Reflect.getMetadata(TRPC_MUTATION_METADATA_KEY, constructor) || [];
+}
+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);
+}
+export {
+  TRPC_MUTATION_METADATA_KEY,
+  TRPC_QUERY_METADATA_KEY,
+  getAllTRPCMethods,
+  getTRPCMutationMethods,
+  getTRPCQueryMethods,
+  isTRPCMethod,
+  isTRPCMutation,
+  isTRPCQuery,
+  trpcMutation,
+  trpcQuery
+};