@zintrust/cache-redis 2.1.3 → 2.4.1

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,8 +2,8 @@ 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'),

package/dist/build-manifest.json

@@ -1,14 +1,14 @@
 {
   "name": "@zintrust/cache-redis",
-  "version": "2.1.3",
-  "buildDate": "2026-05-27T04:03:00.356Z",
+  "version": "2.4.1",
+  "buildDate": "2026-05-31T11:36:02.431Z",
   "buildEnvironment": {
     "node": "v22.22.1",
     "platform": "darwin",
     "arch": "arm64"
   },
   "git": {
-    "commit": "c82f6263",
+    "commit": "e97b7b3d",
     "branch": "release"
   },
   "package": {
@@ -28,28 +28,20 @@
       "sha256": "91df2fbb1916b073c3bafa1dc253ab5ee8998cc924c3cd52308c09798c1d829f"
     },
     "RedisProxyAdapter.js": {
-      "size": 1779,
-      "sha256": "cb3a74a77feb37753c01317258ee94567d1ad20390239fa120a2c5a28d13abdd"
-    },
-    "RedisWorkersDurableObjectAdapter.d.ts": {
-      "size": 193,
-      "sha256": "859d3177d302c65f93add57216eae91d8c45874801bb75bdea3d6f6b00fb00c3"
-    },
-    "RedisWorkersDurableObjectAdapter.js": {
-      "size": 4482,
-      "sha256": "5b0ae2883872ce974ecaf01f07d35b72e6da468439912a57734ccd5222705bfd"
+      "size": 1851,
+      "sha256": "6cbca2f311ac0573e63a1cd60e7bfe8b3eaaedcf23696ec170b234b2fd56f5a9"
     },
     "build-manifest.json": {
-      "size": 1701,
-      "sha256": "d60387ced9538e8ff6b054357632554f2572823d1e21c49794fff8bf1803b243"
+      "size": 1251,
+      "sha256": "6feb4171104bdeedf319a588a822a62e56c1db73f61d4ef5238ad48c828778c3"
     },
     "index.d.ts": {
-      "size": 842,
-      "sha256": "b47614dfdb736524165785958f4a685818c055315961c2e2b48d99ef6ca491e2"
+      "size": 1000,
+      "sha256": "889b6f7ba479e62988d08472d823c41bb026c261992ba6ad65df2fc4048e6a72"
     },
     "index.js": {
-      "size": 6988,
-      "sha256": "1af0670044be451bff237933f3fba3846e0ed30a2e2f3b0a766b3efe7781f192"
+      "size": 10002,
+      "sha256": "3eefc49885300ddadeecef3ff6af2bc0405c43a5498dbc4efb9888144dc6f330"
     },
     "register.d.ts": {
       "size": 184,

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) => {
@@ -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.3",
+  "version": "2.4.1",
   "description": "Redis cache driver for ZinTrust.",
   "private": false,
   "type": "module",

package/dist/RedisWorkersDurableObjectAdapter.d.ts

@@ -1,5 +0,0 @@
-import type { CacheDriver } from './index.js';
-export declare const RedisWorkersDurableObjectAdapter: Readonly<{
-    create(): CacheDriver;
-}>;
-export default RedisWorkersDurableObjectAdapter;

package/dist/RedisWorkersDurableObjectAdapter.js

@@ -1,129 +0,0 @@
-import { ErrorFactory, Logger } from '@zintrust/core';
-const createSendCommandFunction = (getStub, connect) => {
-    return async (command, args) => {
-        await connect();
-        const stub = getStub();
-        const executePath = 'http://do/execute'; //NOSONAR
-        const payload = JSON.stringify({
-            command,
-            params: args,
-        });
-        const response = await stub.fetch(executePath, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: payload,
-        });
-        if (!response.ok) {
-            const text = await response.text();
-            let errDetail;
-            try {
-                errDetail = JSON.parse(text);
-            }
-            catch {
-                errDetail = { error: text };
-            }
-            const msg = errDetail.error ||
-                errDetail.message ||
-                response.statusText;
-            throw ErrorFactory.createGeneralError(`DO Command Failed: ${msg}`);
-        }
-        const json = (await response.json());
-        if (json !== null && typeof json === 'object' && 'result' in json) {
-            return json.result;
-        }
-        return json;
-    };
-};
-const createConnectionManager = (getNamespace) => {
-    let connected = false;
-    const getStub = () => {
-        const namespace = getNamespace();
-        if (!namespace) {
-            throw ErrorFactory.createConfigError('REDIS_POOL binding not found. Cannot connect to Durable Object pool.');
-        }
-        const id = namespace.idFromName('default');
-        return namespace.get(id);
-    };
-    const connect = async () => {
-        if (connected)
-            return;
-        try {
-            const stub = getStub();
-            const health = 'http://do/health'; //NOSONAR
-            const res = await stub.fetch(health, {
-                method: 'POST',
-            });
-            if (!res.ok) {
-                throw ErrorFactory.createGeneralError(`DO health check failed: ${res.status}`);
-            }
-            const body = (await res.json());
-            if (!body.connected) {
-                Logger.info('[RedisWorkersDurableObjectAdapter] DO not connected yet, will init on first command');
-            }
-            connected = true;
-        }
-        catch (err) {
-            Logger.error('[RedisWorkersDurableObjectAdapter] Connection failed', err);
-            throw ErrorFactory.createGeneralError('Failed to connect to Redis DO', err);
-        }
-    };
-    const sendCommand = createSendCommandFunction(getStub, connect);
-    return {
-        connect,
-        sendCommand,
-        disconnect: () => {
-            connected = false;
-        },
-        isConnected: () => connected,
-    };
-};
-const toNumber = (value) => {
-    if (typeof value === 'number')
-        return value;
-    if (typeof value === 'string') {
-        const parsed = Number(value);
-        return Number.isFinite(parsed) ? parsed : 0;
-    }
-    return 0;
-};
-export const RedisWorkersDurableObjectAdapter = Object.freeze({
-    create() {
-        const connectionManager = createConnectionManager(() => {
-            const globalEnv = globalThis.env;
-            return globalEnv?.['REDIS_POOL'];
-        });
-        return {
-            async get(key) {
-                const raw = await connectionManager.sendCommand('GET', [key]);
-                if (raw === null || raw === undefined)
-                    return null;
-                try {
-                    return JSON.parse(String(raw));
-                }
-                catch {
-                    return null;
-                }
-            },
-            async set(key, value, ttl) {
-                const json = JSON.stringify(value);
-                if (Number.isFinite(ttl) && (ttl ?? 0) > 0) {
-                    await connectionManager.sendCommand('SET', [key, json, 'EX', ttl]);
-                }
-                else {
-                    await connectionManager.sendCommand('SET', [key, json]);
-                }
-            },
-            async delete(key) {
-                await connectionManager.sendCommand('DEL', [key]);
-            },
-            async clear() {
-                await connectionManager.sendCommand('FLUSHDB', []);
-            },
-            async has(key) {
-                const count = await connectionManager.sendCommand('EXISTS', [key]);
-                return toNumber(count) > 0;
-            },
-        };
-    },
-});
-export default RedisWorkersDurableObjectAdapter;