@zintrust/cache-redis 0.4.0 → 0.4.27

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

@@ -0,0 +1,63 @@
+{
+  "name": "@zintrust/cache-redis",
+  "version": "0.1.27",
+  "buildDate": "2026-03-26T14:36:58.621Z",
+  "buildEnvironment": {
+    "node": "v22.22.1",
+    "platform": "darwin",
+    "arch": "arm64"
+  },
+  "git": {
+    "commit": "94caf69e",
+    "branch": "dev"
+  },
+  "package": {
+    "engines": {
+      "node": ">=20.0.0"
+    },
+    "dependencies": [
+      "redis"
+    ],
+    "peerDependencies": [
+      "@zintrust/core"
+    ]
+  },
+  "files": {
+    "RedisProxyAdapter.d.ts": {
+      "size": 163,
+      "sha256": "91df2fbb1916b073c3bafa1dc253ab5ee8998cc924c3cd52308c09798c1d829f"
+    },
+    "RedisProxyAdapter.js": {
+      "size": 5296,
+      "sha256": "a58538d3284829c8d0f3b2a7ed48e7db65098c8047f9f84c1015a22944df0100"
+    },
+    "RedisWorkersDurableObjectAdapter.d.ts": {
+      "size": 193,
+      "sha256": "859d3177d302c65f93add57216eae91d8c45874801bb75bdea3d6f6b00fb00c3"
+    },
+    "RedisWorkersDurableObjectAdapter.js": {
+      "size": 4482,
+      "sha256": "5b0ae2883872ce974ecaf01f07d35b72e6da468439912a57734ccd5222705bfd"
+    },
+    "build-manifest.json": {
+      "size": 1698,
+      "sha256": "612dcaf3b1a76efa9ee3060d3abcea12fffb9cd281fd612fac0ef0bf3cb1df00"
+    },
+    "index.d.ts": {
+      "size": 842,
+      "sha256": "b47614dfdb736524165785958f4a685818c055315961c2e2b48d99ef6ca491e2"
+    },
+    "index.js": {
+      "size": 5428,
+      "sha256": "985f446856ed668c7b18287acd14b24f1b73e39fd3560e9aa7a913d7aba8686f"
+    },
+    "register.d.ts": {
+      "size": 184,
+      "sha256": "005e0163b4f5833a0096cfcba7d5851b6f21c0fea7d8faf01a913dc2808730ad"
+    },
+    "register.js": {
+      "size": 330,
+      "sha256": "9fcab6dfb78323d351970dc89dc713910339fc7b1b392225213a93fbeee7c511"
+    }
+  }
+}

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@zintrust/cache-redis",
-  "version": "0.4.0",
+  "version": "0.4.27",
+  "description": "Redis cache driver for ZinTrust.",
   "private": false,
   "type": "module",
   "main": "./dist/index.js",
@@ -22,11 +23,18 @@
     "node": ">=20.0.0"
   },
   "peerDependencies": {
-    "@zintrust/core": "^0.4.0"
+    "@zintrust/core": "^0.4.27"
   },
   "publishConfig": {
     "access": "public"
   },
+  "keywords": [
+    "zintrust",
+    "cache",
+    "redis",
+    "adapter",
+    "typescript"
+  ],
   "dependencies": {
     "redis": "^5.11.0"
   },