@tachybase/plugin-adapter-bullmq 1.3.17 → 1.3.18

package/dist/node_modules/bullmq/dist/esm/classes/job.js

@@ -1,21 +1,10 @@
 import { __rest } from "tslib";
 import { debuglog } from 'util';
-import { errorObject, isEmpty, getParentKey, lengthInUtf8Bytes, parseObjectValues, tryCatch, removeUndefinedFields, invertObject, } from '../utils';
+import { createScripts, errorObject, isEmpty, getParentKey, lengthInUtf8Bytes, optsDecodeMap, optsEncodeMap, parseObjectValues, tryCatch, removeUndefinedFields, } from '../utils';
 import { Backoffs } from './backoffs';
-import { Scripts } from './scripts';
 import { UnrecoverableError } from './errors/unrecoverable-error';
 import { SpanKind } from '../enums';
 const logger = debuglog('bull');
-// Simple options decode map.
-const optsDecodeMap = {
-    de: 'deduplication',
-    fpof: 'failParentOnFailure',
-    idof: 'ignoreDependencyOnFailure',
-    kl: 'keepLogs',
-    rdof: 'removeDependencyOnFailure',
-};
-const optsEncodeMap = Object.assign(Object.assign({}, invertObject(optsDecodeMap)), { 
-    /*/ Legacy for backwards compatibility */ debounce: 'de' });
 export const PRIORITY_LIMIT = 2 ** 21;
 /**
  * Job
@@ -25,7 +14,6 @@ export const PRIORITY_LIMIT = 2 ** 21;
  *
  * A Job instance is also passed to the Worker's process function.
  *
- * @class Job
  */
 export class Job {
     constructor(queue, 
@@ -83,6 +71,11 @@ export class Job {
          * @defaultValue 0
          */
         this.attemptsMade = 0;
+        /**
+         * Number of times where job has stalled.
+         * @defaultValue 0
+         */
+        this.stalledCounter = 0;
         const _a = this.opts, { repeatJobKey } = _a, restOpts = __rest(_a, ["repeatJobKey"]);
         this.opts = Object.assign({
             attempts: 0,
@@ -93,15 +86,27 @@ export class Job {
         this.timestamp = opts.timestamp ? opts.timestamp : Date.now();
         this.opts.backoff = Backoffs.normalize(opts.backoff);
         this.parentKey = getParentKey(opts.parent);
-        this.parent = opts.parent
-            ? { id: opts.parent.id, queueKey: opts.parent.queue }
-            : undefined;
+        if (opts.parent) {
+            this.parent = { id: opts.parent.id, queueKey: opts.parent.queue };
+            if (opts.failParentOnFailure) {
+                this.parent.fpof = true;
+            }
+            if (opts.removeDependencyOnFailure) {
+                this.parent.rdof = true;
+            }
+            if (opts.ignoreDependencyOnFailure) {
+                this.parent.idof = true;
+            }
+            if (opts.continueParentOnFailure) {
+                this.parent.cpof = true;
+            }
+        }
         this.debounceId = opts.debounce ? opts.debounce.id : undefined;
         this.deduplicationId = opts.deduplication
             ? opts.deduplication.id
             : this.debounceId;
         this.toKey = queue.toKey.bind(queue);
-        this.setScripts();
+        this.createScripts();
         this.queueQualifiedName = queue.qualifiedName;
     }
     /**
@@ -167,6 +172,7 @@ export class Job {
         const job = new this(queue, json.name, data, opts, json.id || jobId);
         job.progress = JSON.parse(json.progress || '0');
         job.delay = parseInt(json.delay);
+        job.priority = parseInt(json.priority);
         job.timestamp = parseInt(json.timestamp);
         if (json.finishedOn) {
             job.finishedOn = parseInt(json.finishedOn);
@@ -181,9 +187,15 @@ export class Job {
             job.debounceId = json.deid;
             job.deduplicationId = json.deid;
         }
-        job.failedReason = json.failedReason;
+        if (json.failedReason) {
+            job.failedReason = json.failedReason;
+        }
         job.attemptsStarted = parseInt(json.ats || '0');
         job.attemptsMade = parseInt(json.attemptsMade || json.atm || '0');
+        job.stalledCounter = parseInt(json.stc || '0');
+        if (json.defa) {
+            job.deferredFailure = json.defa;
+        }
         job.stacktrace = getTraces(json.stacktrace);
         if (typeof json.returnvalue === 'string') {
             job.returnvalue = getReturnValue(json.returnvalue);
@@ -202,17 +214,17 @@ export class Job {
         }
         return job;
     }
-    setScripts() {
-        this.scripts = new Scripts(this.queue);
+    createScripts() {
+        this.scripts = createScripts(this.queue);
     }
-    static optsFromJSON(rawOpts) {
+    static optsFromJSON(rawOpts, optsDecode = optsDecodeMap) {
         const opts = JSON.parse(rawOpts || '{}');
         const optionEntries = Object.entries(opts);
         const options = {};
         for (const item of optionEntries) {
             const [attributeName, value] = item;
-            if (optsDecodeMap[attributeName]) {
-                options[optsDecodeMap[attributeName]] =
+            if (optsDecode[attributeName]) {
+                options[optsDecode[attributeName]] =
                     value;
             }
             else {
@@ -249,10 +261,10 @@ export class Job {
     /**
      * addJobLog
      *
-     * @param queue Queue instance
-     * @param jobId Job id
-     * @param logRow Log row
-     * @param keepLogs optional maximum number of logs to keep
+     * @param queue - A minimal queue instance
+     * @param jobId - Job id
+     * @param logRow - String with a row of log data to be logged
+     * @param keepLogs - The optional amount of log entries to preserve
      *
      * @returns The total number of log entries for this job so far.
      */
@@ -279,6 +291,7 @@ export class Job {
             progress: this.progress,
             attemptsMade: this.attemptsMade,
             attemptsStarted: this.attemptsStarted,
+            stalledCounter: this.stalledCounter,
             finishedOn: this.finishedOn,
             processedOn: this.processedOn,
             timestamp: this.timestamp,
@@ -291,16 +304,16 @@ export class Job {
             nrjid: this.nextRepeatableJobId,
         });
     }
-    static optsAsJSON(opts = {}) {
+    static optsAsJSON(opts = {}, optsEncode = optsEncodeMap) {
         const optionEntries = Object.entries(opts);
         const options = {};
         for (const [attributeName, value] of optionEntries) {
             if (typeof value === 'undefined') {
                 continue;
             }
-            if (attributeName in optsEncodeMap) {
+            if (attributeName in optsEncode) {
                 const compressableAttribute = attributeName;
-                const key = optsEncodeMap[compressableAttribute];
+                const key = optsEncode[compressableAttribute];
                 options[key] = value;
             }
             else {
@@ -399,6 +412,18 @@ export class Job {
             throw new Error(`Job ${this.id} could not be removed because it is locked by another worker`);
         }
     }
+    /**
+     * Remove all children from this job that are not yet processed,
+     * in other words that are in any other state than completed, failed or active.
+     *
+     * @remarks
+     *  - Jobs with locks (most likely active) are ignored.
+     *  - This method can be slow if the number of children is large (\> 1000).
+     */
+    async removeUnprocessedChildren() {
+        const jobId = this.id;
+        await this.scripts.removeUnprocessedChildren(jobId);
+    }
     /**
      * Extend the lock for this job.
      *
@@ -418,19 +443,35 @@ export class Job {
      * @returns Returns the jobData of the next job in the waiting queue or void.
      */
     async moveToCompleted(returnValue, token, fetchNext = true) {
-        await this.queue.waitUntilReady();
-        this.returnvalue = returnValue || void 0;
-        const stringifiedReturnValue = tryCatch(JSON.stringify, JSON, [
-            returnValue,
-        ]);
-        if (stringifiedReturnValue === errorObject) {
-            throw errorObject.value;
-        }
-        const args = this.scripts.moveToCompletedArgs(this, stringifiedReturnValue, this.opts.removeOnComplete, token, fetchNext);
-        const result = await this.scripts.moveToFinished(this.id, args);
-        this.finishedOn = args[this.scripts.moveToFinishedKeys.length + 1];
-        this.attemptsMade += 1;
-        return result;
+        return this.queue.trace(SpanKind.INTERNAL, 'complete', this.queue.name, async (span, dstPropagationMedatadata) => {
+            var _a, _b;
+            let tm;
+            if (!((_b = (_a = this.opts) === null || _a === void 0 ? void 0 : _a.telemetry) === null || _b === void 0 ? void 0 : _b.omitContext) && dstPropagationMedatadata) {
+                tm = dstPropagationMedatadata;
+            }
+            await this.queue.waitUntilReady();
+            this.returnvalue = returnValue || void 0;
+            const stringifiedReturnValue = tryCatch(JSON.stringify, JSON, [
+                returnValue,
+            ]);
+            if (stringifiedReturnValue === errorObject) {
+                throw errorObject.value;
+            }
+            const args = this.scripts.moveToCompletedArgs(this, stringifiedReturnValue, this.opts.removeOnComplete, token, fetchNext);
+            const result = await this.scripts.moveToFinished(this.id, args);
+            this.finishedOn = args[this.scripts.moveToFinishedKeys.length + 1];
+            this.attemptsMade += 1;
+            return result;
+        });
+    }
+    /**
+     * Moves a job to the wait or prioritized state.
+     *
+     * @param token - Worker token used to acquire completed job.
+     * @returns Returns pttl.
+     */
+    moveToWait(token) {
+        return this.scripts.moveJobFromActiveToWait(this.id, token);
     }
     async shouldRetryJob(err) {
         if (this.attemptsMade + 1 < this.opts.attempts &&
@@ -454,7 +495,9 @@ export class Job {
      */
     async moveToFailed(err, token, fetchNext = false) {
         this.failedReason = err === null || err === void 0 ? void 0 : err.message;
-        return this.queue.trace(SpanKind.INTERNAL, this.getSpanOperation('moveToFailed'), this.queue.name, async (span, dstPropagationMedatadata) => {
+        // Check if an automatic retry should be performed
+        const [shouldRetry, retryDelay] = await this.shouldRetryJob(err);
+        return this.queue.trace(SpanKind.INTERNAL, this.getSpanOperation(shouldRetry, retryDelay), this.queue.name, async (span, dstPropagationMedatadata) => {
             var _a, _b;
             let tm;
             if (!((_b = (_a = this.opts) === null || _a === void 0 ? void 0 : _a.telemetry) === null || _b === void 0 ? void 0 : _b.omitContext) && dstPropagationMedatadata) {
@@ -467,11 +510,7 @@ export class Job {
                 stacktrace: JSON.stringify(this.stacktrace),
                 tm,
             };
-            //
-            // Check if an automatic retry should be performed
-            //
             let finishedOn;
-            const [shouldRetry, retryDelay] = await this.shouldRetryJob(err);
             if (shouldRetry) {
                 if (retryDelay) {
                     // Retry with delay
@@ -499,15 +538,14 @@ export class Job {
             return result;
         });
     }
-    getSpanOperation(command) {
-        switch (command) {
-            case 'moveToDelayed':
+    getSpanOperation(shouldRetry, retryDelay) {
+        if (shouldRetry) {
+            if (retryDelay) {
                 return 'delay';
-            case 'retryJob':
-                return 'retry';
-            case 'moveToFinished':
-                return 'fail';
+            }
+            return 'retry';
         }
+        return 'fail';
     }
     /**
      * @returns true if the job has completed.
@@ -599,7 +637,20 @@ export class Job {
         }
     }
     /**
-     * Get this jobs children failure values if any.
+     * Retrieves the failures of child jobs that were explicitly ignored while using ignoreDependencyOnFailure option.
+     * This method is useful for inspecting which child jobs were intentionally ignored when an error occured.
+     * @see {@link https://docs.bullmq.io/guide/flows/ignore-dependency}
+     *
+     * @returns Object mapping children job keys with their failure values.
+     */
+    async getIgnoredChildrenFailures() {
+        const client = await this.queue.client;
+        return client.hgetall(this.toKey(`${this.id}:failed`));
+    }
+    /**
+     * Get job's children failure values that were ignored if any.
+     *
+     * @deprecated This method is deprecated and will be removed in v6. Use getIgnoredChildrenFailures instead.
      *
      * @returns Object mapping children job keys with their failure values.
      */
@@ -614,52 +665,108 @@ export class Job {
      * on processed/unprocessed dependencies, since v7.2 you must consider that count
      * won't have any effect until processed/unprocessed dependencies have a length
      * greater than 127
-     * @see https://redis.io/docs/management/optimization/memory-optimization/#redis--72
-     * @returns dependencies separated by processed and unprocessed.
+     * @see {@link https://redis.io/docs/management/optimization/memory-optimization/#redis--72}
+     * @see {@link https://docs.bullmq.io/guide/flows#getters}
+     * @returns dependencies separated by processed, unprocessed, ignored and failed.
      */
     async getDependencies(opts = {}) {
         const client = await this.queue.client;
         const multi = client.multi();
-        if (!opts.processed && !opts.unprocessed) {
+        if (!opts.processed && !opts.unprocessed && !opts.ignored && !opts.failed) {
             multi.hgetall(this.toKey(`${this.id}:processed`));
             multi.smembers(this.toKey(`${this.id}:dependencies`));
-            const [[err1, processed], [err2, unprocessed]] = (await multi.exec());
-            const transformedProcessed = parseObjectValues(processed);
-            return { processed: transformedProcessed, unprocessed };
+            multi.hgetall(this.toKey(`${this.id}:failed`));
+            multi.zrange(this.toKey(`${this.id}:unsuccessful`), 0, -1);
+            const [[err1, processed], [err2, unprocessed], [err3, ignored], [err4, failed],] = (await multi.exec());
+            return {
+                processed: parseObjectValues(processed),
+                unprocessed,
+                failed,
+                ignored,
+            };
         }
         else {
             const defaultOpts = {
                 cursor: 0,
                 count: 20,
             };
+            const childrenResultOrder = [];
             if (opts.processed) {
+                childrenResultOrder.push('processed');
                 const processedOpts = Object.assign(Object.assign({}, defaultOpts), opts.processed);
                 multi.hscan(this.toKey(`${this.id}:processed`), processedOpts.cursor, 'COUNT', processedOpts.count);
             }
             if (opts.unprocessed) {
+                childrenResultOrder.push('unprocessed');
                 const unprocessedOpts = Object.assign(Object.assign({}, defaultOpts), opts.unprocessed);
                 multi.sscan(this.toKey(`${this.id}:dependencies`), unprocessedOpts.cursor, 'COUNT', unprocessedOpts.count);
             }
-            const [result1, result2] = (await multi.exec());
-            const [processedCursor, processed = []] = opts.processed
-                ? result1[1]
-                : [];
-            const [unprocessedCursor, unprocessed = []] = opts.unprocessed
-                ? opts.processed
-                    ? result2[1]
-                    : result1[1]
-                : [];
-            const transformedProcessed = {};
-            for (let index = 0; index < processed.length; ++index) {
-                if (index % 2) {
-                    transformedProcessed[processed[index - 1]] = JSON.parse(processed[index]);
-                }
+            if (opts.ignored) {
+                childrenResultOrder.push('ignored');
+                const ignoredOpts = Object.assign(Object.assign({}, defaultOpts), opts.ignored);
+                multi.hscan(this.toKey(`${this.id}:failed`), ignoredOpts.cursor, 'COUNT', ignoredOpts.count);
             }
-            return Object.assign(Object.assign({}, (processedCursor
+            let failedCursor;
+            if (opts.failed) {
+                childrenResultOrder.push('failed');
+                const failedOpts = Object.assign(Object.assign({}, defaultOpts), opts.failed);
+                failedCursor = failedOpts.cursor + failedOpts.count;
+                multi.zrange(this.toKey(`${this.id}:unsuccessful`), failedOpts.cursor, failedOpts.count - 1);
+            }
+            const results = (await multi.exec());
+            let processedCursor, processed, unprocessedCursor, unprocessed, failed, ignoredCursor, ignored;
+            childrenResultOrder.forEach((key, index) => {
+                switch (key) {
+                    case 'processed': {
+                        processedCursor = results[index][1][0];
+                        const rawProcessed = results[index][1][1];
+                        const transformedProcessed = {};
+                        for (let ind = 0; ind < rawProcessed.length; ++ind) {
+                            if (ind % 2) {
+                                transformedProcessed[rawProcessed[ind - 1]] = JSON.parse(rawProcessed[ind]);
+                            }
+                        }
+                        processed = transformedProcessed;
+                        break;
+                    }
+                    case 'failed': {
+                        failed = results[index][1];
+                        break;
+                    }
+                    case 'ignored': {
+                        ignoredCursor = results[index][1][0];
+                        const rawIgnored = results[index][1][1];
+                        const transformedIgnored = {};
+                        for (let ind = 0; ind < rawIgnored.length; ++ind) {
+                            if (ind % 2) {
+                                transformedIgnored[rawIgnored[ind - 1]] = rawIgnored[ind];
+                            }
+                        }
+                        ignored = transformedIgnored;
+                        break;
+                    }
+                    case 'unprocessed': {
+                        unprocessedCursor = results[index][1][0];
+                        unprocessed = results[index][1][1];
+                        break;
+                    }
+                }
+            });
+            return Object.assign(Object.assign(Object.assign(Object.assign({}, (processedCursor
                 ? {
-                    processed: transformedProcessed,
+                    processed,
                     nextProcessedCursor: Number(processedCursor),
                 }
+                : {})), (ignoredCursor
+                ? {
+                    ignored,
+                    nextIgnoredCursor: Number(ignoredCursor),
+                }
+                : {})), (failedCursor
+                ? {
+                    failed,
+                    nextFailedCursor: failedCursor,
+                }
                 : {})), (unprocessedCursor
                 ? { unprocessed, nextUnprocessedCursor: Number(unprocessedCursor) }
                 : {}));
@@ -668,32 +775,24 @@ export class Job {
     /**
      * Get children job counts if this job is a parent and has children.
      *
-     * @returns dependencies count separated by processed and unprocessed.
+     * @returns dependencies count separated by processed, unprocessed, ignored and failed.
      */
     async getDependenciesCount(opts = {}) {
-        const client = await this.queue.client;
-        const multi = client.multi();
-        const updatedOpts = !opts.processed && !opts.unprocessed
-            ? { processed: true, unprocessed: true }
-            : opts;
-        if (updatedOpts.processed) {
-            multi.hlen(this.toKey(`${this.id}:processed`));
-        }
-        if (updatedOpts.unprocessed) {
-            multi.scard(this.toKey(`${this.id}:dependencies`));
-        }
-        const [[err1, result1] = [], [err2, result2] = []] = (await multi.exec());
-        const processed = updatedOpts.processed ? result1 : undefined;
-        const unprocessed = updatedOpts.unprocessed
-            ? updatedOpts.processed
-                ? result2
-                : result1
-            : undefined;
-        return Object.assign(Object.assign({}, (updatedOpts.processed
-            ? {
-                processed,
+        const types = [];
+        Object.entries(opts).forEach(([key, value]) => {
+            if (value) {
+                types.push(key);
             }
-            : {})), (updatedOpts.unprocessed ? { unprocessed } : {}));
+        });
+        const finalTypes = types.length
+            ? types
+            : ['processed', 'unprocessed', 'ignored', 'failed'];
+        const responses = await this.scripts.getDependencyCounts(this.id, finalTypes);
+        const counts = {};
+        responses.forEach((res, index) => {
+            counts[`${finalTypes[index]}`] = res || 0;
+        });
+        return counts;
     }
     /**
      * Returns a promise the resolves when the job has completed (containing the return value of the job),
@@ -799,6 +898,7 @@ export class Job {
     }
     /**
      * Marks a job to not be retried if it fails (even if attempts has been configured)
+     * @deprecated use UnrecoverableError
      */
     discard() {
         this.discarded = true;
@@ -825,6 +925,12 @@ export class Job {
     }
     validateOptions(jobData) {
         var _a;
+        const exclusiveOptions = [
+            'removeDependencyOnFailure',
+            'failParentOnFailure',
+            'continueParentOnFailure',
+            'ignoreDependencyOnFailure',
+        ];
         const exceedLimit = this.opts.sizeLimit &&
             lengthInUtf8Bytes(jobData.data) > this.opts.sizeLimit;
         if (exceedLimit) {
@@ -833,15 +939,10 @@ export class Job {
         if (this.opts.delay && this.opts.repeat && !((_a = this.opts.repeat) === null || _a === void 0 ? void 0 : _a.count)) {
             throw new Error(`Delay and repeat options could not be used together`);
         }
-        if (this.opts.removeDependencyOnFailure && this.opts.failParentOnFailure) {
-            throw new Error(`RemoveDependencyOnFailure and failParentOnFailure options can not be used together`);
-        }
-        if (this.opts.removeDependencyOnFailure &&
-            this.opts.ignoreDependencyOnFailure) {
-            throw new Error(`RemoveDependencyOnFailure and ignoreDependencyOnFailure options can not be used together`);
-        }
-        if (this.opts.failParentOnFailure && this.opts.ignoreDependencyOnFailure) {
-            throw new Error(`FailParentOnFailure and ignoreDependencyOnFailure options can not be used together`);
+        const enabledExclusiveOptions = exclusiveOptions.filter(opt => this.opts[opt]);
+        if (enabledExclusiveOptions.length > 1) {
+            const optionsList = enabledExclusiveOptions.join(', ');
+            throw new Error(`The following options cannot be used together: ${optionsList}`);
         }
         if (`${parseInt(this.id, 10)}` === this.id) {
             throw new Error('Custom Ids cannot be integers');
@@ -854,6 +955,12 @@ export class Job {
                 throw new Error(`Priority should be between 0 and ${PRIORITY_LIMIT}`);
             }
         }
+        if (typeof this.opts.backoff === 'object' &&
+            typeof this.opts.backoff.jitter === 'number') {
+            if (this.opts.backoff.jitter < 0 || this.opts.backoff.jitter > 1) {
+                throw new Error(`Jitter should be between 0 and 1`);
+            }
+        }
     }
     updateStacktrace(err) {
         this.stacktrace = this.stacktrace || [];

package/dist/node_modules/bullmq/dist/esm/classes/main-base.d.ts

@@ -1,4 +1,3 @@
-declare const _default: (send: (msg: any) => Promise<void>, receiver: {
-    on: (evt: 'message', cb: (msg: any) => void) => void;
-}) => void;
+import { Receiver } from '../interfaces';
+declare const _default: (send: (msg: any) => Promise<void>, receiver: Receiver) => void;
 export default _default;

package/dist/node_modules/bullmq/dist/esm/classes/main-base.js

@@ -6,7 +6,7 @@ import { ChildProcessor } from './child-processor';
 import { ParentCommand, ChildCommand } from '../enums';
 import { errorToJSON, toString } from '../utils';
 export default (send, receiver) => {
-    const childProcessor = new ChildProcessor(send);
+    const childProcessor = new ChildProcessor(send, receiver);
     receiver === null || receiver === void 0 ? void 0 : receiver.on('message', async (msg) => {
         try {
             switch (msg.cmd) {

package/dist/node_modules/bullmq/dist/esm/classes/queue-base.d.ts

@@ -8,10 +8,7 @@ import { KeysMap } from './queue-keys';
 import { Scripts } from './scripts';
 import { SpanKind } from '../enums';
 /**
- * @class QueueBase
- * @extends EventEmitter
- *
- * @description Base class for all classes that need to interact with queues.
+ * Base class for all classes that need to interact with queues.
  * This class is normally not used directly, but extended by the other classes.
  *
  */
@@ -38,7 +35,7 @@ export declare class QueueBase extends EventEmitter implements MinimalQueue {
      * Returns a promise that resolves to a redis client. Normally used only by subclasses.
      */
     get client(): Promise<RedisClient>;
-    protected setScripts(): void;
+    protected createScripts(): void;
     /**
      * Returns the version of the Redis instance the client is connected to,
      */

package/dist/node_modules/bullmq/dist/esm/classes/queue-base.js

@@ -1,14 +1,10 @@
 import { EventEmitter } from 'events';
-import { delay, DELAY_TIME_5, isNotConnectionError, isRedisInstance, trace, } from '../utils';
+import { createScripts, delay, DELAY_TIME_5, isNotConnectionError, isRedisInstance, trace, } from '../utils';
 import { RedisConnection } from './redis-connection';
 import { Job } from './job';
 import { QueueKeys } from './queue-keys';
-import { Scripts } from './scripts';
 /**
- * @class QueueBase
- * @extends EventEmitter
- *
- * @description Base class for all classes that need to interact with queues.
+ * Base class for all classes that need to interact with queues.
  * This class is normally not used directly, but extended by the other classes.
  *
  */
@@ -34,7 +30,12 @@ export class QueueBase extends EventEmitter {
         if (name.includes(':')) {
             throw new Error('Queue name cannot contain :');
         }
-        this.connection = new Connection(opts.connection, isRedisInstance(opts.connection), hasBlockingConnection, opts.skipVersionCheck);
+        this.connection = new Connection(opts.connection, {
+            shared: isRedisInstance(opts.connection),
+            blocking: hasBlockingConnection,
+            skipVersionCheck: opts.skipVersionCheck,
+            skipWaitingForReady: opts.skipWaitingForReady,
+        });
         this.connection.on('error', (error) => this.emit('error', error));
         this.connection.on('close', () => {
             if (!this.closing) {
@@ -45,7 +46,7 @@ export class QueueBase extends EventEmitter {
         this.qualifiedName = queueKeys.getQueueQualifiedName(name);
         this.keys = queueKeys.getKeys(name);
         this.toKey = (type) => queueKeys.toKey(name, type);
-        this.setScripts();
+        this.createScripts();
     }
     /**
      * Returns a promise that resolves to a redis client. Normally used only by subclasses.
@@ -53,8 +54,8 @@ export class QueueBase extends EventEmitter {
     get client() {
         return this.connection.client;
     }
-    setScripts() {
-        this.scripts = new Scripts(this);
+    createScripts() {
+        this.scripts = createScripts(this);
     }
     /**
      * Returns the version of the Redis instance the client is connected to,

package/dist/node_modules/bullmq/dist/esm/classes/queue-events-producer.d.ts

@@ -1,11 +1,11 @@
-import { QueueBaseOptions } from '../interfaces';
+import { QueueEventsProducerOptions } from '../interfaces';
 import { QueueBase } from './queue-base';
 import { RedisConnection } from './redis-connection';
 /**
  * The QueueEventsProducer class is used for publishing custom events.
  */
 export declare class QueueEventsProducer extends QueueBase {
-    constructor(name: string, opts?: QueueBaseOptions, Connection?: typeof RedisConnection);
+    constructor(name: string, opts?: QueueEventsProducerOptions, Connection?: typeof RedisConnection);
     /**
      * Publish custom event to be processed in QueueEvents.
      * @param argsObj - Event payload