@zintrust/queue-redis 2.4.1 → 2.4.3

package/dist/BullMQRedisQueue.d.ts

@@ -1,5 +1,5 @@
 import type { BullMQPayload, QueueMessage } from '@zintrust/core/queue';
-import { Queue } from 'bullmq';
+import type { Queue } from 'bullmq';
 interface IQueueDriver {
     enqueue(queue: string, payload: BullMQPayload): Promise<string>;
     dequeue<T = unknown>(queue: string): Promise<QueueMessage<T> | undefined>;
@@ -8,7 +8,7 @@ interface IQueueDriver {
     drain(queue: string): Promise<void>;
 }
 interface IBullMQRedisQueue extends IQueueDriver {
-    getQueue(queueName: string): Queue;
+    getQueue(queueName: string): Promise<Queue>;
     shutdown(): Promise<void>;
     closeQueue(queueName: string): Promise<void>;
     getQueueNames(): string[];

package/dist/BullMQRedisQueue.js

@@ -6,8 +6,20 @@ import { Logger } from '@zintrust/core/logger';
 import { createLockProvider, getLockProvider, registerLockProvider, resolveDeduplicationLockKey, resolveLockPrefix, } from '@zintrust/core/queue';
 import { createRedisConnection, getBullMQSafeQueueName } from '@zintrust/core/redis';
 import { generateUuid, ZintrustLang } from '@zintrust/core/utils';
-import { Queue } from 'bullmq';
 import { RedisRpcQueueDriver, shouldUseRedisRpcQueueDriver } from './RedisRpcQueueDriver.js';
+// Lazy BullMQ loader keyed on a variable specifier so bundlers (esbuild/wrangler)
+// do not inline bullmq/ioredis into the Workers bundle. Every public method routes
+// through RedisRpcQueueDriver first when shouldUseRedisRpcQueueDriver() is true
+// (always, on Workers), so this loader never runs there.
+let QueueCtor;
+const ensureBullmqLoaded = async () => {
+    if (QueueCtor !== undefined)
+        return QueueCtor;
+    const bullmqPkg = 'bullmq';
+    const loaded = (await import(bullmqPkg)).Queue;
+    QueueCtor = loaded;
+    return loaded;
+};
 /**
  * BullMQ Redis Queue Driver
  *
@@ -178,7 +190,8 @@ export const BullMQRedisQueue = (() => {
             await closeSharedConnection(sharedConnection);
         }
     };
-    const getQueue = (queueName) => {
+    const getQueue = async (queueName) => {
+        const QueueCtor = await ensureBullmqLoaded();
         // Check if queue exists in cache
         if (queues.has(queueName)) {
             const existingQueue = queues.get(queueName);
@@ -210,7 +223,7 @@ export const BullMQRedisQueue = (() => {
         const backoffDelay = Env.getInt('BULLMQ_BACKOFF_DELAY', 2000);
         const backoffType = Env.get('BULLMQ_BACKOFF_TYPE', 'exponential');
         const prefix = getBullMQSafeQueueName();
-        const queue = new Queue(queueName, {
+        const queue = new QueueCtor(queueName, {
             connection: connection,
             prefix,
             defaultJobOptions: {
@@ -385,7 +398,7 @@ export const BullMQRedisQueue = (() => {
             }
             let requestedJobId;
             try {
-                const q = getQueue(queue);
+                const q = await getQueue(queue);
                 // Extract BullMQ options from payload with proper typing
                 const payloadData = payload;
                 const jobOptions = createJobOptions(payloadData);
@@ -422,7 +435,7 @@ export const BullMQRedisQueue = (() => {
                 return RedisRpcQueueDriver.dequeue(queue);
             }
             try {
-                const q = getQueue(queue);
+                const q = await getQueue(queue);
                 const jobs = await q.getJobs(['waiting'], 0, 1);
                 if (jobs.length === 0)
                     return undefined;
@@ -454,7 +467,7 @@ export const BullMQRedisQueue = (() => {
                 return;
             }
             try {
-                const q = getQueue(queue);
+                const q = await getQueue(queue);
                 const job = await q.getJob(id);
                 if (job) {
                     await job.moveToCompleted('acknowledged', PULL_WORKER_TOKEN, false);
@@ -473,7 +486,7 @@ export const BullMQRedisQueue = (() => {
                 return RedisRpcQueueDriver.length(queue);
             }
             try {
-                const q = getQueue(queue);
+                const q = await getQueue(queue);
                 const counts = await q.getJobCounts();
                 return counts['waiting'] || 0;
             }
@@ -488,7 +501,7 @@ export const BullMQRedisQueue = (() => {
                 return;
             }
             try {
-                const q = getQueue(queue);
+                const q = await getQueue(queue);
                 await q.drain();
                 Logger.debug(`BullMQ: Queue ${queue} drained`);
             }

package/dist/RedisPublishClient.js

@@ -83,7 +83,10 @@ export const createRedisPublishClient = async () => {
  */
 const tryCreateRedisClient = async (url) => {
     try {
-        const mod = (await import('redis'));
+        // Variable specifier so bundlers (esbuild/wrangler) do not inline node-redis
+        // into the Workers bundle — this path never runs on Workers (RPC proxy is used).
+        const redisPkg = 'redis';
+        const mod = (await import(redisPkg));
         const client = mod.createClient({ url });
         if (typeof client.connect === 'function') {
             await connectClient(client, 'Redis publish client failed to connect');
@@ -99,7 +102,9 @@ const tryCreateRedisClient = async (url) => {
  */
 const tryCreateIoRedisClient = async (url) => {
     try {
-        const mod = (await import('ioredis'));
+        // Variable specifier so bundlers do not inline ioredis into the Workers bundle.
+        const ioredisPkg = 'ioredis';
+        const mod = (await import(ioredisPkg));
         const redis = mod.default(url);
         const client = {
             publish: (channel, message) => redis.publish(channel, message),

package/dist/RedisRpcQueueDriver.js

@@ -2,7 +2,6 @@ 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() !== '';
 };
@@ -16,8 +15,8 @@ const resolveRpcBaseUrl = () => {
 };
 const createRpcClient = async () => {
     try {
-        const mod = (await import(REDIS_RPC_PACKAGE));
-        return mod.createRedisRpcClient({
+        const { createRedisRpcClient } = await import('@zintrust/redis-rpc/client');
+        return createRedisRpcClient({
             baseUrl: resolveRpcBaseUrl(),
             secret: Env.get('REDIS_RPC_SECRET', Env.get('REDIS_PROXY_SECRET', Env.APP_KEY)),
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zintrust/queue-redis",
-  "version": "2.4.1",
+  "version": "2.4.3",
   "description": "Redis queue driver for ZinTrust.",
   "private": false,
   "type": "module",
@@ -49,4 +49,4 @@
     "ioredis": "^5.11.0",
     "redis": "^5.12.1"
   }
-}
+}

package/dist/HttpQueueDriver.d.ts

@@ -1,17 +0,0 @@
-import type { BullMQPayload, QueueMessage } from '@zintrust/core/queue';
-export type QueueRpcAction = 'enqueue' | 'dequeue' | 'ack' | 'length' | 'drain';
-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 HttpQueueDriver: Readonly<{
-    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 default HttpQueueDriver;

package/dist/HttpQueueDriver.js

@@ -1,258 +0,0 @@
-import { Env } from '@zintrust/core/config';
-import { ErrorFactory } from '@zintrust/core/errors';
-import { Logger } from '@zintrust/core/logger';
-import { JobStateTracker, TimeoutManager } from '@zintrust/core/queue';
-import { SignedRequest } from '@zintrust/core/security';
-import { generateUuid } from '@zintrust/core/utils';
-const DEFAULT_PROXY_URL = 'http://127.0.0.1:7772';
-const DEFAULT_ROUTE_PATH = '/api/_sys/queue/rpc';
-const createTimeoutSignal = (timeoutMs) => {
-    if (timeoutMs <= 0)
-        return undefined;
-    const timeout = AbortSignal.timeout;
-    return typeof timeout === 'function' ? timeout(timeoutMs) : undefined;
-};
-const toBodyText = (payload) => JSON.stringify(payload);
-const normalizeBaseUrl = (value) => {
-    const raw = value.trim();
-    return raw === '' ? DEFAULT_PROXY_URL : raw;
-};
-const normalizeRoutePath = (value) => {
-    const trimmed = value.trim();
-    if (trimmed === '')
-        return DEFAULT_ROUTE_PATH;
-    if (trimmed.startsWith('/'))
-        return trimmed;
-    return `/${trimmed}`;
-};
-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 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 resolveSettings = () => {
-    const baseUrl = normalizeBaseUrl(Env.get('QUEUE_HTTP_PROXY_URL', DEFAULT_PROXY_URL));
-    const routePath = normalizeRoutePath(Env.get('QUEUE_HTTP_PROXY_PATH', DEFAULT_ROUTE_PATH));
-    const keyId = Env.get('QUEUE_HTTP_PROXY_KEY_ID', Env.APP_NAME || 'zintrust').trim();
-    const configuredSecret = Env.get('QUEUE_HTTP_PROXY_KEY', '').trim();
-    const secret = configuredSecret === '' ? Env.APP_KEY : configuredSecret;
-    const timeoutMs = Env.getInt('QUEUE_HTTP_PROXY_TIMEOUT_MS', 10000);
-    if (secret.trim() === '') {
-        throw ErrorFactory.createConfigError('QUEUE_HTTP_PROXY_KEY or APP_KEY is required');
-    }
-    return {
-        baseUrl,
-        routePath,
-        keyId,
-        secret,
-        timeoutMs,
-    };
-};
-const buildRpcUrl = (settings) => {
-    const url = new URL(settings.baseUrl);
-    const basePath = url.pathname.endsWith('/') ? url.pathname.slice(0, -1) : url.pathname;
-    const routePath = settings.routePath.startsWith('/')
-        ? settings.routePath
-        : `/${settings.routePath}`;
-    url.pathname = `${basePath}${routePath}`;
-    url.search = '';
-    return url;
-};
-const parseJsonResponse = async (response) => {
-    const text = await response.text();
-    if (text.trim() === '') {
-        return {
-            ok: false,
-            error: { code: 'EMPTY_RESPONSE', message: 'Empty response from queue gateway' },
-        };
-    }
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        return {
-            ok: false,
-            error: { code: 'INVALID_JSON', message: text },
-        };
-    }
-};
-const ensureSuccessfulResponse = (response, requestId) => {
-    if (!response.ok) {
-        const code = response.error?.code || 'QUEUE_HTTP_PROXY_ERROR';
-        const message = response.error?.message || 'Queue gateway returned an error';
-        const details = {
-            code,
-            requestId,
-            gatewayRequestId: response.requestId,
-            details: response.error?.details,
-        };
-        throw ErrorFactory.createTryCatchError(message, details);
-    }
-    return response.result;
-};
-const callGateway = async (action, payload) => {
-    const settings = resolveSettings();
-    const url = buildRpcUrl(settings);
-    const requestId = generateUuid();
-    const requestBody = {
-        action,
-        requestId,
-        payload,
-    };
-    const bodyText = toBodyText(requestBody);
-    const signingUrl = buildSigningUrl(url, settings.baseUrl);
-    const params = {
-        method: 'POST',
-        url: signingUrl,
-        body: bodyText,
-        keyId: settings.keyId,
-        secret: settings.secret,
-    };
-    const signedHeaders = await SignedRequest.createHeaders(params);
-    try {
-        const response = await fetch(url, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                ...signedHeaders,
-            },
-            body: bodyText,
-            signal: createTimeoutSignal(settings.timeoutMs),
-        });
-        const parsed = await parseJsonResponse(response);
-        if (!response.ok && parsed.ok === false) {
-            throw ErrorFactory.createConnectionError(parsed.error?.message || `Queue gateway HTTP error (${response.status})`, {
-                status: response.status,
-                requestId,
-                error: parsed.error,
-            });
-        }
-        return ensureSuccessfulResponse(parsed, requestId);
-    }
-    catch (error) {
-        if (error instanceof Error && error.name === 'AbortError') {
-            throw ErrorFactory.createConnectionError('Queue gateway request timed out', {
-                timeoutMs: settings.timeoutMs,
-                requestId,
-            });
-        }
-        throw error;
-    }
-};
-const resolveFallbackJobId = (payload) => {
-    if (typeof payload.jobId === 'string' && payload.jobId.trim().length > 0) {
-        return payload.jobId.trim();
-    }
-    return generateUuid();
-};
-const resolveCurrentAttempts = (payload) => {
-    const raw = payload['_currentAttempts'];
-    if (typeof raw !== 'number' || Number.isFinite(raw) === false)
-        return 0;
-    return Math.max(0, Math.floor(raw));
-};
-const resolveMaxAttempts = (payload) => {
-    if (typeof payload.attempts === 'number' && Number.isFinite(payload.attempts)) {
-        return Math.max(1, Math.floor(payload.attempts));
-    }
-    return undefined;
-};
-const resolveIdempotencyKey = (payload) => {
-    if (typeof payload.uniqueId !== 'string')
-        return undefined;
-    const trimmed = payload.uniqueId.trim();
-    return trimmed.length > 0 ? trimmed : undefined;
-};
-const markPendingRecoveryFallback = async (input) => {
-    const currentAttempts = resolveCurrentAttempts(input.payload);
-    const maxAttempts = resolveMaxAttempts(input.payload);
-    const idempotencyKey = resolveIdempotencyKey(input.payload);
-    // Compatibility shim: consumers of `@zintrust/core` may have a narrower
-    // `JobStateTracker.enqueued` type than the runtime implementation.
-    const enqueuedApi = JobStateTracker;
-    await enqueuedApi.enqueued({
-        queueName: input.queue,
-        jobId: input.fallbackJobId,
-        payload: input.payload,
-        attempts: currentAttempts,
-        maxAttempts,
-        idempotencyKey,
-    });
-    const pendingRecoveryApi = JobStateTracker;
-    if (typeof pendingRecoveryApi.pendingRecovery === 'function') {
-        await pendingRecoveryApi.pendingRecovery({
-            queueName: input.queue,
-            jobId: input.fallbackJobId,
-            reason: 'HTTP queue proxy enqueue failed; marked pending recovery',
-            error: input.error,
-        });
-    }
-};
-export const HttpQueueDriver = Object.freeze({
-    async enqueue(queue, payload) {
-        const fallbackJobId = resolveFallbackJobId(payload);
-        const timeoutMs = Env.getInt('QUEUE_HTTP_PROXY_TIMEOUT_MS', 10000);
-        try {
-            return await TimeoutManager.withTimeoutRetry(async () => callGateway('enqueue', { queue, payload }), {
-                timeoutMs,
-                maxRetries: Math.max(0, Env.getInt('QUEUE_HTTP_PROXY_RETRY_MAX', 2)),
-                retryDelayMs: Math.max(0, Env.getInt('QUEUE_HTTP_PROXY_RETRY_DELAY_MS', 500)),
-                operationName: `http-queue-enqueue:${queue}`,
-            });
-        }
-        catch (error) {
-            Logger.warn('HTTP queue enqueue failed; storing tracker fallback in memory', {
-                ...Logger.withTraceSkipContext({
-                    queue,
-                    fallbackJobId,
-                    error: error instanceof Error ? error.message : String(error),
-                }),
-            });
-            await markPendingRecoveryFallback({
-                queue,
-                fallbackJobId,
-                payload,
-                error,
-            });
-            Logger.warn('Job marked pending recovery in tracker', {
-                ...Logger.withTraceSkipContext({
-                    queue,
-                    jobId: fallbackJobId,
-                }),
-            });
-            return fallbackJobId;
-        }
-    },
-    async dequeue(queue) {
-        return callGateway('dequeue', { queue });
-    },
-    async ack(queue, id) {
-        await callGateway('ack', { queue, id });
-    },
-    async length(queue) {
-        return callGateway('length', { queue });
-    },
-    async drain(queue) {
-        await callGateway('drain', { queue });
-    },
-});
-export default HttpQueueDriver;

package/dist/build-manifest.json

@@ -1,89 +0,0 @@
-{
-  "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"
-    }
-  }
-}