bullmq 6.3.1 → 6.3.3

package/dist/cjs/classes/bun-redis-client.js

@@ -49,15 +49,21 @@ function createBunRedisClient(client, opts) {
  */
 class BunRedisAdapter extends events_1.EventEmitter {
     get status() {
+        var _a;
         if (this.statusOverride) {
             return this.statusOverride;
         }
         if (this.closed) {
             return 'end';
         }
-        if (this.raw.connected) {
+        // `raw` may not exist yet on a duplicate whose raw client is created
+        // lazily (via `rawFactory`) on first connect.
+        if (this.ready) {
             return 'ready';
         }
+        if ((_a = this.raw) === null || _a === void 0 ? void 0 : _a.connected) {
+            return 'connect';
+        }
         return this.hasConnected ? 'end' : 'wait';
     }
     set status(val) {
@@ -90,8 +96,14 @@ class BunRedisAdapter extends events_1.EventEmitter {
         this.reconnectTimer = null;
         this.reconnectAttempts = 0;
         this.maxReconnectDelay = 20000; // cap at 20s (matches ioredis default)
+        this.ready = false;
         this.isCluster = false;
-        this._setupCallbacks();
+        this.rawFactory = opts === null || opts === void 0 ? void 0 : opts.rawFactory;
+        // When a `rawFactory` is provided the raw client is created lazily on the
+        // first `connect()`; callbacks are wired up there once it exists.
+        if (this.raw) {
+            this._setupCallbacks();
+        }
         // ioredis auto-connects by default. Mimic that behavior unless
         // lazyConnect is set.
         if (!(opts === null || opts === void 0 ? void 0 : opts.lazyConnect)) {
@@ -109,23 +121,10 @@ class BunRedisAdapter extends events_1.EventEmitter {
         // event until CLIENT SETNAME completes so callers waiting for 'ready'
         // see the name already applied.
         this.raw.onconnect = () => {
-            this.hasConnected = true;
-            this.closed = false;
-            this.closing = false;
-            this.reconnecting = false;
-            this.reconnectAttempts = 0;
-            this.statusOverride = undefined;
-            // The server-side SCRIPT cache is gone for this (possibly new) raw
-            // connection. Force re-loading on next use.
-            this.loadedScriptShas.clear();
-            if (this.connectionName) {
-                this.clientSetName(this.connectionName).then(() => this.emit('ready'), () => this.emit('ready'));
-            }
-            else {
-                this.emit('ready');
-            }
+            this._handleConnected();
         };
         this.raw.onclose = (error) => {
+            this.ready = false;
             if (this.closing) {
                 // User-initiated close – no reconnect
                 this.closed = true;
@@ -142,6 +141,31 @@ class BunRedisAdapter extends events_1.EventEmitter {
             this._scheduleReconnect();
         };
     }
+    _handleConnected() {
+        this.hasConnected = true;
+        this.ready = false;
+        this.closed = false;
+        this.closing = false;
+        this.reconnecting = false;
+        this.reconnectAttempts = 0;
+        this.statusOverride = undefined;
+        // The server-side SCRIPT cache is gone for this (possibly new) raw
+        // connection. Force re-loading on next use.
+        this.loadedScriptShas.clear();
+        const markReady = () => {
+            this.ready = true;
+            this.emit('ready');
+        };
+        const readying = this.connectionName
+            ? this.clientSetName(this.connectionName).then(markReady, markReady)
+            : (markReady(), Promise.resolve());
+        this.readying = readying.finally(() => {
+            if (this.readying === readying) {
+                this.readying = undefined;
+            }
+        });
+        return this.readying;
+    }
     /**
      * Schedule a reconnection attempt with exponential backoff.
      */
@@ -160,10 +184,16 @@ class BunRedisAdapter extends events_1.EventEmitter {
                 return;
             }
             try {
-                // Create a fresh raw client with the same URL
-                const BunRedisClient = this.raw
-                    .constructor;
-                const newRaw = new BunRedisClient(this.raw.url);
+                // Create a fresh raw client aimed at the *same* server. Bun's native
+                // `duplicate()` preserves the connection target and options; the old
+                // `new BunRedisClient(this.raw.url)` produced a client pointed at Bun's
+                // default target because `url` is always undefined (#4582). If the raw
+                // client was never created (a duplicate reconnecting before its first
+                // connect), fall back to its lazy factory.
+                const newRaw = this.raw
+                    ? await this._duplicateRaw(this.raw)
+                    : await this.rawFactory();
+                this.rawFactory = undefined;
                 // Swap the raw client reference
                 this.raw = newRaw;
                 this.closed = false;
@@ -186,6 +216,14 @@ class BunRedisAdapter extends events_1.EventEmitter {
     // Connection lifecycle
     // ---------------------------------------------------------------
     async connect() {
+        var _a, _b;
+        // A duplicate created with a `rawFactory` builds its raw client lazily on
+        // the first connect (Bun's native `duplicate()` is async).
+        if (!this.raw && this.rawFactory) {
+            this.raw = await this.rawFactory();
+            this.rawFactory = undefined;
+            this._setupCallbacks();
+        }
         const replaceRaw = this.hasConnected && (this.closed || !this.raw.connected);
         if (this.reconnectTimer) {
             clearTimeout(this.reconnectTimer);
@@ -197,6 +235,9 @@ class BunRedisAdapter extends events_1.EventEmitter {
             this.closed = false;
             this.closing = false;
             this.statusOverride = undefined;
+            if (!this.ready) {
+                await ((_a = this.readying) !== null && _a !== void 0 ? _a : this._handleConnected());
+            }
             return;
         }
         if (!this.connecting) {
@@ -204,11 +245,10 @@ class BunRedisAdapter extends events_1.EventEmitter {
             this.closing = false;
             this.statusOverride = undefined;
             // If the raw client was previously closed, Bun doesn't support
-            // reconnecting on the same instance. Create a fresh raw client.
+            // reconnecting on the same instance. Create a fresh raw client aimed at
+            // the same server via Bun's native `duplicate()` (see #4582).
             if (replaceRaw) {
-                const BunRedisClient = this.raw
-                    .constructor;
-                this.raw = new BunRedisClient(this.raw.url);
+                this.raw = await this._duplicateRaw(this.raw);
                 this._setupCallbacks();
             }
             this.connecting = this.raw
@@ -224,6 +264,31 @@ class BunRedisAdapter extends events_1.EventEmitter {
             });
         }
         await this.connecting;
+        await this.readying;
+        // Bun may report the socket as connected before this adapter transitions
+        // to ready (for example while applying CLIENT SETNAME on duplicates).
+        // Keep connect() aligned with ioredis semantics by waiting until the
+        // adapter is either ready or closed.
+        if (!this.ready && !this.closed && !this.closing && ((_b = this.raw) === null || _b === void 0 ? void 0 : _b.connected)) {
+            await new Promise(resolve => {
+                var _a;
+                const cleanup = () => {
+                    this.off('ready', onDone);
+                    this.off('close', onDone);
+                    this.off('end', onDone);
+                };
+                const onDone = () => {
+                    cleanup();
+                    resolve();
+                };
+                this.on('ready', onDone);
+                this.on('close', onDone);
+                this.on('end', onDone);
+                if (this.ready || this.closed || this.closing || !((_a = this.raw) === null || _a === void 0 ? void 0 : _a.connected)) {
+                    onDone();
+                }
+            });
+        }
     }
     _closeRaw() {
         // Cancel any pending reconnect
@@ -232,7 +297,12 @@ class BunRedisAdapter extends events_1.EventEmitter {
             this.reconnectTimer = null;
         }
         this.reconnecting = false;
+        // A duplicate closed before it ever connected has no raw client yet.
+        this.rawFactory = undefined;
         const raw = this.raw;
+        if (!raw) {
+            return;
+        }
         raw.onconnect = () => { };
         raw.onclose = () => { };
         raw.onerror = () => { };
@@ -262,18 +332,20 @@ class BunRedisAdapter extends events_1.EventEmitter {
             this.closed = true;
             this.statusOverride = undefined;
             const raw = this.raw;
-            raw.onclose = () => { };
-            if (raw.connected) {
-                setImmediate(() => {
-                    try {
-                        if (raw.connected) {
-                            raw.close();
+            if (raw) {
+                raw.onclose = () => { };
+                if (raw.connected) {
+                    setImmediate(() => {
+                        try {
+                            if (raw.connected) {
+                                raw.close();
+                            }
                         }
-                    }
-                    catch (_err) {
-                        // swallow
-                    }
-                });
+                        catch (_err) {
+                            // swallow
+                        }
+                    });
+                }
             }
             this.emit('close');
             this._scheduleReconnect();
@@ -306,15 +378,45 @@ class BunRedisAdapter extends events_1.EventEmitter {
         });
         return 'OK';
     }
+    /**
+     * Create a fresh raw client aimed at the *same* Redis server as `src`.
+     *
+     * Bun's `RedisClient` exposes no public connection info (no `url`, host,
+     * port or options), so the target cannot be reconstructed from the instance.
+     * Its native `duplicate()` is the only reliable way to clone the target and
+     * options; we fall back to URL-based reconstruction for exotic raw clients
+     * that don't implement it. See #4582.
+     */
+    async _duplicateRaw(src) {
+        if (typeof src.duplicate === 'function') {
+            return await src.duplicate();
+        }
+        const Ctor = src.constructor;
+        return new Ctor(src.url);
+    }
+    /**
+     * Return the raw client, materializing it first when this adapter is a
+     * lazily-initialized duplicate (created via `duplicate()` with a
+     * `rawFactory`). Command paths that touch `this.raw` directly use this so a
+     * duplicate can be used immediately without an explicit `connect()`.
+     */
+    async _ensureRaw() {
+        if (!this.raw) {
+            await this.connect();
+        }
+        return this.raw;
+    }
     duplicate(...args) {
-        // Bun's duplicate() is async, but IRedisClient.duplicate() is sync.
-        // We create a new RedisClient with the same URL/options instead.
-        // The raw client constructor in Bun doesn't connect until connect() or
-        // first command, so this is safe.
-        const BunRedisClient = this.raw
-            .constructor;
-        const dup = new BunRedisClient(this.raw.url);
-        const adapter = new BunRedisAdapter(dup);
+        // Bun's duplicate() is async, but IRedisClient.duplicate() is sync. The
+        // duplicate adapter is therefore created immediately with a `rawFactory`
+        // that clones the connection target lazily (via Bun's native duplicate)
+        // on first connect. Rebuilding from `this.raw.url` is not possible because
+        // Bun never exposes the URL, which previously sent duplicates to the
+        // wrong (default) server (#4582).
+        const parentRaw = this.raw;
+        const adapter = new BunRedisAdapter(undefined, {
+            rawFactory: () => this._duplicateRaw(parentRaw),
+        });
         // Copy registered scripts to the duplicate
         for (const [name, script] of this.scripts) {
             adapter.scripts.set(name, script);
@@ -411,6 +513,14 @@ class BunRedisAdapter extends events_1.EventEmitter {
         if (this.closing || this.closed) {
             return Promise.reject(new connection_closed_error_1.ConnectionClosedError('Connection is closed'));
         }
+        // A duplicate created via `duplicate()` builds its raw client lazily on the
+        // first `connect()` (Bun's native `duplicate()` is async). Materialize it
+        // here so commands issued before an explicit `connect()` don't throw on an
+        // undefined `raw` — matching other adapters where duplicates connect
+        // implicitly on first use.
+        if (!this.raw) {
+            return this.connect().then(() => this.sendCommand(command, args));
+        }
         // Send directly to the underlying Bun client. Redis protocol guarantees
         // responses arrive in the same order as requests on a single connection,
         // so concurrent send() calls are safe and enable implicit pipelining
@@ -440,10 +550,10 @@ class BunRedisAdapter extends events_1.EventEmitter {
     // Pipeline / Transaction
     // ---------------------------------------------------------------
     multi() {
-        return new BunRedisTransaction(this.raw, this.scripts, true, this);
+        return new BunRedisTransaction(this.scripts, true, this);
     }
     pipeline() {
-        return new BunRedisTransaction(this.raw, this.scripts, false, this);
+        return new BunRedisTransaction(this.scripts, false, this);
     }
     // ---------------------------------------------------------------
     // Hash commands
@@ -606,7 +716,7 @@ class BunRedisAdapter extends events_1.EventEmitter {
         for (const [k, v] of Object.entries(fields)) {
             args.push(k, String(v));
         }
-        return await this.raw.send('XADD', args);
+        return await (await this._ensureRaw()).send('XADD', args);
     }
     async xread(streams, options) {
         const args = [];
@@ -833,8 +943,7 @@ class BunRedisAdapter extends events_1.EventEmitter {
 // them within a MULTI/EXEC block using send().
 // ---------------------------------------------------------------------------
 class BunRedisTransaction {
-    constructor(raw, scripts, transactional, adapter) {
-        this.raw = raw;
+    constructor(scripts, transactional, adapter) {
         this.scripts = scripts;
         this.transactional = transactional;
         this.adapter = adapter;
@@ -996,15 +1105,18 @@ class BunRedisTransaction {
         const swallow = (_) => {
             /* error surfaces via EXEC or the outer try/catch */
         };
+        // Materialize the raw client (a lazily-initialized duplicate may not have
+        // one yet) so the MULTI…EXEC frames can be written as a contiguous burst.
+        const raw = await this.adapter._ensureRaw();
         try {
             // Fire MULTI without awaiting — no round-trip needed before commands.
-            this.raw.send('MULTI', []).catch(swallow);
+            raw.send('MULTI', []).catch(swallow);
             // Fire all queued commands synchronously (no awaits).
             for (const { cmd, args } of this.commands) {
-                this.raw.send(cmd, args).catch(swallow);
+                raw.send(cmd, args).catch(swallow);
             }
             // EXEC is the only await — it returns the array of results.
-            const results = await this.raw.send('EXEC', []);
+            const results = await raw.send('EXEC', []);
             if (!results) {
                 return null;
             }
@@ -1021,7 +1133,7 @@ class BunRedisTransaction {
         catch (err) {
             // Try to discard the MULTI state on error
             try {
-                await this.raw.send('DISCARD', []);
+                await raw.send('DISCARD', []);
             }
             catch (_a) {
                 // ignore

package/dist/cjs/classes/redis-queue-backend.js

@@ -23,6 +23,44 @@ const queue_keys_1 = require("./queue-keys");
  * scan the whole state unboundedly.
  */
 const GET_JOBS_MAX_BACKFILL_ITERATIONS = 5;
+/**
+ * Whether the client currently has a live connection. IORedis Cluster reports a
+ * usable connection as `connect` rather than `ready` (see
+ * `RedisConnection.waitUntilReady`).
+ */
+function isClientLive(client) {
+    return (client.status === 'ready' ||
+        (client.status === 'connect' && (0, utils_1.isRedisCluster)(client)));
+}
+/**
+ * Resets a connection whose blocking command was abandoned by a watchdog.
+ *
+ * Under `maxRetriesPerRequest: null` IORedis silently re-queues and re-sends
+ * an interrupted blocking command instead of rejecting it, so the abandoned
+ * command outlives a reconnect and would be served ahead of the next blocking
+ * read. Getting rid of it requires tearing the socket down while it is live.
+ *
+ * If the client is currently socketless (`reconnecting`) we must NOT
+ * disconnect it: that clears IORedis' own retry timer without emitting a
+ * `close` event and parks it in `reconnecting` forever (#4585). Instead we
+ * wait (via `reconnect`) for it to reach a live state and only then tear the
+ * socket down, waiting for it to actually close (`disconnect(true)` awaits
+ * the `end` event) before reconnecting again: IORedis closes the socket
+ * asynchronously, so a bare `disconnect(false)` leaves `status` transiently
+ * `ready`, `reconnect()` would observe the stale status, return a no-op, and
+ * the pending close would kill the connection for good (#4585 ready-path
+ * race).
+ */
+async function resetBlockedConnection(connection, client, reconnect) {
+    if (!isClientLive(client)) {
+        // Let IORedis' own retry timer bring the connection back first.
+        await reconnect();
+    }
+    if (isClientLive(client)) {
+        await connection.disconnect(true);
+        await reconnect();
+    }
+}
 class RedisQueueBackend extends events_1.EventEmitter {
     constructor(connection, name, keys, toKey, opts, blockingConnection, ownsConnection = true) {
         var _a;
@@ -242,6 +280,14 @@ class RedisQueueBackend extends events_1.EventEmitter {
             ? 0.001
             : 0.002;
     }
+    /**
+     * Largest meaningful block timeout (seconds). Capped at 10s because a
+     * `BZPOPMIN` blocked longer than this risks issues on reconnection
+     * (see #1658).
+     */
+    get maximumBlockTimeout() {
+        return 10;
+    }
     /**
      * Interrupts the in-flight blocking wait by disconnecting the dedicated
      * blocking connection. No-op if there is none.
@@ -1821,7 +1867,7 @@ class RedisQueueBackend extends events_1.EventEmitter {
     // Worker blocking primitive (previously bzpopmin in Worker)
     // ============================================================
     async waitForJob(blockTimeout) {
-        var _a;
+        var _a, _b;
         const conn = (_a = this.blockingConnection) !== null && _a !== void 0 ? _a : this.connection;
         const bclient = (await this.queue.blockingClient);
         const roundedTimeout = conn.capabilities.canDoubleTimeout
@@ -1850,7 +1896,9 @@ class RedisQueueBackend extends events_1.EventEmitter {
         const timeout = new Promise(resolve => {
             watchdog = setTimeout(() => {
                 timedOut = true;
-                bclient.disconnect(false);
+                // Resolve the wait as a timeout so the worker loop always advances.
+                // The (possibly stuck) command is abandoned and the connection is
+                // re-established in the `finally` block — see the note there.
                 resolve(null);
             }, roundedTimeout * 1000 + 1000);
         });
@@ -1866,16 +1914,16 @@ class RedisQueueBackend extends events_1.EventEmitter {
         }
         finally {
             clearTimeout(watchdog);
-            // The watchdog disconnected the blocking connection without letting
-            // IORedis auto-resend the abandoned command. Since we resolved the wait
-            // as a timeout (rather than surfacing a rejection to the worker's own
-            // reconnect path), re-establish the dedicated blocking connection here so
-            // the next `waitForJob` starts from a healthy, unblocked connection.
+            // The watchdog resolved the wait as a timeout because the awaited command
+            // never settled. Reset the dedicated blocking connection so the next
+            // `waitForJob` starts from a healthy, unblocked connection and the
+            // abandoned command is actually dropped — see
+            // `resetBlockedConnection()`.
             if (timedOut && !this.closing) {
                 try {
-                    await this.reconnectBlocking();
+                    await resetBlockedConnection((_b = this.blockingConnection) !== null && _b !== void 0 ? _b : this.connection, bclient, () => this.reconnectBlocking());
                 }
-                catch (_b) {
+                catch (_c) {
                     // Ignored: the next waitForJob call will retry the reconnect.
                 }
             }
@@ -1915,7 +1963,9 @@ class RedisQueueBackend extends events_1.EventEmitter {
         const timeout = new Promise(resolve => {
             watchdog = setTimeout(() => {
                 timedOut = true;
-                client.disconnect(false);
+                // Resolve as a timeout so the consumer loop always advances. The
+                // (possibly stuck) command is abandoned and the connection
+                // re-established in the `finally` block — see the note there.
                 resolve(null);
             }, blockTimeout + 1000);
         });
@@ -1924,12 +1974,12 @@ class RedisQueueBackend extends events_1.EventEmitter {
         }
         finally {
             clearTimeout(watchdog);
-            // The watchdog disconnected the connection without letting IORedis
-            // auto-resend the abandoned command. Re-establish it here so the next
-            // read starts from a healthy, unblocked connection.
+            // Reset the connection so the next read starts healthy and the abandoned
+            // command is actually dropped. Mirrors the `waitForJob` reset — see
+            // `resetBlockedConnection()`.
             if (timedOut && !this.closing) {
                 try {
-                    await this.connection.reconnect();
+                    await resetBlockedConnection(this.connection, client, () => this.connection.reconnect());
                 }
                 catch (_a) {
                     // Ignored: the next readEvents call will retry the reconnect.

package/dist/cjs/classes/worker.js

@@ -14,8 +14,9 @@ const errors_1 = require("./errors");
 const enums_1 = require("../enums");
 const job_scheduler_1 = require("./job-scheduler");
 const lock_manager_1 = require("./lock-manager");
-// 10 seconds is the maximum time a BZPOPMIN can block.
-const maximumBlockTimeout = 10;
+// 10 seconds is the maximum time a BZPOPMIN can block, so it is the default
+// ceiling used when a backend does not delegate its own `maximumBlockTimeout`.
+const defaultMaximumBlockTimeout = 10;
 /**
  *
  * This class represents a worker that is able to process jobs from the queue.
@@ -396,6 +397,10 @@ class Worker extends queue_base_1.QueueBase {
     get minimumBlockTimeout() {
         return this.backend.minimumBlockTimeout;
     }
+    get maximumBlockTimeout() {
+        var _a;
+        return (_a = this.backend.maximumBlockTimeout) !== null && _a !== void 0 ? _a : defaultMaximumBlockTimeout;
+    }
     isRateLimited() {
         return this.limitUntil > Date.now();
     }
@@ -466,10 +471,13 @@ class Worker extends queue_base_1.QueueBase {
                 return this.minimumBlockTimeout;
             }
             else {
-                // We restrict the maximum block timeout to 10 second to avoid
-                // blocking the connection for too long in the case of reconnections
-                // reference: https://github.com/taskforcesh/bullmq/issues/1658
-                return Math.min(blockDelay / 1000, maximumBlockTimeout);
+                // We restrict the maximum block timeout to avoid blocking the
+                // connection for too long in the case of reconnections. The ceiling is
+                // backend-specific: Redis caps it at 10s (a `BZPOPMIN` blocked longer
+                // risks issues on reconnection, see #1658), whereas a backend that
+                // keeps the connection open and re-arms to the next due job can allow a
+                // much larger value so an idle worker stops re-polling.
+                return Math.min(blockDelay / 1000, this.maximumBlockTimeout);
             }
         }
         else {