@zintrust/queue-redis 0.1.20 → 0.1.27

package/dist/RedisPublishClient.js

@@ -0,0 +1,251 @@
+import { Env, ErrorFactory, SignedRequest, ZintrustLang } 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;
+};
+let publishClientInstance = null;
+let publishClientConnected = false;
+const resolveProxyBaseUrl = () => {
+    const explicit = Env.REDIS_PROXY_URL.trim();
+    if (explicit !== '')
+        return explicit;
+    if (Env.USE_REDIS_PROXY === false)
+        return '';
+    const host = Env.REDIS_PROXY_HOST || '127.0.0.1';
+    const port = Env.REDIS_PROXY_PORT;
+    return `http://${host}:${port}`;
+};
+const buildProxySettings = () => {
+    const baseUrl = resolveProxyBaseUrl();
+    const keyId = Env.REDIS_PROXY_KEY_ID || undefined;
+    const secret = Env.REDIS_PROXY_SECRET || Env.APP_KEY || undefined;
+    const timeoutMs = Env.REDIS_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);
+    }
+    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;
+};
+const tryCreateProxyPublishClient = async () => {
+    const settings = buildProxySettings();
+    if (settings.baseUrl.trim() === '')
+        return null;
+    return {
+        publish: async (channel, message) => {
+            const response = await requestProxy(settings, '/zin/redis/command', {
+                command: 'PUBLISH',
+                args: [channel, message],
+            });
+            return toNumber(response.result);
+        },
+    };
+};
+/**
+ * Build Redis URL from environment variables
+ */
+const buildRedisUrl = () => {
+    // Get REDIS_URL from environment
+    const redisUrl = getRedisUrlFromEnv();
+    if (redisUrl)
+        return redisUrl;
+    // Build URL from individual components
+    return buildRedisUrlFromComponents();
+};
+/**
+ * Get REDIS_URL from environment variables
+ */
+const getRedisUrlFromEnv = () => {
+    const anyEnv = process.env;
+    const fromEnv = typeof anyEnv.get === 'function' ? anyEnv.get('REDIS_URL', '') : '';
+    const hasProcess = typeof process === 'object' && process !== null;
+    const fallback = hasProcess ? (process.env?.['REDIS_URL'] ?? '') : '';
+    const trimmed = fromEnv.trim();
+    const url = (trimmed.length > 0 ? fromEnv : String(fallback)).trim();
+    return url.length > 0 ? url : null;
+};
+/**
+ * Build Redis URL from individual environment components
+ */
+const buildRedisUrlFromComponents = () => {
+    const host = process.env?.['REDIS_HOST'] ?? 'localhost';
+    const port = Number(process.env?.['REDIS_PORT'] ?? ZintrustLang.REDIS_DEFAULT_PORT);
+    const password = process.env?.['REDIS_PASSWORD'];
+    const database = Number(process.env?.['REDIS_QUEUE_DB'] ?? ZintrustLang.REDIS_DEFAULT_DB);
+    let redisUrl = `redis://`;
+    if (password)
+        redisUrl += `:${password}@`;
+    redisUrl += `${host}:${port}`;
+    if (database > 0)
+        redisUrl += `/${database}`;
+    return redisUrl;
+};
+/**
+ * Singleton Redis publish client factory
+ * Creates and caches a Redis publish client for broadcasting
+ */
+export const createRedisPublishClient = async () => {
+    // Return cached instance if available
+    if (publishClientConnected && publishClientInstance !== null) {
+        return publishClientInstance;
+    }
+    const proxyClient = await tryCreateProxyPublishClient();
+    if (proxyClient) {
+        return cacheAndReturnClient(proxyClient);
+    }
+    const url = buildRedisUrl();
+    if (url === null)
+        throw ErrorFactory.createConfigError('Redis publish client requires REDIS_URL');
+    // Try different Redis clients in order of preference
+    const redisClient = (await tryCreateRedisClient(url)) || (await tryCreateIoRedisClient(url)) || getFallbackClient();
+    return redisClient;
+};
+/**
+ * Try to create client using 'redis' package
+ */
+const tryCreateRedisClient = async (url) => {
+    try {
+        const mod = (await import('redis'));
+        const client = mod.createClient({ url });
+        if (typeof client.connect === 'function') {
+            await connectClient(client, 'Redis publish client failed to connect');
+        }
+        return cacheAndReturnClient(client);
+    }
+    catch {
+        return null;
+    }
+};
+/**
+ * Try to create client using 'ioredis' package
+ */
+const tryCreateIoRedisClient = async (url) => {
+    try {
+        const mod = (await import('ioredis'));
+        const redis = mod.default(url);
+        const client = {
+            publish: (channel, message) => redis.publish(channel, message),
+            connect: redis.connect
+                ? async () => {
+                    const connectFn = redis.connect;
+                    await connectFn();
+                }
+                : undefined,
+        };
+        if (typeof client.connect === 'function') {
+            await connectClient(client, 'Redis publish client (ioredis) failed to connect');
+        }
+        return cacheAndReturnClient(client);
+    }
+    catch {
+        return null;
+    }
+};
+/**
+ * Get fallback client from global or throw error
+ */
+const getFallbackClient = () => {
+    const globalFake = globalThis
+        .__fakeRedisClient;
+    if (globalFake === undefined) {
+        throw ErrorFactory.createConfigError("Redis publish client requires the 'redis' or 'ioredis' package (run `zin add broadcast:redis' / `zin plugin install broadcast:redis`, or `npm install redis` / `npm install ioredis`) or a test fake client set in globalThis.__fakeRedisClient");
+    }
+    return cacheAndReturnClient(globalFake);
+};
+/**
+ * Connect to Redis client with error handling
+ */
+const connectClient = async (client, errorMessage) => {
+    try {
+        if (client.connect) {
+            await client.connect();
+        }
+    }
+    catch (err) {
+        throw ErrorFactory.createTryCatchError(errorMessage, err);
+    }
+};
+/**
+ * Cache and return the client instance
+ */
+const cacheAndReturnClient = (client) => {
+    publishClientInstance = client;
+    publishClientConnected = true;
+    return client;
+};
+/**
+ * Reset the singleton publish client (useful for testing)
+ */
+export const resetPublishClient = () => {
+    publishClientInstance = null;
+    publishClientConnected = false;
+};

