bullmq 6.3.7 → 6.3.9

package/dist/cjs/classes/flow-producer.js

@@ -15,13 +15,13 @@ const enums_1 = require("../enums");
  * All Jobs can be in different queues, either children or parents,
  */
 class FlowProducer extends events_1.EventEmitter {
-    constructor(opts = { connection: {} }, backendFactory = (0, create_backend_1.getDefaultBackendFactory)()) {
+    constructor(opts, backendFactory) {
         super();
-        this.opts = opts;
-        this.opts = Object.assign({}, opts);
+        this.opts = Object.assign(opts === undefined ? { connection: {} } : {}, opts);
         // The flow producer is not bound to a single queue: each flow entry carries
         // its own queue identity, so the backend is created with an empty name.
-        this.backend = backendFactory('', this.opts);
+        const factory = backendFactory !== null && backendFactory !== void 0 ? backendFactory : (0, create_backend_1.getDefaultBackendFactory)();
+        this.backend = factory('', this.opts);
         this.backend.on('error', (error) => {
             if (this.listenerCount('error') > 0) {
                 this.emit('error', error);

package/dist/cjs/classes/queue-base.js

@@ -11,23 +11,15 @@ const job_1 = require("./job");
  *
  */
 class QueueBase extends events_1.EventEmitter {
-    /**
-     *
-     * @param name - The name of the queue.
-     * @param opts - Options for the queue.
-     * @param backendFactory - Factory used to build the {@link IQueueBackend}.
-     * Defaults to the Redis backend; inject a different factory to use another
-     * datastore or a test mock.
-     */
-    constructor(name, opts = { connection: {} }, backendFactory = (0, create_backend_1.getDefaultBackendFactory)(), hasBlockingConnection = false) {
+    constructor(name, opts, backendFactory, hasBlockingConnection = false) {
         super();
-        this.name = name;
-        this.opts = opts;
         this.closed = false;
         this.hasBlockingConnection = false;
-        this.backendFactory = backendFactory;
+        this.name = name;
+        this.backendFactory =
+            backendFactory !== null && backendFactory !== void 0 ? backendFactory : (0, create_backend_1.getDefaultBackendFactory)();
         this.hasBlockingConnection = hasBlockingConnection;
-        this.opts = Object.assign({}, opts);
+        this.opts = Object.assign(opts === undefined ? { connection: {} } : {}, opts);
         if (!name) {
             throw new Error('Queue name must be provided');
         }

package/dist/cjs/classes/queue-events-producer.js

@@ -7,11 +7,11 @@ const queue_base_1 = require("./queue-base");
  * The QueueEventsProducer class is used for publishing custom events.
  */
 class QueueEventsProducer extends queue_base_1.QueueBase {
-    constructor(name, opts = {
-        connection: {},
-    }, backendFactory) {
-        super(name, Object.assign({ blockingConnection: false }, opts), backendFactory);
-        this.opts = opts;
+    constructor(name, opts, backendFactory) {
+        super(name, opts && Object.assign({ blockingConnection: false }, opts), backendFactory);
+        if (opts) {
+            this.opts = opts;
+        }
     }
     /**
      * Publish custom event to be processed in QueueEvents.

package/dist/cjs/classes/queue-events.js

@@ -4,7 +4,6 @@ exports.QueueEvents = void 0;
 const tslib_1 = require("tslib");
 const utils_1 = require("../utils");
 const queue_base_1 = require("./queue-base");
-const ioredis_client_1 = require("./ioredis-client");
 /**
  * The QueueEvents class is used for listening to the global events
  * emitted by a given queue.
@@ -13,15 +12,13 @@ const ioredis_client_1 = require("./ioredis-client");
  *
  */
 class QueueEvents extends queue_base_1.QueueBase {
-    constructor(name, _a = {
-        connection: {},
-    }, backendFactory) {
-        var { connection, autorun = true } = _a, opts = tslib_1.__rest(_a, ["connection", "autorun"]);
-        super(name, Object.assign(Object.assign({}, opts), { connection: (0, utils_1.isRedisInstance)(connection)
-                ? ((0, ioredis_client_1.isIRedisClient)(connection)
-                    ? connection
-                    : (0, ioredis_client_1.createIORedisClient)(connection)).duplicate()
-                : connection }), backendFactory, true);
+    constructor(name, opts, backendFactory) {
+        const { autorun = true } = opts !== null && opts !== void 0 ? opts : {};
+        const queueOptions = opts && Object.assign({}, opts);
+        if (queueOptions) {
+            delete queueOptions.autorun;
+        }
+        super(name, queueOptions, backendFactory, true);
         this.running = false;
         this.blocking = false;
         this.opts = Object.assign({

package/dist/cjs/classes/queue.js

@@ -36,7 +36,7 @@ const utils_1 = require("../utils");
 class Queue extends queue_getters_1.QueueGetters {
     constructor(name, opts, backendFactory) {
         var _a;
-        super(name, Object.assign({}, opts), backendFactory);
+        super(name, opts, backendFactory);
         this.token = (0, utils_1.randomUUID)();
         this.libName = 'bullmq';
         this.jobsOpts = (_a = opts === null || opts === void 0 ? void 0 : opts.defaultJobOptions) !== null && _a !== void 0 ? _a : {};

package/dist/cjs/classes/worker.js

@@ -37,6 +37,9 @@ class Worker extends queue_base_1.QueueBase {
         return new errors_1.RateLimitError();
     }
     constructor(name, processor, opts, backendFactory) {
+        if (!opts || opts.connection === undefined || opts.connection === null) {
+            throw new Error('Worker requires a connection');
+        }
         super(name, Object.assign(Object.assign({ drainDelay: 5, concurrency: 1, lockDuration: 30000, maximumRateLimitDelay: 30000, maxStalledCount: 1, stalledInterval: 30000, autorun: true, runRetryDelay: 15000 }, opts), { blockingConnection: true }), backendFactory);
         this.abortDelayController = null;
         this.blockUntil = 0;
@@ -47,9 +50,6 @@ class Worker extends queue_base_1.QueueBase {
         this.waiting = null;
         this.running = false;
         this.mainLoopRunning = null;
-        if (!opts || !opts.connection) {
-            throw new Error('Worker requires a connection');
-        }
         if (typeof this.opts.maxStalledCount !== 'number' ||
             this.opts.maxStalledCount < 0) {
             throw new Error('maxStalledCount must be greater or equal than 0');

package/dist/cjs/index.js

@@ -9,5 +9,6 @@ tslib_1.__exportStar(require("./utils"), exports);
 // to prevent circular references
 tslib_1.__exportStar(require("./types/processor"), exports);
 tslib_1.__exportStar(require("./utils/create-backend"), exports);
+tslib_1.__exportStar(require("./utils/with-backend"), exports);
 // PostgreSQL backend (optional; requires the `pg` peer dependency at runtime).
 tslib_1.__exportStar(require("./postgres"), exports);

package/dist/cjs/postgres/create-postgres-backend.js

@@ -10,11 +10,9 @@ const postgres_queue_backend_1 = require("./postgres-queue-backend");
  * dedicated `LISTEN` client); the high-level classes depend only on
  * `IQueueBackend` and never touch a `pg` client directly.
  *
- * The `opts.connection` value is forwarded to {@link PostgresConnection} and may
- * be a connection string, a node-postgres pool config (optionally carrying a
- * `schema`), or an already-built `pg.Pool` instance. `pg` is lazily required
- * only when a config/string is passed, so Redis-only users never need it
- * installed.
+ * Accepts a connection string, pool config (optionally carrying a `schema`),
+ * or an existing `pg.Pool`. The `pg` driver is loaded lazily for config/string
+ * connections; Redis-only users do not need it installed.
  *
  * Inject this into the queue classes (or set it as the process-wide default via
  * `setDefaultBackendFactory(createPostgresBackend)`) to back BullMQ with

package/dist/cjs/postgres/postgres-connection.js

@@ -44,7 +44,10 @@ const LISTEN_KEEPALIVE_INITIAL_DELAY_MS = 10000;
 function enableSocketKeepAlive(client) {
     var _a;
     const stream = (_a = client.connection) === null || _a === void 0 ? void 0 : _a.stream;
-    if (!stream || typeof stream.setKeepAlive !== 'function') {
+    if (!stream ||
+        typeof stream !== 'object' ||
+        !('setKeepAlive' in stream) ||
+        typeof stream.setKeepAlive !== 'function') {
         return false;
     }
     try {
@@ -188,7 +191,7 @@ class PostgresConnection extends events_1.EventEmitter {
         // callers racing on the first use don't each open a connection — the
         // `await` below is exactly where a second caller would otherwise slip in.
         if (!this.listenClientPromise) {
-            this.listenClientPromise = (async () => {
+            const establishing = (async () => {
                 if (this.pgModule && this.listenClientConfig) {
                     const client = new this.pgModule.Client(Object.assign(Object.assign({}, this.listenClientConfig), { 
                         // A LISTEN subscription is bound to one physical connection. Enable
@@ -220,6 +223,16 @@ class PostgresConnection extends events_1.EventEmitter {
                     return client;
                 }
             })();
+            this.listenClientPromise = establishing;
+            // Memoize only a connect that succeeds. A rejected one (e.g. Postgres
+            // mid-restart) would otherwise be handed to every later caller, so the
+            // worker could never LISTEN again until the process restarts. Callers
+            // sharing this attempt still see its rejection.
+            establishing.catch(() => {
+                if (this.listenClientPromise === establishing) {
+                    this.listenClientPromise = undefined;
+                }
+            });
         }
         return this.listenClientPromise;
     }