@zintrust/queue-redis 2.1.4 → 2.4.1

package/README.md

@@ -16,9 +16,16 @@ npm i @zintrust/queue-redis
 import '@zintrust/queue-redis/register';
 ```
 
-Then set `QUEUE_DRIVER=redis` and configure `REDIS_URL`.
+Then set `QUEUE_DRIVER=redis` and configure your Redis connection.
 
-For Cloudflare Workers, set `ENABLE_CLOUDFLARE_SOCKETS=true` and use a TCP-accessible Redis endpoint.
+For Cloudflare Workers or any runtime without Redis TCP access, run Redis RPC from a Node.js backend and configure the Worker with both flags:
+
+```bash
+USE_REDIS_PROXY=true
+REDIS_RPC_URL=https://queues.example.com
+```
+
+Start the backend with `zin redis-rpc` or `zin s redis-rpc`. See [`@zintrust/redis-rpc`](https://www.npmjs.com/package/@zintrust/redis-rpc).
 
 ## When to use
 

package/dist/BullMQRedisQueue.d.ts

@@ -13,8 +13,6 @@ interface IBullMQRedisQueue extends IQueueDriver {
     closeQueue(queueName: string): Promise<void>;
     getQueueNames(): string[];
 }
-export declare const shouldUseHttpProxyDriver: () => boolean;
-export declare const runWithDirectQueueDriver: <T>(fn: () => Promise<T>) => Promise<T>;
 /**
  * BullMQ Redis Queue Driver
  *

package/dist/BullMQRedisQueue.js

@@ -7,24 +7,7 @@ import { createLockProvider, getLockProvider, registerLockProvider, resolveDedup
 import { createRedisConnection, getBullMQSafeQueueName } from '@zintrust/core/redis';
 import { generateUuid, ZintrustLang } from '@zintrust/core/utils';
 import { Queue } from 'bullmq';
-import { HttpQueueDriver } from './HttpQueueDriver.js';
-export const shouldUseHttpProxyDriver = () => {
-    if (directModeDepth > 0)
-        return false;
-    const isCloudFlareWorkers = Cloudflare.getWorkersEnv() !== null;
-    const isProxy = isCloudFlareWorkers || Env.getBool('QUEUE_HTTP_PROXY_ENABLED', false);
-    return isProxy;
-};
-let directModeDepth = 0;
-export const runWithDirectQueueDriver = async (fn) => {
-    directModeDepth += 1;
-    try {
-        return await fn();
-    }
-    finally {
-        directModeDepth = Math.max(0, directModeDepth - 1);
-    }
-};
+import { RedisRpcQueueDriver, shouldUseRedisRpcQueueDriver } from './RedisRpcQueueDriver.js';
 /**
  * BullMQ Redis Queue Driver
  *
@@ -37,17 +20,6 @@ export const BullMQRedisQueue = (() => {
     let lockProviderCache = null;
     const PULL_WORKER_TOKEN = 'pull-worker';
     const SHARED_CONNECTION_SHUTDOWN_TIMEOUT_MS = 100;
-    const isRedisProxyEnabled = () => {
-        return Env.USE_REDIS_PROXY === true || Env.get('REDIS_PROXY_URL', '').trim() !== '';
-    };
-    const assertProxyAndWorkersCompatibility = (isWorkersRuntime) => {
-        if (isRedisProxyEnabled() && shouldUseHttpProxyDriver() === false) {
-            throw ErrorFactory.createConfigError('BullMQ Redis driver does not support REDIS proxy transport directly. Enable QUEUE_HTTP_PROXY_ENABLED=true for queue proxy mode, or disable REDIS proxy mode for direct BullMQ access.');
-        }
-        if (isWorkersRuntime && Cloudflare.isCloudflareSocketsEnabled() === false) {
-            throw ErrorFactory.createConfigError('BullMQ Redis driver requires ENABLE_CLOUDFLARE_SOCKETS=true in Cloudflare Workers. To use HTTP queue proxy mode, set QUEUE_HTTP_PROXY_ENABLED=true and QUEUE_HTTP_PROXY_URL.');
-        }
-    };
     const resolveQueueRedisConfig = () => {
         let workersHost = Cloudflare.getWorkersVar('WORKERS_REDIS_HOST');
         let workersPortRaw = Cloudflare.getWorkersVar('WORKERS_REDIS_PORT');
@@ -75,12 +47,11 @@ export const BullMQRedisQueue = (() => {
     const assertWorkersHostIsReachable = (isWorkersRuntime, redisConfig) => {
         if (isWorkersRuntime &&
             (redisConfig.host === 'localhost' || redisConfig.host === '127.0.0.1')) {
-            throw ErrorFactory.createConfigError('Redis host cannot be localhost in Cloudflare Workers. Use a public Redis host, or enable queue HTTP proxy mode with QUEUE_HTTP_PROXY_ENABLED=true and QUEUE_HTTP_PROXY_URL.');
+            throw ErrorFactory.createConfigError('Redis host cannot be localhost in Cloudflare Workers. Use a public Redis host.');
         }
     };
     const createSharedBullMqConnection = () => {
         const isWorkersRuntime = Cloudflare.getWorkersEnv() !== null;
-        assertProxyAndWorkersCompatibility(isWorkersRuntime);
         const redisConfig = resolveQueueRedisConfig();
         assertWorkersHostIsReachable(isWorkersRuntime, redisConfig);
         return createRedisConnection({
@@ -208,9 +179,6 @@ export const BullMQRedisQueue = (() => {
         }
     };
     const getQueue = (queueName) => {
-        if (shouldUseHttpProxyDriver()) {
-            throw ErrorFactory.createConfigError('BullMQ queue instance is not available when QUEUE_HTTP_PROXY mode is active.');
-        }
         // Check if queue exists in cache
         if (queues.has(queueName)) {
             const existingQueue = queues.get(queueName);
@@ -412,8 +380,8 @@ export const BullMQRedisQueue = (() => {
         closeQueue,
         getQueueNames,
         async enqueue(queue, payload) {
-            if (shouldUseHttpProxyDriver()) {
-                return HttpQueueDriver.enqueue(queue, payload);
+            if (shouldUseRedisRpcQueueDriver()) {
+                return RedisRpcQueueDriver.enqueue(queue, payload);
             }
             let requestedJobId;
             try {
@@ -450,8 +418,8 @@ export const BullMQRedisQueue = (() => {
             }
         },
         async dequeue(queue) {
-            if (shouldUseHttpProxyDriver()) {
-                return HttpQueueDriver.dequeue(queue);
+            if (shouldUseRedisRpcQueueDriver()) {
+                return RedisRpcQueueDriver.dequeue(queue);
             }
             try {
                 const q = getQueue(queue);
@@ -481,8 +449,8 @@ export const BullMQRedisQueue = (() => {
             }
         },
         async ack(queue, id) {
-            if (shouldUseHttpProxyDriver()) {
-                await HttpQueueDriver.ack(queue, id);
+            if (shouldUseRedisRpcQueueDriver()) {
+                await RedisRpcQueueDriver.ack(queue, id);
                 return;
             }
             try {
@@ -501,8 +469,8 @@ export const BullMQRedisQueue = (() => {
             }
         },
         async length(queue) {
-            if (shouldUseHttpProxyDriver()) {
-                return HttpQueueDriver.length(queue);
+            if (shouldUseRedisRpcQueueDriver()) {
+                return RedisRpcQueueDriver.length(queue);
             }
             try {
                 const q = getQueue(queue);
@@ -515,8 +483,8 @@ export const BullMQRedisQueue = (() => {
             }
         },
         async drain(queue) {
-            if (shouldUseHttpProxyDriver()) {
-                await HttpQueueDriver.drain(queue);
+            if (shouldUseRedisRpcQueueDriver()) {
+                await RedisRpcQueueDriver.drain(queue);
                 return;
             }
             try {

package/dist/QueueHttpGateway.d.ts

@@ -1,4 +1,4 @@
-import type { IRouter } from '@zintrust/core/http';
+import { type IRouter } from '@zintrust/core/http';
 type QueueGatewaySettings = {
     basePath: string;
     keyId: string;

package/dist/QueueHttpGateway.js

@@ -3,7 +3,7 @@ import { ErrorFactory } from '@zintrust/core/errors';
 import { Router } from '@zintrust/core/http';
 import { Logger } from '@zintrust/core/logger';
 import { SignedRequest } from '@zintrust/core/security';
-import BullMQRedisQueue, { runWithDirectQueueDriver } from './BullMQRedisQueue.js';
+import BullMQRedisQueue from './BullMQRedisQueue.js';
 const nonces = new Map();
 const nowMs = () => Date.now();
 const normalizePath = (value) => {
@@ -31,9 +31,8 @@ const readSettings = () => {
 const cleanupExpiredNonces = () => {
     const current = nowMs();
     for (const [nonceKey, expiresAt] of nonces.entries()) {
-        if (expiresAt <= current) {
+        if (expiresAt <= current)
             nonces.delete(nonceKey);
-        }
     }
 };
 const storeNonce = async (keyId, nonce, ttlMs) => {
@@ -52,18 +51,14 @@ const getBodyRecord = (req) => {
     return {};
 };
 const getRawBody = (req) => {
-    const rawText = req.context['rawBodyText'];
+    const rawText = req.context?.['rawBodyText'];
     if (typeof rawText === 'string')
         return rawText;
     return JSON.stringify(getBodyRecord(req));
 };
 const toIncomingHeaders = (req) => {
     const headers = req.getHeaders();
-    const normalize = (value) => {
-        if (Array.isArray(value))
-            return value.join(',');
-        return value;
-    };
+    const normalize = (value) => Array.isArray(value) ? value.join(',') : value;
     return {
         'x-zt-key-id': normalize(headers['x-zt-key-id']),
         'x-zt-timestamp': normalize(headers['x-zt-timestamp']),
@@ -73,63 +68,51 @@ const toIncomingHeaders = (req) => {
     };
 };
 const sendFailure = (res, requestId, status, code, message, details) => {
-    const payload = {
+    res.status(status).json({
         ok: false,
         requestId,
         result: null,
         error: { code, message, details },
-    };
-    res.status(status).json(payload);
+    });
 };
 const sendSuccess = (res, requestId, result) => {
-    const payload = {
-        ok: true,
-        requestId,
-        result,
-        error: null,
-    };
-    res.status(200).json(payload);
+    res.status(200).json({ ok: true, requestId, result, error: null });
 };
 const readQueueName = (payload) => {
-    const value = payload.queue;
-    if (typeof value !== 'string')
-        return null;
-    const normalized = value.trim();
-    return normalized === '' ? null : normalized;
+    const value = payload['queue'];
+    if (typeof value !== 'string' || value.trim() === '') {
+        throw ErrorFactory.createValidationError('payload.queue is required');
+    }
+    return value.trim();
 };
 const executeAction = async (request) => {
-    return runWithDirectQueueDriver(async () => {
-        const queueName = readQueueName(request.payload);
-        if (!queueName) {
-            throw ErrorFactory.createValidationError('payload.queue is required');
-        }
-        switch (request.action) {
-            case 'enqueue': {
-                const payload = request.payload.payload;
-                if (!payload || typeof payload !== 'object') {
-                    throw ErrorFactory.createValidationError('payload.payload is required for enqueue');
-                }
-                return BullMQRedisQueue.enqueue(queueName, payload);
+    const queueName = readQueueName(request.payload);
+    switch (request.action) {
+        case 'enqueue': {
+            const payload = request.payload['payload'];
+            if (!payload || typeof payload !== 'object') {
+                throw ErrorFactory.createValidationError('payload.payload is required for enqueue');
             }
-            case 'dequeue':
-                return BullMQRedisQueue.dequeue(queueName);
-            case 'ack': {
-                const id = request.payload.id;
-                if (typeof id !== 'string' || id.trim() === '') {
-                    throw ErrorFactory.createValidationError('payload.id is required for ack');
-                }
-                await BullMQRedisQueue.ack(queueName, id);
-                return null;
+            return BullMQRedisQueue.enqueue(queueName, payload);
+        }
+        case 'dequeue':
+            return BullMQRedisQueue.dequeue(queueName);
+        case 'ack': {
+            const id = request.payload['id'];
+            if (typeof id !== 'string' || id.trim() === '') {
+                throw ErrorFactory.createValidationError('payload.id is required for ack');
             }
-            case 'length':
-                return BullMQRedisQueue.length(queueName);
-            case 'drain':
-                await BullMQRedisQueue.drain(queueName);
-                return null;
-            default:
-                throw ErrorFactory.createValidationError(`Unsupported action: ${String(request.action)}`);
+            await BullMQRedisQueue.ack(queueName, id);
+            return null;
         }
-    });
+        case 'length':
+            return BullMQRedisQueue.length(queueName);
+        case 'drain':
+            await BullMQRedisQueue.drain(queueName);
+            return null;
+        default:
+            throw ErrorFactory.createValidationError(`Unsupported action: ${String(request.action)}`);
+    }
 };
 const verifyRequest = async (req, bodyText, settings) => {
     if (settings.keyId.trim() === '' || settings.secret.trim() === '') {
@@ -140,30 +123,25 @@ const verifyRequest = async (req, bodyText, settings) => {
             message: 'Queue HTTP gateway signing credentials are not configured',
         };
     }
-    const url = new URL(req.getPath(), 'http://localhost');
     const verifyResult = await SignedRequest.verify({
         method: req.getMethod(),
-        url,
+        url: new URL(req.getPath(), 'http://localhost'),
         body: bodyText,
         headers: toIncomingHeaders(req),
         nowMs: nowMs(),
         windowMs: settings.signingWindowMs,
         verifyNonce: async (keyId, nonce) => storeNonce(keyId, nonce, settings.nonceTtlMs),
-        getSecretForKeyId: async (keyId) => {
-            if (keyId === settings.keyId)
-                return settings.secret;
-            return undefined;
-        },
+        getSecretForKeyId: async (keyId) => (keyId === settings.keyId ? settings.secret : undefined),
     });
     if (verifyResult.ok === true)
         return { ok: true };
-    const errorCode = 'code' in verifyResult ? verifyResult.code : 'INVALID_SIGNATURE';
-    const errorMessage = 'message' in verifyResult ? verifyResult.message : 'Invalid signature';
+    const code = 'code' in verifyResult ? verifyResult.code : 'INVALID_SIGNATURE';
+    const message = 'message' in verifyResult ? verifyResult.message : 'Invalid signature';
     return {
         ok: false,
-        code: errorCode,
-        status: errorCode === 'EXPIRED' || errorCode === 'REPLAYED' ? 401 : 403,
-        message: errorMessage,
+        code,
+        status: code === 'EXPIRED' || code === 'REPLAYED' ? 401 : 403,
+        message,
     };
 };
 const createHandler = (settings) => {
@@ -178,37 +156,37 @@ const createHandler = (settings) => {
             sendFailure(res, requestId, auth.status, auth.code, auth.message);
             return;
         }
-        const action = body['action'];
-        const payload = body['payload'];
-        if (typeof action !== 'string') {
+        if (typeof body['action'] !== 'string') {
             sendFailure(res, requestId, 400, 'VALIDATION_ERROR', 'action is required');
             return;
         }
-        if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+        if (!body['payload'] || typeof body['payload'] !== 'object' || Array.isArray(body['payload'])) {
             sendFailure(res, requestId, 400, 'VALIDATION_ERROR', 'payload must be an object');
             return;
         }
-        const normalizedRequest = {
-            action: action,
-            requestId,
-            payload: payload,
-        };
         try {
-            const result = await executeAction(normalizedRequest);
+            const result = await executeAction({
+                action: body['action'],
+                requestId,
+                payload: body['payload'],
+            });
             sendSuccess(res, requestId, result);
         }
         catch (error) {
             Logger.error('Queue HTTP gateway action failed', error);
-            sendFailure(res, requestId, 500, 'QUEUE_ERROR', 'Queue operation failed', error instanceof Error ? { message: error.message } : error);
+            sendFailure(res, requestId, 500, 'QUEUE_ERROR', 'Queue operation failed', {
+                message: error instanceof Error ? error.message : String(error),
+            });
         }
     };
 };
 export const QueueHttpGateway = Object.freeze({
     create(config) {
+        const defaults = readSettings();
         const settings = {
-            ...readSettings(),
+            ...defaults,
             ...config,
-            basePath: normalizePath(config?.basePath ?? readSettings().basePath),
+            basePath: normalizePath(config?.basePath ?? defaults.basePath),
         };
         const routeOptions = settings.middleware.length > 0 ? { middleware: settings.middleware } : undefined;
         return {

package/dist/RedisRpcQueueDriver.d.ts

@@ -0,0 +1,11 @@
+import type { BullMQPayload, QueueMessage } from '@zintrust/core/queue';
+export interface IQueueDriver {
+    enqueue(queue: string, payload: BullMQPayload): 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 shouldUseRedisRpcQueueDriver: () => boolean;
+export declare const RedisRpcQueueDriver: IQueueDriver;
+export default RedisRpcQueueDriver;

package/dist/RedisRpcQueueDriver.js

@@ -0,0 +1,131 @@
+import { Env } from '@zintrust/core/config';
+import { ErrorFactory } from '@zintrust/core/errors';
+import { JobStateTracker, TimeoutManager } from '@zintrust/core/queue';
+import { generateUuid } from '@zintrust/core/utils';
+const REDIS_RPC_PACKAGE = '@zintrust/redis-rpc';
+export const shouldUseRedisRpcQueueDriver = () => {
+    return Env.USE_REDIS_PROXY === true && Env.get('REDIS_RPC_URL', '').trim() !== '';
+};
+const resolveRpcBaseUrl = () => {
+    const configured = Env.get('REDIS_RPC_URL', '').trim();
+    if (configured.length > 0)
+        return configured;
+    const host = Env.get('REDIS_RPC_HOST', '127.0.0.1').trim() || '127.0.0.1';
+    const port = Env.getInt('REDIS_RPC_PORT', 8794);
+    return `http://${host}:${port}`;
+};
+const createRpcClient = async () => {
+    try {
+        const mod = (await import(REDIS_RPC_PACKAGE));
+        return mod.createRedisRpcClient({
+            baseUrl: resolveRpcBaseUrl(),
+            secret: Env.get('REDIS_RPC_SECRET', Env.get('REDIS_PROXY_SECRET', Env.APP_KEY)),
+        });
+    }
+    catch (error) {
+        throw ErrorFactory.createConfigError('@zintrust/redis-rpc is required when USE_REDIS_PROXY=true and REDIS_RPC_URL is configured', error);
+    }
+};
+const resolveRequestedJobId = (payloadData) => {
+    if (typeof payloadData?.jobId === 'string' && payloadData.jobId.trim().length > 0) {
+        return payloadData.jobId.trim();
+    }
+    return generateUuid();
+};
+const createJobOptions = (payloadData) => ({
+    jobId: resolveRequestedJobId(payloadData),
+    delay: payloadData.delay,
+    attempts: payloadData.attempts,
+    priority: payloadData.priority,
+    removeOnComplete: payloadData.removeOnComplete || 100,
+    removeOnFail: payloadData.removeOnFail || 50,
+    backoff: payloadData.backoff || {
+        type: 'exponential',
+        delay: 2000,
+    },
+    repeat: payloadData.repeat,
+    lifo: payloadData.lifo ?? false,
+});
+const resolveJobId = (result, fallback) => {
+    if (typeof result === 'object' && result !== null) {
+        const id = result.id;
+        if (typeof id === 'string' && id.trim().length > 0)
+            return id;
+        if (typeof id === 'number' && Number.isFinite(id))
+            return String(id);
+    }
+    return fallback;
+};
+const markPendingRecoveryFallback = async (input) => {
+    const payload = input.payload;
+    const currentAttempts = typeof payload['_currentAttempts'] === 'number' && Number.isFinite(payload['_currentAttempts'])
+        ? Math.max(0, Math.floor(payload['_currentAttempts']))
+        : 0;
+    const maxAttempts = typeof payload['attempts'] === 'number' && Number.isFinite(payload['attempts'])
+        ? Math.max(1, Math.floor(payload['attempts']))
+        : undefined;
+    const idempotencyKey = typeof payload['uniqueId'] === 'string' && payload['uniqueId'].trim().length > 0
+        ? payload['uniqueId'].trim()
+        : undefined;
+    await JobStateTracker.enqueued({
+        queueName: input.queue,
+        jobId: input.fallbackJobId,
+        payload: input.payload,
+        attempts: currentAttempts,
+        maxAttempts,
+        idempotencyKey,
+    });
+    const pendingRecoveryApi = JobStateTracker;
+    await pendingRecoveryApi.pendingRecovery?.({
+        queueName: input.queue,
+        jobId: input.fallbackJobId,
+        reason: 'Redis RPC enqueue failed; marked pending recovery',
+        error: input.error,
+    });
+};
+export const RedisRpcQueueDriver = Object.freeze({
+    async enqueue(queue, payload) {
+        const fallbackJobId = resolveRequestedJobId(payload);
+        const timeoutMs = Env.getInt('REDIS_RPC_TIMEOUT_MS', Env.getInt('QUEUE_HTTP_PROXY_TIMEOUT_MS', 10000));
+        const options = createJobOptions({ ...payload, jobId: fallbackJobId });
+        try {
+            return await TimeoutManager.withTimeoutRetry(async () => {
+                const client = await createRpcClient();
+                const result = await client.queue('add', {
+                    target: queue,
+                    args: [`${queue}-job`, payload, options],
+                });
+                return resolveJobId(result, fallbackJobId);
+            }, {
+                timeoutMs,
+                maxRetries: Math.max(0, Env.getInt('REDIS_RPC_RETRY_MAX', Env.getInt('QUEUE_HTTP_PROXY_RETRY_MAX', 2))),
+                retryDelayMs: Math.max(0, Env.getInt('REDIS_RPC_RETRY_DELAY_MS', Env.getInt('QUEUE_HTTP_PROXY_RETRY_DELAY_MS', 500))),
+                operationName: `redis-rpc-queue-enqueue:${queue}`,
+            });
+        }
+        catch (error) {
+            await markPendingRecoveryFallback({ queue, fallbackJobId, payload, error });
+            return fallbackJobId;
+        }
+    },
+    async dequeue(queue) {
+        const client = await createRpcClient();
+        return client.queue('dequeue', {
+            target: queue,
+            visibilityTimeoutMs: Env.getInt('QUEUE_REDIS_VISIBILITY_TIMEOUT_MS', 30_000),
+        });
+    },
+    async ack(queue, id) {
+        const client = await createRpcClient();
+        await client.queue('ack', { target: queue, args: [id] });
+    },
+    async length(queue) {
+        const client = await createRpcClient();
+        return client.queue('length', { target: queue });
+    },
+    async drain(queue) {
+        const client = await createRpcClient();
+        await client.queue('drain', { target: queue });
+    },
+});
+export default RedisRpcQueueDriver;