package/dist/RedisQueue.d.ts

@@ -0,0 +1,10 @@
+import type { QueueMessage } from '@zintrust/core';
+interface IQueueDriver {
+    enqueue<T = unknown>(queue: string, payload: T): Promise<string>;
+    dequeue<T = unknown>(queue: string): Promise<QueueMessage<T> | undefined>;
+    ack(queue: string, id: string): Promise<void>;
+    length(queue: string): Promise<number>;
+    drain(queue: string): Promise<void>;
+}
+export declare const RedisQueue: IQueueDriver;
+export default RedisQueue;

package/dist/RedisQueue.js

@@ -0,0 +1,92 @@
+import { ErrorFactory, generateUuid, getRedisUrl, Logger } from '@zintrust/core';
+export const RedisQueue = (() => {
+    let client = null;
+    let connected = false;
+    const ensureClient = async () => {
+        if (connected && client !== null)
+            return client;
+        const url = getRedisUrl();
+        if (url === null)
+            throw ErrorFactory.createConfigError('Redis queue driver requires REDIS_URL');
+        // Import lazily so package is optional for environments that don't use Redis
+        try {
+            // Prefer the redis package when available
+            try {
+                const mod = (await import('redis'));
+                const createClient = mod.createClient;
+                client = createClient({ url });
+                if (typeof client.connect === 'function') {
+                    try {
+                        await client.connect();
+                        connected = true;
+                    }
+                    catch (connectionError) {
+                        connected = false;
+                        Logger.warn('Redis client connect failed:', String(connectionError));
+                    }
+                }
+                else {
+                    connected = true;
+                }
+            }
+            catch {
+                // Fallback to ioredis when available (used by queue-monitor)
+                const mod = (await import('ioredis'));
+                const redis = mod.default(url);
+                client = {
+                    rPush: (queue, value) => redis.rpush(queue, value),
+                    lPop: (queue) => redis.lpop(queue),
+                    lLen: (queue) => redis.llen(queue),
+                    del: (queue) => redis.del(queue),
+                };
+                connected = true;
+            }
+        }
+        catch (error) {
+            const globalFake = globalThis
+                .__fakeRedisClient;
+            if (globalFake === undefined) {
+                throw ErrorFactory.createConfigError("Redis queue driver requires the 'redis' or 'ioredis' package (run `zin add queue:redis` / `zin plugin install queue:redis`, or `npm install redis` / `npm install ioredis`) or a test fake client set in globalThis.__fakeRedisClient", error);
+            }
+            client = globalFake;
+            connected = true;
+        }
+        if (client === null)
+            throw ErrorFactory.createConfigError('Redis client could not be initialized');
+        return client;
+    };
+    return {
+        async enqueue(queue, payload) {
+            const cli = await ensureClient();
+            const id = generateUuid();
+            const msg = JSON.stringify({ id, payload, attempts: 0 });
+            await cli.rPush(queue, msg);
+            return id;
+        },
+        async dequeue(queue) {
+            const cli = await ensureClient();
+            const raw = await cli.lPop(queue);
+            if (raw === null)
+                return undefined;
+            try {
+                const parsed = JSON.parse(raw);
+                return parsed;
+            }
+            catch (err) {
+                throw ErrorFactory.createTryCatchError('Failed to parse queue message', err);
+            }
+        },
+        async ack(_queue, _id) {
+            return Promise.resolve(); // NOSONAR
+        },
+        async length(queue) {
+            const cli = await ensureClient();
+            return cli.lLen(queue);
+        },
+        async drain(queue) {
+            const cli = await ensureClient();
+            await cli.del(queue);
+        },
+    };
+})();
+export default RedisQueue;

