@zintrust/cache-redis 0.4.27 → 0.4.43

package/dist/RedisProxyAdapter.js

@@ -1,115 +1,21 @@
-import { Env, ErrorFactory, Logger, SignedRequest } from '@zintrust/core';
-const resolveSigningPrefix = (baseUrl) => {
-    try {
-        const parsed = new URL(baseUrl);
-        const path = parsed.pathname.endsWith('/') ? parsed.pathname.slice(0, -1) : parsed.pathname;
-        if (path === '' || path === '/')
-            return undefined;
-        return path;
-    }
-    catch {
-        return undefined;
-    }
-};
-const buildRequestUrl = (baseUrl, path) => {
-    const url = new URL(baseUrl);
-    const basePath = url.pathname.endsWith('/') ? url.pathname.slice(0, -1) : url.pathname;
-    const requestPath = path.startsWith('/') ? path : `/${path}`;
-    url.pathname = `${basePath}${requestPath}`;
-    return url;
-};
-const buildSigningUrl = (requestUrl, baseUrl) => {
-    const prefix = resolveSigningPrefix(baseUrl);
-    if (!prefix)
-        return requestUrl;
-    if (requestUrl.pathname === prefix || requestUrl.pathname.startsWith(`${prefix}/`)) {
-        const signingUrl = new URL(requestUrl.toString());
-        const stripped = requestUrl.pathname.slice(prefix.length);
-        signingUrl.pathname = stripped.startsWith('/') ? stripped : `/${stripped}`;
-        return signingUrl;
-    }
-    return requestUrl;
-};
-const resolveBaseUrl = () => {
-    const explicit = Env.get('REDIS_PROXY_URL', '').trim();
-    if (explicit !== '')
-        return explicit;
-    const host = Env.get('REDIS_PROXY_HOST', '127.0.0.1');
-    const port = Env.getInt('REDIS_PROXY_PORT', 8791);
-    return `http://${host}:${port}`;
-};
-const buildProxySettings = () => {
-    const baseUrl = resolveBaseUrl();
-    const rawKeyId = Env.get('REDIS_PROXY_KEY_ID', '').trim();
-    const fallbackKeyId = (Env.APP_NAME ?? 'zintrust').trim().toLowerCase().replaceAll(/\s+/g, '_');
-    const keyId = (rawKeyId === '' ? fallbackKeyId : rawKeyId) || undefined;
-    const secret = Env.get('REDIS_PROXY_SECRET', '') || Env.APP_KEY || undefined;
-    const timeoutMs = Env.getInt('REDIS_PROXY_TIMEOUT_MS', Env.ZT_PROXY_TIMEOUT_MS);
-    return { baseUrl, keyId, secret, timeoutMs };
-};
-const buildHeaders = async (settings, requestUrl, body) => {
-    const headers = {
-        'Content-Type': 'application/json',
-    };
-    if (settings.keyId && settings.secret) {
-        const signingUrl = buildSigningUrl(requestUrl, settings.baseUrl);
-        const signed = await SignedRequest.createHeaders({
-            method: 'POST',
-            url: signingUrl,
-            body,
-            keyId: settings.keyId,
-            secret: settings.secret,
-        });
-        Object.assign(headers, signed);
-    }
-    else {
-        Logger.warn('[redis-proxy] Proxy signing disabled; sending unsigned request.');
-    }
-    return headers;
-};
-const requestProxy = async (settings, path, payload) => {
-    if (settings.baseUrl.trim() === '') {
+import { Env, ErrorFactory, createRedisConnection } from '@zintrust/core';
+const createProxyClient = () => {
+    if (Env.REDIS_PROXY_URL.trim() === '' && Env.USE_REDIS_PROXY !== true) {
         throw ErrorFactory.createConfigError('Redis proxy URL is missing (REDIS_PROXY_URL)');
     }
-    const body = JSON.stringify(payload);
-    const url = buildRequestUrl(settings.baseUrl, path);
-    const headers = await buildHeaders(settings, url, body);
-    const timeoutSignal = typeof AbortSignal !== 'undefined' && 'timeout' in AbortSignal;
-    const signal = timeoutSignal ? AbortSignal.timeout(settings.timeoutMs) : undefined;
-    const response = await fetch(url.toString(), {
-        method: 'POST',
-        headers,
-        body,
-        signal,
-    });
-    if (!response.ok) {
-        const text = await response.text();
-        throw ErrorFactory.createTryCatchError(`Redis proxy request failed (${response.status})`, text);
-    }
-    return (await response.json());
-};
-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;
+    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' });
 };
 export const RedisProxyAdapter = Object.freeze({
     create() {
-        const settings = buildProxySettings();
-        const sendCommand = async (command, args) => {
-            const response = await requestProxy(settings, '/zin/redis/command', {
-                command,
-                args,
-            });
-            return response.result;
-        };
+        const client = createProxyClient();
         return {
             async get(key) {
-                const result = await sendCommand('GET', [key]);
+                const result = await client.get(key);
                 if (result === null)
                     return null;
                 try {
@@ -122,21 +28,21 @@ export const RedisProxyAdapter = Object.freeze({
             async set(key, value, ttl) {
                 const json = JSON.stringify(value);
                 if (Number.isFinite(ttl) && (ttl ?? 0) > 0) {
-                    await sendCommand('SET', [key, json, 'EX', ttl]);
+                    await client.set(key, json, 'EX', ttl);
                 }
                 else {
-                    await sendCommand('SET', [key, json]);
+                    await client.set(key, json);
                 }
             },
             async delete(key) {
-                await sendCommand('DEL', [key]);
+                await client.del(key);
             },
             async clear() {
-                await sendCommand('FLUSHDB', []);
+                await client.flushdb();
             },
             async has(key) {
-                const result = await sendCommand('EXISTS', [key]);
-                return toNumber(result) > 0;
+                const result = await client.exists(key);
+                return result > 0;
             },
         };
     },

package/dist/build-manifest.json

@@ -1,15 +1,15 @@
 {
   "name": "@zintrust/cache-redis",
-  "version": "0.1.27",
-  "buildDate": "2026-03-26T14:36:58.621Z",
+  "version": "0.4.43",
+  "buildDate": "2026-04-01T18:12:00.772Z",
   "buildEnvironment": {
     "node": "v22.22.1",
     "platform": "darwin",
     "arch": "arm64"
   },
   "git": {
-    "commit": "94caf69e",
-    "branch": "dev"
+    "commit": "57e4d1b5",
+    "branch": "release"
   },
   "package": {
     "engines": {
@@ -28,8 +28,8 @@
       "sha256": "91df2fbb1916b073c3bafa1dc253ab5ee8998cc924c3cd52308c09798c1d829f"
     },
     "RedisProxyAdapter.js": {
-      "size": 5296,
-      "sha256": "a58538d3284829c8d0f3b2a7ed48e7db65098c8047f9f84c1015a22944df0100"
+      "size": 1693,
+      "sha256": "b1cd4417d827598b41226597355559eef423eac869448df5fd94d338d16a09f2"
     },
     "RedisWorkersDurableObjectAdapter.d.ts": {
       "size": 193,
@@ -40,16 +40,16 @@
       "sha256": "5b0ae2883872ce974ecaf01f07d35b72e6da468439912a57734ccd5222705bfd"
     },
     "build-manifest.json": {
-      "size": 1698,
-      "sha256": "612dcaf3b1a76efa9ee3060d3abcea12fffb9cd281fd612fac0ef0bf3cb1df00"
+      "size": 1701,
+      "sha256": "e4b4002108e2ada6e393d6716d6eab75e1b98b82eee0a9c3e5c1402f7f23882e"
     },
     "index.d.ts": {
       "size": 842,
       "sha256": "b47614dfdb736524165785958f4a685818c055315961c2e2b48d99ef6ca491e2"
     },
     "index.js": {
-      "size": 5428,
-      "sha256": "985f446856ed668c7b18287acd14b24f1b73e39fd3560e9aa7a913d7aba8686f"
+      "size": 5371,
+      "sha256": "91cf637340e283c2c90e4cc11d2be1aa1ee2a009df282356bda4db9c7e57e54a"
     },
     "register.d.ts": {
       "size": 184,

package/dist/index.js

@@ -1,5 +1,5 @@
 import { Cloudflare, Env, ErrorFactory, Logger, createRedisConnection } from '@zintrust/core';
-import { RedisProxyAdapter } from './RedisProxyAdapter.js';
+const createSharedRedisConnection = createRedisConnection;
 const safeJsonParse = (value) => {
     try {
         return JSON.parse(value);
@@ -51,14 +51,12 @@ const createWorkersCacheDriver = (config) => {
     let client;
     let connected = false;
     const ensureClient = async () => {
-        if (client === undefined) {
-            client = createRedisConnection({
-                host: config.host,
-                port: config.port,
-                password: config.password,
-                db: config.database ?? 0,
-            });
-        }
+        client ??= createSharedRedisConnection({
+            host: config.host,
+            port: config.port,
+            password: config.password,
+            db: config.database ?? 0,
+        }, 3, { subsystem: 'cache' });
         if (!connected && typeof client.connect === 'function') {
             await client.connect();
             connected = true;
@@ -127,15 +125,13 @@ const createNodeCacheDriver = (config) => {
     }, config.ttl ?? 300);
 };
 const shouldUseProxy = () => {
-    if (Env.REDIS_PROXY_URL.trim() !== '')
-        return true;
-    return Env.USE_REDIS_PROXY === true;
+    return Env.REDIS_PROXY_URL.trim() !== '' || Env.USE_REDIS_PROXY === true;
 };
 export const RedisCacheDriver = Object.freeze({
     create(config) {
         const isWorkers = Cloudflare.getWorkersEnv() !== null;
         if (shouldUseProxy()) {
-            return RedisProxyAdapter.create();
+            return createWorkersCacheDriver(config);
         }
         if (isWorkers && Cloudflare.isCloudflareSocketsEnabled() === false) {
             throw ErrorFactory.createConfigError('Redis cache driver requires ENABLE_CLOUDFLARE_SOCKETS=true in Cloudflare Workers.');

package/package.json

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