@reactionary/core 0.9.5 → 0.9.7

package/cache/redis-cache.js

@@ -1,16 +1,41 @@
-import { Redis } from "@upstash/redis";
+import { createClient } from "redis";
 import { getReactionaryCacheMeter } from "../metrics/metrics.js";
 class RedisCache {
   redis;
+  connectPromise;
   meter = getReactionaryCacheMeter();
-  constructor() {
-    this.redis = Redis.fromEnv();
+  constructor(redisUrl = process.env["REDIS_URL"]) {
+    if (!redisUrl) {
+      throw new Error("REDIS_URL is required");
+    }
+    this.redis = createClient({
+      url: redisUrl
+    });
+    this.redis.on("error", (err) => {
+      console.error("Redis error", err);
+    });
+  }
+  async client() {
+    if (!this.connectPromise) {
+      this.connectPromise = this.redis.connect();
+    }
+    return this.connectPromise;
   }
   async get(key, schema) {
     if (!key) {
       return null;
     }
-    const unvalidated = await this.redis.get(key);
+    const redis = await this.client();
+    const serialized = await redis.get(key);
+    if (serialized === null) {
+      return null;
+    }
+    let unvalidated;
+    try {
+      unvalidated = JSON.parse(serialized);
+    } catch {
+      return null;
+    }
     const parsed = schema.safeParse(unvalidated);
     if (parsed.success) {
       this.meter.hits.add(1, {
@@ -24,34 +49,45 @@ class RedisCache {
     if (!key) {
       return;
     }
+    const redis = await this.client();
     const serialized = JSON.stringify(value);
-    const multi = this.redis.multi();
-    multi.set(key, serialized, { ex: options.ttlSeconds });
+    const multi = redis.multi();
+    multi.set(key, serialized, {
+      EX: options.ttlSeconds
+    });
     for (const depId of options.dependencyIds) {
-      multi.sadd(`dep:${depId}`, key);
+      multi.sAdd(`dep:${depId}`, key);
     }
-    this.meter.items.record(await this.redis.dbsize(), {
+    await multi.exec();
+    this.meter.items.record(await redis.dbSize(), {
       "labels.cache_type": "redis"
     });
-    await multi.exec();
   }
   async invalidate(dependencyIds) {
+    const redis = await this.client();
     for (const id of dependencyIds) {
       const depKey = `dep:${id}`;
-      const keys = await this.redis.smembers(depKey);
+      const keys = await redis.sMembers(depKey);
       if (keys.length > 0) {
-        await this.redis.del(...keys);
+        await redis.del(keys);
       }
-      await this.redis.del(depKey);
+      await redis.del(depKey);
     }
-    this.meter.items.record(await this.redis.dbsize(), {
+    this.meter.items.record(await redis.dbSize(), {
       "labels.cache_type": "redis"
     });
   }
   async clear() {
-    this.meter.items.record(await this.redis.dbsize(), {
+    const redis = await this.client();
+    this.meter.items.record(await redis.dbSize(), {
       "labels.cache_type": "redis"
     });
+    await redis.flushDb();
+  }
+  async close() {
+    if (this.redis.isOpen) {
+      await this.redis.quit();
+    }
   }
 }
 export {

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@reactionary/core",
-  "version": "0.9.5",
+  "version": "0.9.7",
   "type": "module",
   "main": "./index.js",
   "types": "./src/index.d.ts",
   "dependencies": {
     "zod": "4.1.9",
-    "@upstash/redis": "^1.34.9",
     "@opentelemetry/api": "^1.9.0",
     "node-object-hash": "^3.1.1",
     "vitest": "^4.0.9",
-    "@nx/vite": "22.4.5"
+    "@nx/vite": "22.4.5",
+    "redis": "^5.12.1"
   },
   "sideEffects": false
 }

package/src/cache/redis-cache.d.ts

@@ -1,12 +1,15 @@
-import { Redis } from '@upstash/redis';
+import { createClient } from 'redis';
 import type { Cache, CacheEntryOptions } from './cache.interface.js';
 import type * as z from 'zod';
 export declare class RedisCache implements Cache {
-    protected redis: Redis;
+    protected redis: ReturnType<typeof createClient>;
+    protected connectPromise?: Promise<ReturnType<typeof createClient>>;
     protected meter: import("../metrics/metrics.js").ReactionaryCacheMetrics;
-    constructor();
+    constructor(redisUrl?: string | undefined);
+    protected client(): Promise<ReturnType<typeof createClient>>;
     get<T>(key: string, schema: z.ZodType<T>): Promise<T | null>;
     put(key: string, value: unknown, options: CacheEntryOptions): Promise<void>;
     invalidate(dependencyIds: Array<string>): Promise<void>;
     clear(): Promise<void>;
+    close(): Promise<void>;
 }