package/dist/build-manifest.json

@@ -0,0 +1,88 @@
+{
+  "name": "@zintrust/queue-redis",
+  "version": "0.1.27",
+  "buildDate": "2026-03-26T09:12:06.897Z",
+  "buildEnvironment": {
+    "node": "v25.6.1",
+    "platform": "darwin",
+    "arch": "arm64"
+  },
+  "git": {
+    "commit": "597f453f",
+    "branch": "dev"
+  },
+  "package": {
+    "engines": {
+      "node": ">=20.0.0"
+    },
+    "dependencies": [
+      "ioredis",
+      "redis"
+    ],
+    "peerDependencies": [
+      "@zintrust/core"
+    ]
+  },
+  "files": {
+    "BullMQRedisQueue.d.ts": {
+      "size": 1062,
+      "sha256": "52fb0f688cd17cc7d8e8128e60df6f5eea4c803282382ac75550e6aacee7cbb0"
+    },
+    "BullMQRedisQueue.js": {
+      "size": 20130,
+      "sha256": "25e6fb6928236fe10959d2d6a3849ee7845d89e7469b12e57d4f945d32f7304f"
+    },
+    "HttpQueueDriver.d.ts": {
+      "size": 835,
+      "sha256": "31735e10a83cf905ca48f3bf1c79f40029b9ac7c0ce6c26751ad646fa77bc764"
+    },
+    "HttpQueueDriver.js": {
+      "size": 8967,
+      "sha256": "1ed2cbcee0df24c42760222eb2cab2fac21d4547c153453ce4a8623e5b83b5c3"
+    },
+    "QueueHttpGateway.d.ts": {
+      "size": 432,
+      "sha256": "16c32e2179c3286569714233a9f84f32a64056593fe502a381dc9bc45e972e3a"
+    },
+    "QueueHttpGateway.js": {
+      "size": 8066,
+      "sha256": "ad4b78c5a40221aa6cf1f5959729f7ad9f6b0321c443723fff481c7dbfb91239"
+    },
+    "RedisPublishClient.d.ts": {
+      "size": 451,
+      "sha256": "341a68a3b8603b453146dc721f9d2eaf0d65bb6a1acb67908a9c6f9542b9fd2d"
+    },
+    "RedisPublishClient.js": {
+      "size": 8688,
+      "sha256": "4252875ce0326c74fb96bd6901e328bff4a4f6cd894681a3378f990a528880ff"
+    },
+    "RedisQueue.d.ts": {
+      "size": 438,
+      "sha256": "eefad366ae71d63044b23038265bf3eb60a0277e41ac70f57c5973d79f2af5ce"
+    },
+    "RedisQueue.js": {
+      "size": 3593,
+      "sha256": "dc8b2c28b2e288e048423067f90ffbe0389ac813086246a1c8fafeeeab5c142d"
+    },
+    "build-manifest.json": {
+      "size": 2508,
+      "sha256": "4c5170b80a1f21694c96af04dd5c10b7597ba3d52780a577eff04458b727e571"
+    },
+    "index.d.ts": {
+      "size": 565,
+      "sha256": "7bc063419989a39530b3a4213627e0aea33fbaacac8c307d9e7e654c99bd5b8d"
+    },
+    "index.js": {
+      "size": 677,
+      "sha256": "aa8fbba3ba7a6f0a603c3e57dd49cbc43a028273ceba9c45eb584baaa20a37bd"
+    },
+    "register.d.ts": {
+      "size": 169,
+      "sha256": "1ba6de37e0d3276ed9b9e6de02541aab03d3d1b7d3246013af27b66179c38948"
+    },
+    "register.js": {
+      "size": 513,
+      "sha256": "3c5de15f10641521cac21e0a26112bb7bde615c60652327210e77b5c90307409"
+    }
+  }
+}

