bullmq 5.80.4 → 5.80.6

package/dist/cjs/classes/child-pool.js

@@ -46,7 +46,23 @@ class ChildPool {
         }
         catch (err) {
             console.error(err);
-            this.release(child);
+            // A child that failed to initialize (or exited during init) must never
+            // be released back into the free pool, otherwise it becomes a "zombie"
+            // that is reused for every subsequent job and fails them instantly.
+            // Kill and remove it so a fresh child is forked on the next retain.
+            // The child also exits itself after a failed init (see ChildProcessor),
+            // so this is normally a no-op; log any kill failure instead of silently
+            // swallowing it so a lingering child would not go unnoticed.
+            if (child.childProcess || child.worker) {
+                try {
+                    this.kill(child, 'SIGKILL').catch(killErr => {
+                        console.error('Failed to kill child after init error:', killErr);
+                    });
+                }
+                catch (killErr) {
+                    console.error('Failed to kill child after init error:', killErr);
+                }
+            }
             throw err;
         }
     }

package/dist/cjs/classes/child-processor.js

@@ -25,6 +25,7 @@ class ChildProcessor {
         this.receiver = receiver;
     }
     async init(processorFile) {
+        var _a;
         let processor;
         try {
             const { default: processorFn } = await import(processorFile);
@@ -39,10 +40,22 @@ class ChildProcessor {
         }
         catch (err) {
             this.status = ChildStatus.Errored;
-            return this.send({
-                cmd: enums_1.ParentCommand.InitFailed,
-                err: (0, utils_1.errorToJSON)(err),
-            });
+            try {
+                await this.send({
+                    cmd: enums_1.ParentCommand.InitFailed,
+                    err: (0, utils_1.errorToJSON)(err),
+                });
+            }
+            finally {
+                // A child that failed to initialize cannot recover, and because the open
+                // IPC channel keeps its event loop alive it would never exit on its own.
+                // Exit explicitly (after attempting to send InitFailed) so the parent
+                // can never reuse a half-initialized "zombie" child. This is a
+                // belt-and-braces measure: ChildPool also kills the child, but exiting
+                // here guarantees termination even if the parent-side kill were to fail.
+                // In a worker thread this stops only the current worker, not the process.
+                process.exit((_a = process.exitCode) !== null && _a !== void 0 ? _a : 1);
+            }
         }
         const origProcessor = processor;
         processor = function (job, token, signal) {

package/dist/cjs/classes/child.js

@@ -68,6 +68,7 @@ class Child extends events_1.EventEmitter {
         return this._killed;
     }
     async init() {
+        var _a, _b;
         const execArgv = await convertExecArgv(process.execArgv);
         let parent;
         if (this.opts.useWorkerThreads) {
@@ -92,8 +93,13 @@ class Child extends events_1.EventEmitter {
         parent.on('error', (...args) => this.emit('error', ...args));
         parent.on('message', (...args) => this.emit('message', ...args));
         parent.on('close', (...args) => this.emit('close', ...args));
-        parent.stdout.pipe(process.stdout);
-        parent.stderr.pipe(process.stderr);
+        // `parent.stdout`/`parent.stderr` may be null when the underlying runtime
+        // does not pipe child stdio (e.g. Bun ignores `worker_threads` stdout/stderr
+        // options, and Node returns null when `stdio: 'ignore'` is passed in
+        // `workerForkOptions`). Guard the pipe calls so initialization does not throw.
+        // See https://github.com/taskforcesh/bullmq/issues/2232
+        (_a = parent.stdout) === null || _a === void 0 ? void 0 : _a.pipe(process.stdout);
+        (_b = parent.stderr) === null || _b === void 0 ? void 0 : _b.pipe(process.stderr);
         await this.initChild();
     }
     async send(msg) {

package/dist/cjs/classes/job.js

@@ -27,6 +27,18 @@ class Job {
     name, 
     /**
      * The payload for this job.
+     *
+     * Note: The `DataType` type parameter describes the *shape* of the
+     * payload, not its runtime class. Job data is serialized with
+     * `JSON.stringify` before being stored in Redis and deserialized with
+     * `JSON.parse` when read back, so when a worker picks up the job
+     * `job.data` will contain a JSON-compatible value such as an object,
+     * array, string, number, boolean, or `null`. Class instances passed as
+     * `data` lose their prototype (and therefore any methods,
+     * getters/setters, or non-enumerable properties) on the worker side.
+     * If you need methods, store the data as a plain object and
+     * re-instantiate the class inside your processor, or rely on
+     * `JSON.stringify`'s built-in `toJSON()` hook to control serialization.
      */
     data, 
     /**
@@ -120,7 +132,11 @@ class Job {
      *
      * @param queue - the queue where to add the job.
      * @param name - the name of the job.
-     * @param data - the payload of the job.
+     * @param data - the payload of the job. It will be serialized with
+     * `JSON.stringify` before being stored in Redis, so it must be
+     * JSON-serializable. Class instances are flattened to plain objects and
+     * lose their prototype methods on the worker side; see the
+     * {@link Job} class for details.
      * @param opts - the options bag for this job.
      * @returns The created Job instance
      */

package/dist/cjs/classes/queue.js

@@ -145,7 +145,14 @@ class Queue extends queue_getters_1.QueueGetters {
      * Adds a new job to the queue.
      *
      * @param name - Name of the job to be added to the queue.
-     * @param data - Arbitrary data to append to the job.
+     * @param data - Arbitrary data to append to the job. The value is
+     * serialized with `JSON.stringify` before being stored in Redis, so it
+     * must be JSON-serializable. The `DataType` type parameter describes the
+     * shape of this payload, not a runtime class: passing a class instance
+     * will store its enumerable own properties, but its prototype methods
+     * and getters/setters will not be available when a worker reads
+     * `job.data` back. Prefer plain objects, or implement `toJSON()` on
+     * the class to control how it is serialized.
      * @param opts - Job options that affects how the job is going to be processed.
      */
     async add(name, data, opts) {
@@ -200,7 +207,9 @@ class Queue extends queue_getters_1.QueueGetters {
      * one job at a time in a sequence.
      *
      * @param jobs - The array of jobs to add to the queue. Each job is defined by 3
-     * properties, 'name', 'data' and 'opts'. They follow the same signature as 'Queue.add'.
+     * properties, 'name', 'data' and 'opts'. They follow the same signature as 'Queue.add',
+     * including the JSON-serialization caveat for `data` (class instances lose their
+     * prototype methods on the worker side).
      */
     async addBulk(jobs) {
         return this.trace(enums_1.SpanKind.PRODUCER, 'addBulk', this.name, async (span, srcPropagationMetadata) => {

package/dist/cjs/classes/sandbox.js

@@ -17,7 +17,7 @@ const sandbox = (processFile, childPool) => {
                         child = await childPool.retain(processFile);
                         child.on('exit', exitHandler);
                         msgHandler = async (msg) => {
-                            var _a, _b, _c, _d, _e;
+                            var _a, _b, _c, _d, _e, _f;
                             try {
                                 switch (msg.cmd) {
                                     case enums_1.ParentCommand.Completed:
@@ -26,7 +26,10 @@ const sandbox = (processFile, childPool) => {
                                     case enums_1.ParentCommand.Failed:
                                     case enums_1.ParentCommand.Error: {
                                         const err = new Error();
-                                        Object.assign(err, msg.value);
+                                        // ParentCommand.Failed carries the error under `value`,
+                                        // while ParentCommand.Error carries it under `err`. Read
+                                        // from either key so the failure reason is never lost.
+                                        Object.assign(err, (_a = msg.value) !== null && _a !== void 0 ? _a : msg.err);
                                         reject(err);
                                         break;
                                     }
@@ -37,14 +40,14 @@ const sandbox = (processFile, childPool) => {
                                         await job.log(msg.value);
                                         break;
                                     case enums_1.ParentCommand.MoveToDelayed:
-                                        await job.moveToDelayed((_a = msg.value) === null || _a === void 0 ? void 0 : _a.timestamp, (_b = msg.value) === null || _b === void 0 ? void 0 : _b.token);
+                                        await job.moveToDelayed((_b = msg.value) === null || _b === void 0 ? void 0 : _b.timestamp, (_c = msg.value) === null || _c === void 0 ? void 0 : _c.token);
                                         break;
                                     case enums_1.ParentCommand.MoveToWait:
-                                        await job.moveToWait((_c = msg.value) === null || _c === void 0 ? void 0 : _c.token);
+                                        await job.moveToWait((_d = msg.value) === null || _d === void 0 ? void 0 : _d.token);
                                         break;
                                     case enums_1.ParentCommand.MoveToWaitingChildren:
                                         {
-                                            const value = await job.moveToWaitingChildren((_d = msg.value) === null || _d === void 0 ? void 0 : _d.token, (_e = msg.value) === null || _e === void 0 ? void 0 : _e.opts);
+                                            const value = await job.moveToWaitingChildren((_e = msg.value) === null || _e === void 0 ? void 0 : _e.token, (_f = msg.value) === null || _f === void 0 ? void 0 : _f.opts);
                                             child.send({
                                                 requestId: msg.requestId,
                                                 cmd: enums_1.ChildCommand.MoveToWaitingChildrenResponse,