@zintrust/cache-redis 2.1.4 → 2.8.0

package/README.md

@@ -32,6 +32,19 @@ Then set your cache driver config (see docs for the full set of env vars):
 CACHE_DRIVER=redis
 ```
 
+## Cloudflare Workers
+
+When the app runs in Cloudflare Workers or another runtime without Redis TCP access, use Redis RPC:
+
+```bash
+npm i @zintrust/redis-rpc
+
+USE_REDIS_PROXY=true
+REDIS_RPC_URL=https://queues.example.com
+```
+
+Run the backend with `zin redis-rpc` or `zin s redis-rpc`. The Redis cache driver will send `get`, `set`, `del`, `exists`, and `flushdb` through the core Redis RPC transport. The older Redis HTTP proxy remains available for simple command forwarding through `REDIS_PROXY_URL`.
+
 ## Docs
 
 - https://zintrust.com/cache

package/dist/RedisProxyAdapter.js

@@ -2,15 +2,15 @@ import { Env } from '@zintrust/core/config';
 import { ErrorFactory } from '@zintrust/core/errors';
 import { createRedisConnection } from '@zintrust/core/redis';
 const createProxyClient = () => {
-    if (Env.REDIS_PROXY_URL.trim() === '' && Env.USE_REDIS_PROXY !== true) {
-        throw ErrorFactory.createConfigError('Redis proxy URL is missing (REDIS_PROXY_URL)');
+    if (Env.USE_REDIS_PROXY !== true) {
+        throw ErrorFactory.createConfigError('Redis proxy transport requires USE_REDIS_PROXY=true. Add REDIS_RPC_URL for Redis RPC or REDIS_PROXY_URL/REDIS_PROXY_HOST for the legacy Redis HTTP proxy.');
     }
     return createRedisConnection({
         host: Env.get('REDIS_HOST', 'localhost'),
         port: Env.getInt('REDIS_PORT', 6379),
         password: Env.get('REDIS_PASSWORD'),
         db: Env.getInt('REDIS_DB', 0),
-    }, 3, { subsystem: 'cache', requireDirectForScripts: false });
+    }, 3, { subsystem: 'cache' });
 };
 export const RedisProxyAdapter = Object.freeze({
     create() {

package/dist/build-manifest.json

@@ -0,0 +1,51 @@
+{
+  "name": "@zintrust/cache-redis",
+  "version": "2.8.0",
+  "buildDate": "2026-06-25T14:58:58.204Z",
+  "buildEnvironment": {
+    "node": "v20.20.2",
+    "platform": "linux",
+    "arch": "x64"
+  },
+  "git": {
+    "commit": "4f1c19ee",
+    "branch": "master"
+  },
+  "package": {
+    "engines": {
+      "node": ">=20.0.0"
+    },
+    "dependencies": [
+      "redis"
+    ],
+    "peerDependencies": [
+      "@zintrust/core"
+    ]
+  },
+  "files": {
+    "RedisProxyAdapter.d.ts": {
+      "size": 163,
+      "sha256": "91df2fbb1916b073c3bafa1dc253ab5ee8998cc924c3cd52308c09798c1d829f"
+    },
+    "RedisProxyAdapter.js": {
+      "size": 1851,
+      "sha256": "6cbca2f311ac0573e63a1cd60e7bfe8b3eaaedcf23696ec170b234b2fd56f5a9"
+    },
+    "index.d.ts": {
+      "size": 1000,
+      "sha256": "889b6f7ba479e62988d08472d823c41bb026c261992ba6ad65df2fc4048e6a72"
+    },
+    "index.js": {
+      "size": 10002,
+      "sha256": "7cfe9ed90d018da8c9bebe5eaed377023284e8b230d32e2b53587dedc22b5d1c"
+    },
+    "register.d.ts": {
+      "size": 184,
+      "sha256": "005e0163b4f5833a0096cfcba7d5851b6f21c0fea7d8faf01a913dc2808730ad"
+    },
+    "register.js": {
+      "size": 472,
+      "sha256": "0fa19f823df12b6b99973a893c1b975e767d183b0275e9b78a60e454ca63b6ca"
+    }
+  }
+}

package/dist/index.d.ts

@@ -4,6 +4,9 @@ export interface CacheDriver {
     delete(key: string): Promise<void>;
     clear(): Promise<void>;
     has(key: string): Promise<boolean>;
+    increment?(key: string, amount?: number): Promise<number>;
+    decrement?(key: string, amount?: number): Promise<number>;
+    getRedisClient?(): unknown;
 }
 export type RedisCacheConfig = {
     driver: 'redis';

package/dist/index.js

@@ -30,7 +30,42 @@ const createCacheFailureState = () => {
         },
     };
 };
-const createCacheOperations = (ensureClient, operations, defaultTtl) => {
+const incrementValue = async (ensureClient, operations, failureState, defaultTtl, key, amount) => {
+    if (failureState.isDisabled())
+        return 0;
+    try {
+        const client = await ensureClient();
+        if (operations.increment)
+            return operations.increment(client, key, amount);
+        const current = Number(safeJsonParse((await operations.get(client, key)) ?? '0') ?? 0);
+        const next = current + amount;
+        await operations.set(client, key, JSON.stringify(next), defaultTtl);
+        return next;
+    }
+    catch (error) {
+        failureState.disableAfterFailure('SET', error);
+        return 0;
+    }
+};
+const decrementValue = async (ensureClient, operations, failureState, defaultTtl, key, amount) => {
+    if (failureState.isDisabled())
+        return 0;
+    try {
+        const client = await ensureClient();
+        if (operations.decrement)
+            return operations.decrement(client, key, amount);
+        const current = Number(safeJsonParse((await operations.get(client, key)) ?? '0') ?? 0);
+        const next = current - amount;
+        await operations.set(client, key, JSON.stringify(next), defaultTtl);
+        return next;
+    }
+    catch (error) {
+        failureState.disableAfterFailure('SET', error);
+        return 0;
+    }
+};
+// Driver objects intentionally keep the cache method table in one sealed return value.
+const createCacheOperations = (ensureClient, operations, defaultTtl, getRedisClient) => {
     const failureState = createCacheFailureState();
     return {
         async get(key) {
@@ -96,6 +131,13 @@ const createCacheOperations = (ensureClient, operations, defaultTtl) => {
                 return false;
             }
         },
+        async increment(key, amount = 1) {
+            return incrementValue(ensureClient, operations, failureState, defaultTtl, key, amount);
+        },
+        async decrement(key, amount = 1) {
+            return decrementValue(ensureClient, operations, failureState, defaultTtl, key, amount);
+        },
+        ...(getRedisClient ? { getRedisClient } : {}),
     };
 };
 const createWorkersCacheDriver = (config) => {
@@ -107,7 +149,7 @@ const createWorkersCacheDriver = (config) => {
             port: config.port,
             password: config.password,
             db: config.database ?? 0,
-        }, 3, { subsystem: 'cache', requireDirectForScripts: false });
+        }, 3, { subsystem: 'cache' });
         if (!connected && typeof client.connect === 'function') {
             await client.connect();
             connected = true;
@@ -118,7 +160,7 @@ const createWorkersCacheDriver = (config) => {
         get: (redisClient, key) => redisClient.get(key),
         set: (redisClient, key, json, ttl) => {
             if (Number.isFinite(ttl) && ttl > 0) {
-                return redisClient.set(key, json, { EX: ttl });
+                return redisClient.set(key, json, 'EX', ttl);
             }
             else {
                 return redisClient.set(key, json);
@@ -137,7 +179,31 @@ const createWorkersCacheDriver = (config) => {
             return Promise.resolve();
         },
         exists: (redisClient, key) => redisClient.exists(key),
-    }, config.ttl ?? 300);
+        increment: async (redisClient, key, amount) => {
+            if (typeof redisClient.incrBy === 'function') {
+                return redisClient.incrBy(key, amount);
+            }
+            if (typeof redisClient.incrby === 'function') {
+                return redisClient.incrby(key, amount);
+            }
+            const current = Number((await redisClient.get(key)) ?? 0);
+            const next = current + amount;
+            await redisClient.set(key, String(next));
+            return next;
+        },
+        decrement: async (redisClient, key, amount) => {
+            if (typeof redisClient.decrBy === 'function') {
+                return redisClient.decrBy(key, amount);
+            }
+            if (typeof redisClient.decrby === 'function') {
+                return redisClient.decrby(key, amount);
+            }
+            const current = Number((await redisClient.get(key)) ?? 0);
+            const next = current - amount;
+            await redisClient.set(key, String(next));
+            return next;
+        },
+    }, config.ttl ?? 300, () => client);
 };
 const createNodeCacheDriver = (config) => {
     let client;
@@ -172,10 +238,12 @@ const createNodeCacheDriver = (config) => {
         },
         clear: (redisClient) => redisClient.flushDb(),
         exists: (redisClient, key) => redisClient.exists(key),
-    }, config.ttl ?? 300);
+        increment: (redisClient, key, amount) => redisClient.incrBy(key, amount),
+        decrement: (redisClient, key, amount) => redisClient.decrBy(key, amount),
+    }, config.ttl ?? 300, () => client);
 };
 const shouldUseProxy = () => {
-    return Env.REDIS_PROXY_URL.trim() !== '' || Env.USE_REDIS_PROXY === true;
+    return Env.USE_REDIS_PROXY === true;
 };
 export const RedisCacheDriver = Object.freeze({
     create(config) {
@@ -184,7 +252,7 @@ export const RedisCacheDriver = Object.freeze({
             return createWorkersCacheDriver(config);
         }
         if (isWorkers && Cloudflare.isCloudflareSocketsEnabled() === false) {
-            throw ErrorFactory.createConfigError('Redis cache driver requires ENABLE_CLOUDFLARE_SOCKETS=true in Cloudflare Workers.');
+            throw ErrorFactory.createConfigError('Redis cache driver in Cloudflare Workers requires USE_REDIS_PROXY=true with REDIS_RPC_URL/REDIS_PROXY_URL, or ENABLE_CLOUDFLARE_SOCKETS=true.');
         }
         return isWorkers ? createWorkersCacheDriver(config) : createNodeCacheDriver(config);
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zintrust/cache-redis",
-  "version": "2.1.4",
+  "version": "2.8.0",
   "description": "Redis cache driver for ZinTrust.",
   "private": false,
   "type": "module",
@@ -42,4 +42,4 @@
     "build": "tsc -p tsconfig.json",
     "prepublishOnly": "npm run build"
   }
-}
+}