package/dist/build-manifest.json

@@ -0,0 +1,89 @@
+{
+  "name": "@zintrust/queue-redis",
+  "version": "2.4.1",
+  "buildDate": "2026-05-31T11:38:17.470Z",
+  "buildEnvironment": {
+    "node": "v22.22.1",
+    "platform": "darwin",
+    "arch": "arm64"
+  },
+  "git": {
+    "commit": "e97b7b3d",
+    "branch": "release"
+  },
+  "package": {
+    "engines": {
+      "node": ">=20.0.0"
+    },
+    "dependencies": [
+      "ioredis",
+      "redis"
+    ],
+    "peerDependencies": [
+      "@zintrust/core",
+      "@zintrust/redis-rpc"
+    ]
+  },
+  "files": {
+    "BullMQRedisQueue.d.ts": {
+      "size": 918,
+      "sha256": "fdcd271e7aa241cc3af89c979a4ee2538541d1442024bd6dda91c8b12f712c6f"
+    },
+    "BullMQRedisQueue.js": {
+      "size": 21906,
+      "sha256": "87fd1eb1a320ea85b4cffde44e6f86ec487332cf8cd7052b11fd1b89caf8a1e5"
+    },
+    "HttpQueueDriver.d.ts": {
+      "size": 841,
+      "sha256": "5ef4a0a87a0df070df1fd56c499996eeb6c280af7b018c3e0ee84de67fb401cb"
+    },
+    "HttpQueueDriver.js": {
+      "size": 9322,
+      "sha256": "228ef02377b6f72f1e1eea0c2ac463828d55cc97b4ec6bbb235e31e5c35cada1"
+    },
+    "QueueHttpGateway.d.ts": {
+      "size": 437,
+      "sha256": "9c45a8643136415b248828322442aac16cd4b2e0d22355c3b8ecf6188973ffe7"
+    },
+    "QueueHttpGateway.js": {
+      "size": 7665,
+      "sha256": "352a1c2de6bbbaf7cd684bb428454bdd3293aff070956b3ee912403fe1394992"
+    },
+    "RedisPublishClient.d.ts": {
+      "size": 451,
+      "sha256": "341a68a3b8603b453146dc721f9d2eaf0d65bb6a1acb67908a9c6f9542b9fd2d"
+    },
+    "RedisPublishClient.js": {
+      "size": 5589,
+      "sha256": "aed9cee5023addfdbbf1026d0a45c86d29a8f3e65ffbd01637c1e0e7f994213b"
+    },
+    "RedisRpcQueueDriver.d.ts": {
+      "size": 549,
+      "sha256": "19dc10ffc29e813a241a9c69184e988d94d1c16ffc82010c75cadc29a4833a93"
+    },
+    "RedisRpcQueueDriver.js": {
+      "size": 5357,
+      "sha256": "24bb11e1a9f8a163ec79b08dc326e0c337297f312d393347dad91d38b692a9ea"
+    },
+    "build-manifest.json": {
+      "size": 2273,
+      "sha256": "774ebf83d6b9fc3222555c6ace7c7318e4cdeba9e4f439bce38cfc99cef9cf66"
+    },
+    "index.d.ts": {
+      "size": 609,
+      "sha256": "c74e26117ad588f7d28dda0c71fdd17588e6f58a0c68ede56af2fb2795352726"
+    },
+    "index.js": {
+      "size": 714,
+      "sha256": "ea00335dbb0386bc3863d61def64aebcc330f8dcef348a663bae51055d1bcc20"
+    },
+    "register.d.ts": {
+      "size": 170,
+      "sha256": "e10ca97976730171bfaaaa25f484a30d06c6dca57c7cd85d700c202e0785a0b7"
+    },
+    "register.js": {
+      "size": 593,
+      "sha256": "9a4ca56fc5d0ae9ca9c5d6c89731b3331749d3e254e583992f311e3ec7add80b"
+    }
+  }
+}

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export { BullMQRedisQueue } from './BullMQRedisQueue';
-export { HttpQueueDriver } from './HttpQueueDriver';
 export { QueueHttpGateway } from './QueueHttpGateway';
