@zintrust/cache-redis 0.4.70 → 0.4.72

package/dist/RedisWorkersDurableObjectAdapter.d.ts

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

package/dist/RedisWorkersDurableObjectAdapter.js

@@ -0,0 +1,129 @@
+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;

package/dist/build-manifest.json

@@ -1,15 +1,15 @@
 {
   "name": "@zintrust/cache-redis",
-  "version": "0.4.70",
-  "buildDate": "2026-04-06T16:04:58.363Z",
+  "version": "0.4.72",
+  "buildDate": "2026-04-06T17:13:09.661Z",
   "buildEnvironment": {
-    "node": "v20.20.2",
-    "platform": "linux",
-    "arch": "x64"
+    "node": "v22.22.1",
+    "platform": "darwin",
+    "arch": "arm64"
   },
   "git": {
-    "commit": "b92b2b05",
-    "branch": "master"
+    "commit": "996fb4dc",
+    "branch": "release"
   },
   "package": {
     "engines": {
@@ -31,13 +31,25 @@
       "size": 1693,
       "sha256": "b1cd4417d827598b41226597355559eef423eac869448df5fd94d338d16a09f2"
     },
+    "RedisWorkersDurableObjectAdapter.d.ts": {
+      "size": 193,
+      "sha256": "859d3177d302c65f93add57216eae91d8c45874801bb75bdea3d6f6b00fb00c3"
+    },
+    "RedisWorkersDurableObjectAdapter.js": {
+      "size": 4482,
+      "sha256": "5b0ae2883872ce974ecaf01f07d35b72e6da468439912a57734ccd5222705bfd"
+    },
+    "build-manifest.json": {
+      "size": 1702,
+      "sha256": "56b119a0de0905853463885edc07919693b509d40cd06133ffa91eb3a600ab56"
+    },
     "index.d.ts": {
       "size": 842,
       "sha256": "b47614dfdb736524165785958f4a685818c055315961c2e2b48d99ef6ca491e2"
     },
     "index.js": {
-      "size": 5371,
-      "sha256": "9caa2ed06025012497e5d62fd6451ff6bef9731e9545493644616b90aa0da7ad"
+      "size": 6819,
+      "sha256": "52212fcd6e65730e0fedae07e2207c4270cd40cc1e437a471a9e89b7eebf49c9"
     },
     "register.d.ts": {
       "size": 184,

package/dist/index.js

@@ -11,9 +11,27 @@ const safeJsonParse = (value) => {
 async function importRedis() {
     return (await import('redis'));
 }
+const logCacheFailure = (action, error) => {
+    Logger.error(`Redis cache ${action} failed`, error);
+};
+const createCacheFailureState = () => {
+    let disabled = false;
+    return {
+        isDisabled: () => disabled,
+        disableAfterFailure: (action, error) => {
+            if (!disabled) {
+                logCacheFailure(action, error);
+            }
+            disabled = true;
+        },
+    };
+};
 const createCacheOperations = (ensureClient, operations, defaultTtl) => {
+    const failureState = createCacheFailureState();
     return {
         async get(key) {
+            if (failureState.isDisabled())
+                return null;
             try {
                 const client = await ensureClient();
                 const value = await operations.get(client, key);
@@ -22,28 +40,57 @@ const createCacheOperations = (ensureClient, operations, defaultTtl) => {
                 return safeJsonParse(value);
             }
             catch (error) {
-                Logger.error('Redis cache GET failed', error);
+                failureState.disableAfterFailure('GET', error);
                 return null;
             }
         },
         async set(key, value, ttl) {
-            const client = await ensureClient();
-            const json = JSON.stringify(value);
-            const effectiveTtl = ttl ?? defaultTtl;
-            await operations.set(client, key, json, effectiveTtl);
+            if (failureState.isDisabled())
+                return;
+            try {
+                const client = await ensureClient();
+                const json = JSON.stringify(value);
+                const effectiveTtl = ttl ?? defaultTtl;
+                await operations.set(client, key, json, effectiveTtl);
+            }
+            catch (error) {
+                failureState.disableAfterFailure('SET', error);
+            }
         },
         async delete(key) {
-            const client = await ensureClient();
-            await operations.del(client, key);
+            if (failureState.isDisabled())
+                return;
+            try {
+                const client = await ensureClient();
+                await operations.del(client, key);
+            }
+            catch (error) {
+                failureState.disableAfterFailure('DEL', error);
+            }
         },
         async clear() {
-            const client = await ensureClient();
-            await operations.clear(client);
+            if (failureState.isDisabled())
+                return;
+            try {
+                const client = await ensureClient();
+                await operations.clear(client);
+            }
+            catch (error) {
+                failureState.disableAfterFailure('FLUSHDB', error);
+            }
         },
         async has(key) {
-            const client = await ensureClient();
-            const count = await operations.exists(client, key);
-            return count > 0;
+            if (failureState.isDisabled())
+                return false;
+            try {
+                const client = await ensureClient();
+                const count = await operations.exists(client, key);
+                return count > 0;
+            }
+            catch (error) {
+                failureState.disableAfterFailure('EXISTS', error);
+                return false;
+            }
         },
     };
 };
@@ -73,9 +120,8 @@ const createWorkersCacheDriver = (config) => {
                 return redisClient.set(key, json);
             }
         },
-        del: (redisClient, key) => {
-            redisClient.del(key);
-            return Promise.resolve();
+        del: async (redisClient, key) => {
+            await redisClient.del(key);
         },
         clear: (redisClient) => {
             if (typeof redisClient.flushDb === 'function') {
@@ -95,7 +141,11 @@ const createNodeCacheDriver = (config) => {
     const ensureClient = async () => {
         if (client === undefined) {
             const { createClient } = await importRedis();
-            client = createClient({ socket: { host: config.host, port: config.port } });
+            client = createClient({
+                socket: { host: config.host, port: config.port },
+                password: config.password,
+                database: config.database ?? 0,
+            });
         }
         if (!connected) {
             await client.connect();
@@ -113,14 +163,10 @@ const createNodeCacheDriver = (config) => {
                 return redisClient.set(key, json);
             }
         },
-        del: (redisClient, key) => {
-            redisClient.del(key);
-            return Promise.resolve();
-        },
-        clear: (redisClient) => {
-            redisClient.flushDb();
-            return Promise.resolve();
+        del: async (redisClient, key) => {
+            await redisClient.del(key);
         },
+        clear: (redisClient) => redisClient.flushDb(),
         exists: (redisClient, key) => redisClient.exists(key),
     }, config.ttl ?? 300);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zintrust/cache-redis",
-  "version": "0.4.70",
+  "version": "0.4.72",
   "description": "Redis cache driver for ZinTrust.",
   "private": false,
   "type": "module",
@@ -23,7 +23,7 @@
     "node": ">=20.0.0"
   },
   "peerDependencies": {
-    "@zintrust/core": "^0.4.70"
+    "@zintrust/core": "^0.4.72"
   },
   "publishConfig": {
     "access": "public"