bullmq 6.0.6 → 6.0.8

package/dist/cjs/classes/errors/connection-closed-error.js

@@ -1,6 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConnectionClosedError = void 0;
+exports.ConnectionClosedError = exports.CONNECTION_CLOSED_ERROR_MSG = void 0;
+/**
+ * Error message used when a connection is closed.
+ *
+ * This mirrors the constant exported by ioredis (`ioredis/built/utils`) but is
+ * defined locally so that BullMQ can be used without ioredis installed (for
+ * example, when using the PostgreSQL backend).
+ */
+exports.CONNECTION_CLOSED_ERROR_MSG = 'Connection is closed.';
 /**
  * Thrown by any BullMQ Redis adapter (ioredis, node-redis, Bun, …) when a
  * command fails because the connection is already closed or was closed
@@ -11,7 +19,7 @@ exports.ConnectionClosedError = void 0;
  */
 class ConnectionClosedError extends Error {
     constructor(message, cause) {
-        super(message !== null && message !== void 0 ? message : 'Connection is closed');
+        super(message !== null && message !== void 0 ? message : exports.CONNECTION_CLOSED_ERROR_MSG);
         this.cause = cause;
         this.name = 'ConnectionClosedError';
         Object.setPrototypeOf(this, new.target.prototype);

package/dist/cjs/classes/redis-connection.js

@@ -4,10 +4,7 @@ exports.RedisConnection = void 0;
 const tslib_1 = require("tslib");
 const events_1 = require("events");
 const ioredis_1 = require("ioredis");
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore
-const utils_1 = require("ioredis/built/utils");
-const utils_2 = require("../utils");
+const utils_1 = require("../utils");
 const version_1 = require("../version");
 const scripts = require("../scripts");
 const ioredis_client_1 = require("./ioredis-client");
@@ -44,7 +41,7 @@ class RedisConnection extends events_1.EventEmitter {
         this.disabledBlockingClusterReconnect = false;
         // Set extra options defaults
         this.extraOptions = Object.assign({ shared: false, blocking: true, skipVersionCheck: false, skipWaitingForReady: false, clusterReconnectTimeoutMs: DEFAULT_CLUSTER_RECONNECT_TIMEOUT_MS }, extraOptions);
-        if (!(0, utils_2.isRedisInstance)(opts)) {
+        if (!(0, utils_1.isRedisInstance)(opts)) {
             this.checkBlockingOptions(overrideMessage, opts);
             this.opts = Object.assign({ port: 6379, host: '127.0.0.1', retryStrategy: function (times) {
                     return Math.max(Math.min(Math.exp(times), 20000), 1000);
@@ -118,14 +115,14 @@ class RedisConnection extends events_1.EventEmitter {
         // 'ready' that standalone Redis uses. Treat it as already connected so we
         // don't hang waiting for a 'ready' event that will never fire and end up
         // throwing a spurious "Connection is closed" error during disconnect.
-        if (client.status === 'connect' && (0, utils_2.isRedisCluster)(client)) {
+        if (client.status === 'connect' && (0, utils_1.isRedisCluster)(client)) {
             return;
         }
         if (client.status === 'wait') {
             return client.connect();
         }
         if (client.status === 'end') {
-            throw new connection_closed_error_1.ConnectionClosedError(utils_1.CONNECTION_CLOSED_ERROR_MSG);
+            throw new connection_closed_error_1.ConnectionClosedError(connection_closed_error_1.CONNECTION_CLOSED_ERROR_MSG);
         }
         let handleReady;
         let handleEnd;
@@ -142,7 +139,7 @@ class RedisConnection extends events_1.EventEmitter {
                 handleEnd = () => {
                     if (client.status !== 'end') {
                         reject(lastError ||
-                            new connection_closed_error_1.ConnectionClosedError(utils_1.CONNECTION_CLOSED_ERROR_MSG));
+                            new connection_closed_error_1.ConnectionClosedError(connection_closed_error_1.CONNECTION_CLOSED_ERROR_MSG));
                     }
                     else {
                         if (lastError) {
@@ -154,7 +151,7 @@ class RedisConnection extends events_1.EventEmitter {
                         }
                     }
                 };
-                (0, utils_2.increaseMaxListeners)(client, 3);
+                (0, utils_1.increaseMaxListeners)(client, 3);
                 client.once('ready', handleReady);
                 client.on('end', handleEnd);
                 client.once('error', handleError);
@@ -164,7 +161,7 @@ class RedisConnection extends events_1.EventEmitter {
             client.removeListener('end', handleEnd);
             client.removeListener('error', handleError);
             client.removeListener('ready', handleReady);
-            (0, utils_2.decreaseMaxListeners)(client, 3);
+            (0, utils_1.decreaseMaxListeners)(client, 3);
         }
     }
     get client() {
@@ -194,7 +191,7 @@ class RedisConnection extends events_1.EventEmitter {
                 this._client = (0, ioredis_client_1.createIORedisClient)(ioredisClient);
             }
         }
-        (0, utils_2.increaseMaxListeners)(this._client, 3);
+        (0, utils_1.increaseMaxListeners)(this._client, 3);
         this._client.on('error', this.handleClientError);
         // ioredis treats connection errors as a different event ('close')
         this._client.on('close', this.handleClientClose);
@@ -209,18 +206,18 @@ class RedisConnection extends events_1.EventEmitter {
             this.version = versionResult.version;
             this.dbType = versionResult.databaseType;
             if (this.skipVersionCheck !== true && !this.closing) {
-                if ((0, utils_2.isRedisVersionLowerThan)(this.version, RedisConnection.minimumVersion, this.dbType)) {
+                if ((0, utils_1.isRedisVersionLowerThan)(this.version, RedisConnection.minimumVersion, this.dbType)) {
                     throw new Error(`Redis version needs to be greater or equal than ${RedisConnection.minimumVersion} ` +
                         `Current: ${this.version}`);
                 }
-                if ((0, utils_2.isRedisVersionLowerThan)(this.version, RedisConnection.recommendedMinimumVersion, this.dbType)) {
+                if ((0, utils_1.isRedisVersionLowerThan)(this.version, RedisConnection.recommendedMinimumVersion, this.dbType)) {
                     console.warn(`It is highly recommended to use a minimum Redis version of ${RedisConnection.recommendedMinimumVersion}
              Current: ${this.version}`);
                 }
             }
             this.capabilities = {
-                canDoubleTimeout: !(0, utils_2.isRedisVersionLowerThan)(this.version, '6.0.0', this.dbType),
-                canBlockFor1Ms: !(0, utils_2.isRedisVersionLowerThan)(this.version, '7.0.8', this.dbType),
+                canDoubleTimeout: !(0, utils_1.isRedisVersionLowerThan)(this.version, '6.0.0', this.dbType),
+                canBlockFor1Ms: !(0, utils_1.isRedisVersionLowerThan)(this.version, '7.0.8', this.dbType),
             };
             this.status = 'ready';
         }
@@ -231,7 +228,7 @@ class RedisConnection extends events_1.EventEmitter {
         const client = this._client;
         const blockingClient = client;
         if (!this.extraOptions.blocking ||
-            !(0, utils_2.isRedisCluster)(client) ||
+            !(0, utils_1.isRedisCluster)(client) ||
             typeof blockingClient.bzpopmin !== 'function') {
             return;
         }
@@ -384,7 +381,7 @@ class RedisConnection extends events_1.EventEmitter {
                 return client.disconnect();
             }
             const disconnecting = new Promise((resolve, reject) => {
-                (0, utils_2.increaseMaxListeners)(client, 2);
+                (0, utils_1.increaseMaxListeners)(client, 2);
                 client.once('end', resolve);
                 client.once('error', reject);
                 _resolve = resolve;
@@ -395,7 +392,7 @@ class RedisConnection extends events_1.EventEmitter {
                 await disconnecting;
             }
             finally {
-                (0, utils_2.decreaseMaxListeners)(client, 2);
+                (0, utils_1.decreaseMaxListeners)(client, 2);
                 client.removeListener('end', _resolve);
                 client.removeListener('error', _reject);
             }
@@ -405,7 +402,7 @@ class RedisConnection extends events_1.EventEmitter {
         const client = await this.client;
         for (;;) {
             if (client.status === 'ready' ||
-                (client.status === 'connect' && (0, utils_2.isRedisCluster)(client))) {
+                (client.status === 'connect' && (0, utils_1.isRedisCluster)(client))) {
                 return;
             }
             if (client.status === 'wait' || client.status === 'end') {
@@ -449,7 +446,7 @@ class RedisConnection extends events_1.EventEmitter {
                 }
             }
             catch (error) {
-                if ((0, utils_2.isNotConnectionError)(error)) {
+                if ((0, utils_1.isNotConnectionError)(error)) {
                     throw error;
                 }
             }
@@ -458,7 +455,7 @@ class RedisConnection extends events_1.EventEmitter {
                 this._client.off('error', this.handleClientError);
                 this._client.off('close', this.handleClientClose);
                 this._client.off('ready', this.handleClientReady);
-                (0, utils_2.decreaseMaxListeners)(this._client, 3);
+                (0, utils_1.decreaseMaxListeners)(this._client, 3);
                 this.removeAllListeners();
                 this.status = 'closed';
             }

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

@@ -1829,14 +1829,35 @@ class RedisQueueBackend extends events_1.EventEmitter {
         const roundedTimeout = conn.capabilities.canDoubleTimeout
             ? blockTimeout
             : Math.ceil(blockTimeout);
-        // We cannot trust that the blocking connection stays blocking forever due
-        // to issues in Redis and IORedis, so we reconnect the (owned) blocking
-        // connection if we don't get a response within the expected time.
-        const watchdog = setTimeout(() => {
-            bclient.disconnect(!this.closing);
-        }, roundedTimeout * 1000 + 1000);
+        const bzpopmin = bclient.bzpopmin(this.queue.keys.marker, roundedTimeout);
+        // If the watchdog abandons this command below, its (possibly much later)
+        // rejection must not surface as an unhandled promise rejection.
+        bzpopmin.catch(() => null);
+        // We cannot trust that the blocking connection stays blocking for exactly
+        // the expected time due to issues in Redis and IORedis. In particular,
+        // blocking connections must use `maxRetriesPerRequest: null`, and with that
+        // setting IORedis silently re-queues and re-sends an interrupted blocking
+        // command after a reconnect instead of rejecting it (see #4479). As a
+        // result the awaited `bzpopmin` can hang forever after a transient
+        // connection reset, parking the worker's fetch loop permanently.
+        //
+        // To make this robust we race the blocking command against a watchdog
+        // timeout: when the deadline passes we disconnect the (owned) blocking
+        // connection to abandon the possibly-stuck command and resolve the wait as
+        // a timeout, so the worker loop always advances (and can promote due
+        // delayed jobs / write markers) regardless of whether IORedis ever settles
+        // the command.
+        let timedOut = false;
+        let watchdog;
+        const timeout = new Promise(resolve => {
+            watchdog = setTimeout(() => {
+                timedOut = true;
+                bclient.disconnect(false);
+                resolve(null);
+            }, roundedTimeout * 1000 + 1000);
+        });
         try {
-            const result = await bclient.bzpopmin(this.queue.keys.marker, roundedTimeout);
+            const result = await Promise.race([bzpopmin, timeout]);
             if (result) {
                 const [, member, score] = result;
                 if (member) {
@@ -1847,6 +1868,19 @@ 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.
+            if (timedOut && !this.closing) {
+                try {
+                    await this.reconnectBlocking();
+                }
+                catch (_b) {
+                    // Ignored: the next waitForJob call will retry the reconnect.
+                }
+            }
         }
     }
     async publishEvent(fields, maxEvents) {
@@ -1858,9 +1892,52 @@ class RedisQueueBackend extends events_1.EventEmitter {
     }
     async readEvents(id, blockTimeout) {
         const client = await this.queue.client;
-        return client.xread([{ key: this.queue.keys.events, id }], {
+        const xread = client.xread([{ key: this.queue.keys.events, id }], {
             BLOCK: blockTimeout,
         });
+        // Redis XREAD `BLOCK 0` means "block forever". If `blockTimeout` is <= 0 we
+        // cannot enforce a bounded deadline, so fall back to the plain blocking read.
+        if (blockTimeout <= 0) {
+            return xread;
+        }
+        // If the watchdog abandons this command below, its (possibly much later)
+        // rejection must not surface as an unhandled promise rejection.
+        xread.catch(() => null);
+        // Same class of hang as `waitForJob` (#4479): the event-stream connection
+        // must use `maxRetriesPerRequest: null`, and with that setting IORedis
+        // silently re-queues and re-sends an interrupted blocking `XREAD` after a
+        // reconnect instead of rejecting it — so the awaited read can hang forever
+        // after a transient connection reset, permanently stalling the event
+        // consumer loop. Race the read against a watchdog: when the deadline passes
+        // (the server-side BLOCK plus a small margin) we disconnect the connection
+        // to abandon the stuck command and resolve as a timeout, so the consumer
+        // loop always advances and can re-issue the read.
+        let timedOut = false;
+        let watchdog;
+        const timeout = new Promise(resolve => {
+            watchdog = setTimeout(() => {
+                timedOut = true;
+                client.disconnect(false);
+                resolve(null);
+            }, blockTimeout + 1000);
+        });
+        try {
+            return (await Promise.race([xread, timeout]));
+        }
+        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.
+            if (timedOut && !this.closing) {
+                try {
+                    await this.connection.reconnect();
+                }
+                catch (_a) {
+                    // Ignored: the next readEvents call will retry the reconnect.
+                }
+            }
+        }
     }
 }
 exports.RedisQueueBackend = RedisQueueBackend;

package/dist/cjs/postgres/sql-loader.js

@@ -4,6 +4,26 @@ exports.loadMigrationSql = loadMigrationSql;
 exports.loadCommandSql = loadCommandSql;
 const fs_1 = require("fs");
 const path_1 = require("path");
+const url_1 = require("url");
+function getDirname() {
+    if (typeof __dirname !== 'undefined' && __dirname) {
+        return __dirname;
+    }
+    const stack = new Error().stack || '';
+    for (const line of stack.split('\n')) {
+        const match = line.match(/(file:\/\/\/[^\s)]+)/);
+        if (match) {
+            try {
+                return (0, path_1.dirname)((0, url_1.fileURLToPath)(match[1]));
+            }
+            catch (_a) {
+                // continue searching
+            }
+        }
+    }
+    throw new Error('Could not determine sql-loader directory path');
+}
+const currentDir = getDirname();
 /**
  * Loads a migration's SQL from its `.sql` file — the portable source of truth
  * shared with the Elixir/Python ports. Results are cached after the first read.
@@ -13,7 +33,7 @@ const path_1 = require("path");
  * analogous to how the Lua scripts are bundled), so the same relative lookup
  * works at runtime.
  */
-const MIGRATIONS_DIR = (0, path_1.join)(__dirname, 'migrations');
+const MIGRATIONS_DIR = (0, path_1.join)(currentDir, 'migrations');
 /**
  * Runtime queries live under `commands/`. Each `.sql` file is one parameterized
  * statement (a `SELECT fn(...)` for the PL/pgSQL operations, or a direct
@@ -22,7 +42,7 @@ const MIGRATIONS_DIR = (0, path_1.join)(__dirname, 'migrations');
  * Python/Elixir/PHP/Rust ports (mirroring how the Redis backend's `.lua`
  * scripts never hardcode the key prefix).
  */
-const COMMANDS_DIR = (0, path_1.join)(__dirname, 'commands');
+const COMMANDS_DIR = (0, path_1.join)(currentDir, 'commands');
 const migrationCache = new Map();
 const commandCache = new Map();
 function loadMigrationSql(file) {