+export { RedisRpcQueueDriver, shouldUseRedisRpcQueueDriver } from './RedisRpcQueueDriver';
 export { createRedisPublishClient, resetPublishClient, type RedisPublishClient, } from './RedisPublishClient';
 export type { QueueMessage } from '@zintrust/core/queue';
 /**

package/dist/index.js

@@ -1,6 +1,6 @@
 export { BullMQRedisQueue } from './BullMQRedisQueue.js';
-export { HttpQueueDriver } from './HttpQueueDriver.js';
 export { QueueHttpGateway } from './QueueHttpGateway.js';
+export { RedisRpcQueueDriver, shouldUseRedisRpcQueueDriver } from './RedisRpcQueueDriver.js';
 export { createRedisPublishClient, resetPublishClient, } from './RedisPublishClient.js';
 /**
  * Package version and build metadata

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zintrust/queue-redis",
-  "version": "2.1.4",
+  "version": "2.4.1",
   "description": "Redis queue driver for ZinTrust.",
   "private": false,
   "type": "module",
@@ -23,7 +23,13 @@
     "node": ">=20.0.0"
   },
   "peerDependencies": {
-    "@zintrust/core": "*"
+    "@zintrust/core": "*",
+    "@zintrust/redis-rpc": "*"
+  },
+  "peerDependenciesMeta": {
+    "@zintrust/redis-rpc": {
+      "optional": true
+    }
   },
   "publishConfig": {
     "access": "public"
@@ -40,7 +46,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "ioredis": "^5.10.1",
+    "ioredis": "^5.11.0",
     "redis": "^5.12.1"
   }
-}
+}