@zintrust/cache-redis 0.1.27 → 0.1.41

package/dist/RedisProxyAdapter.d.ts

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

package/dist/RedisProxyAdapter.js

@@ -0,0 +1,144 @@
+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() === '') {
+        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;
+};
+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;
+        };
+        return {
+            async get(key) {
+                const result = await sendCommand('GET', [key]);
+                if (result === null)
+                    return null;
+                try {
+                    return JSON.parse(result);
+                }
+                catch {
+                    return null;
+                }
+            },
+            async set(key, value, ttl) {
+                const json = JSON.stringify(value);
+                if (Number.isFinite(ttl) && (ttl ?? 0) > 0) {
+                    await sendCommand('SET', [key, json, 'EX', ttl]);
+                }
+                else {
+                    await sendCommand('SET', [key, json]);
+                }
+            },
+            async delete(key) {
+                await sendCommand('DEL', [key]);
+            },
+            async clear() {
+                await sendCommand('FLUSHDB', []);
+            },
+            async has(key) {
+                const result = await sendCommand('EXISTS', [key]);
+                return toNumber(result) > 0;
+            },
+        };
+    },
+});
+export default RedisProxyAdapter;

package/dist/build-manifest.json

@@ -1,14 +1,14 @@
 {
   "name": "@zintrust/cache-redis",
-  "version": "0.1.15",
-  "buildDate": "2026-01-28T12:16:44.297Z",
+  "version": "0.1.27",
+  "buildDate": "2026-02-15T07:16:17.299Z",
   "buildEnvironment": {
     "node": "v20.20.0",
     "platform": "linux",
     "arch": "x64"
   },
   "git": {
-    "commit": "a274786",
+    "commit": "33b681d",
     "branch": "master"
   },
   "package": {
@@ -23,13 +23,21 @@
     ]
   },
   "files": {
+    "RedisProxyAdapter.d.ts": {
+      "size": 163,
+      "sha256": "91df2fbb1916b073c3bafa1dc253ab5ee8998cc924c3cd52308c09798c1d829f"
+    },
+    "RedisProxyAdapter.js": {
+      "size": 5296,
+      "sha256": "a58538d3284829c8d0f3b2a7ed48e7db65098c8047f9f84c1015a22944df0100"
+    },
     "index.d.ts": {
-      "size": 736,
-      "sha256": "0c9eae934ad4888d5ed29d62250010ee904692daace4f47f6461f81ebcf5f3ff"
+      "size": 842,
+      "sha256": "b47614dfdb736524165785958f4a685818c055315961c2e2b48d99ef6ca491e2"
     },
     "index.js": {
-      "size": 2661,
-      "sha256": "4392bb314da8b87f0f294a4e2b856300e46a4de1fc2af54f380b3dde6378c925"
+      "size": 5422,
+      "sha256": "462d16289788ef6d27d1688be9dbd17a8baeb939ec088fc68294dfc8ce4ca0f8"
     },
     "register.d.ts": {
       "size": 184,

package/dist/index.d.ts

@@ -10,11 +10,14 @@ export type RedisCacheConfig = {
     host: string;
     port: number;
     ttl: number;
+    password?: string;
+    database?: number;
 };
 export declare const RedisCacheDriver: Readonly<{
     create(config: RedisCacheConfig): CacheDriver;
 }>;
 export default RedisCacheDriver;
+export { RedisProxyAdapter } from './RedisProxyAdapter.js';
 /**
  * Package version and build metadata
  * Available at runtime for debugging and health checks

package/dist/index.js

@@ -1,72 +1,150 @@
-import { Logger } from '@zintrust/core';
+import { Cloudflare, Env, ErrorFactory, Logger, createRedisConnection } from '@zintrust/core';
+import { RedisProxyAdapter } from './RedisProxyAdapter.js';
+const safeJsonParse = (value) => {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return null;
+    }
+};
 async function importRedis() {
     return (await import('redis'));
 }
-export const RedisCacheDriver = Object.freeze({
-    create(config) {
-        let client;
-        let connected = false;
-        const ensureClient = async () => {
-            if (client === undefined) {
-                const { createClient } = await importRedis();
-                client = createClient({ socket: { host: config.host, port: config.port } });
-            }
-            if (!connected) {
-                await client.connect();
-                connected = true;
-            }
-            return client;
-        };
-        const safeJsonParse = (value) => {
+const createCacheOperations = (ensureClient, operations, defaultTtl) => {
+    return {
+        async get(key) {
             try {
-                return JSON.parse(value);
+                const client = await ensureClient();
+                const value = await operations.get(client, key);
+                if (value === null)
+                    return null;
+                return safeJsonParse(value);
             }
-            catch {
+            catch (error) {
+                Logger.error('Redis cache GET failed', error);
                 return null;
             }
-        };
-        return {
-            async get(key) {
-                try {
-                    const c = await ensureClient();
-                    const value = await c.get(key);
-                    if (value === null)
-                        return null;
-                    return safeJsonParse(value);
-                }
-                catch (error) {
-                    Logger.error('Redis cache GET failed', error);
-                    return null;
-                }
-            },
-            async set(key, value, ttl) {
-                const c = await ensureClient();
-                const json = JSON.stringify(value);
-                const effectiveTtl = ttl ?? config.ttl;
-                if (Number.isFinite(effectiveTtl) && effectiveTtl > 0) {
-                    await c.set(key, json, { EX: effectiveTtl });
-                }
-                else {
-                    await c.set(key, json);
-                }
-            },
-            async delete(key) {
-                const c = await ensureClient();
-                await c.del(key);
-            },
-            async clear() {
-                const c = await ensureClient();
-                await c.flushDb();
-            },
-            async has(key) {
-                const c = await ensureClient();
-                const count = await c.exists(key);
-                return count > 0;
-            },
-        };
+        },
+        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);
+        },
+        async delete(key) {
+            const client = await ensureClient();
+            await operations.del(client, key);
+        },
+        async clear() {
+            const client = await ensureClient();
+            await operations.clear(client);
+        },
+        async has(key) {
+            const client = await ensureClient();
+            const count = await operations.exists(client, key);
+            return count > 0;
+        },
+    };
+};
+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,
+            });
+        }
+        if (!connected && typeof client.connect === 'function') {
+            await client.connect();
+            connected = true;
+        }
+        return client;
+    };
+    return createCacheOperations(ensureClient, {
+        get: (redisClient, key) => redisClient.get(key),
+        set: (redisClient, key, json, ttl) => {
+            if (Number.isFinite(ttl) && ttl > 0) {
+                return redisClient.set(key, json, { EX: ttl });
+            }
+            else {
+                return redisClient.set(key, json);
+            }
+        },
+        del: (redisClient, key) => {
+            redisClient.del(key);
+            return Promise.resolve();
+        },
+        clear: (redisClient) => {
+            if (typeof redisClient.flushDb === 'function') {
+                return redisClient.flushDb();
+            }
+            else if (typeof redisClient.flushdb === 'function') {
+                return redisClient.flushdb();
+            }
+            return Promise.resolve();
+        },
+        exists: (redisClient, key) => redisClient.exists(key),
+    }, config.ttl ?? 300);
+};
+const createNodeCacheDriver = (config) => {
+    let client;
+    let connected = false;
+    const ensureClient = async () => {
+        if (client === undefined) {
+            const { createClient } = await importRedis();
+            client = createClient({ socket: { host: config.host, port: config.port } });
+        }
+        if (!connected) {
+            await client.connect();
+            connected = true;
+        }
+        return client;
+    };
+    return createCacheOperations(ensureClient, {
+        get: (redisClient, key) => redisClient.get(key),
+        set: (redisClient, key, json, ttl) => {
+            if (Number.isFinite(ttl) && ttl > 0) {
+                return redisClient.set(key, json, { EX: ttl });
+            }
+            else {
+                return redisClient.set(key, json);
+            }
+        },
+        del: (redisClient, key) => {
+            redisClient.del(key);
+            return Promise.resolve();
+        },
+        clear: (redisClient) => {
+            redisClient.flushDb();
+            return Promise.resolve();
+        },
+        exists: (redisClient, key) => redisClient.exists(key),
+    }, config.ttl ?? 300);
+};
+const shouldUseProxy = () => {
+    if (Env.REDIS_PROXY_URL.trim() !== '')
+        return true;
+    return Env.USE_REDIS_PROXY === true;
+};
+export const RedisCacheDriver = Object.freeze({
+    create(config) {
+        const isWorkers = Cloudflare.getWorkersEnv() !== null;
+        if (shouldUseProxy()) {
+            return RedisProxyAdapter.create();
+        }
+        if (isWorkers && Cloudflare.isCloudflareSocketsEnabled() === false) {
+            throw ErrorFactory.createConfigError('Redis cache driver requires ENABLE_CLOUDFLARE_SOCKETS=true in Cloudflare Workers.');
+        }
+        return isWorkers ? createWorkersCacheDriver(config) : createNodeCacheDriver(config);
     },
 });
 export default RedisCacheDriver;
+export { RedisProxyAdapter } from './RedisProxyAdapter.js';
 /**
  * Package version and build metadata
  * Available at runtime for debugging and health checks

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zintrust/cache-redis",
-  "version": "0.1.27",
+  "version": "0.1.41",
   "private": false,
   "type": "module",
   "main": "./dist/index.js",
@@ -22,7 +22,7 @@
     "node": ">=20.0.0"
   },
   "peerDependencies": {
-    "@zintrust/core": "^0.1.27"
+    "@zintrust/core": "^0.1.41"
   },
   "publishConfig": {
     "access": "public"