package/dist/index.d.ts

@@ -1,3 +1,11 @@
-declare const RedisQueue: any;
-export { RedisQueue };
+export { BullMQRedisQueue } from './BullMQRedisQueue';
+export { HttpQueueDriver } from './HttpQueueDriver';
+export { QueueHttpGateway } from './QueueHttpGateway';
+export { createRedisPublishClient, resetPublishClient, type RedisPublishClient, } from './RedisPublishClient';
 export type { QueueMessage } from '@zintrust/core';
+/**
+ * Package version and build metadata
+ * Available at runtime for debugging and health checks
+ */
+export declare const _ZINTRUST_QUEUE_REDIS_VERSION = "0.1.15";
+export declare const _ZINTRUST_QUEUE_REDIS_BUILD_DATE = "__BUILD_DATE__";

package/dist/index.js

@@ -1,3 +1,10 @@
-import { RedisQueue as CoreRedisQueue } from '@zintrust/core';
-const RedisQueue = CoreRedisQueue;
-export { RedisQueue };
+export { BullMQRedisQueue } from './BullMQRedisQueue.js';
+export { HttpQueueDriver } from './HttpQueueDriver.js';
+export { QueueHttpGateway } from './QueueHttpGateway.js';
+export { createRedisPublishClient, resetPublishClient, } from './RedisPublishClient.js';
+/**
+ * Package version and build metadata
+ * Available at runtime for debugging and health checks
+ */
+export const _ZINTRUST_QUEUE_REDIS_VERSION = '0.1.15';
+export const _ZINTRUST_QUEUE_REDIS_BUILD_DATE = '__BUILD_DATE__';

package/dist/register.js

@@ -1,8 +1,6 @@
 export async function registerRedisQueueDriver(queue) {
-    const core = (await importCore());
-    if (core.RedisQueue === undefined)
-        return;
-    queue.register('redis', core.RedisQueue);
+    const mod = await import('./BullMQRedisQueue.js');
+    queue.register('redis', mod.default);
 }
 const importCore = async () => {
     try {

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@zintrust/queue-redis",
-  "version": "0.1.20",
+  "version": "0.1.27",
+  "description": "Redis queue driver for ZinTrust.",
   "private": false,
   "type": "module",
   "main": "./dist/index.js",
@@ -22,13 +23,27 @@
     "node": ">=20.0.0"
   },
   "peerDependencies": {
-    "@zintrust/core": "^0.1.20"
+    "@zintrust/core": "^0.4.21"
+  },
+  "devDependencies": {
+    "@zintrust/core": "file:../../dist"
   },
   "publishConfig": {
     "access": "public"
   },
+  "keywords": [
+    "zintrust",
+    "queue",
+    "redis",
+    "jobs",
+    "adapter"
+  ],
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "build": "tsc -p tsconfig.json && node ../../scripts/fix-dist-esm-imports.mjs dist",
     "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "ioredis": "^5.10.0",
+    "redis": "^5.11.0"
   }
 }