@tachybase/plugin-adapter-bullmq 1.3.17 → 1.3.19

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

@@ -5,20 +5,9 @@ const tslib_1 = require("tslib");
 const util_1 = require("util");
 const utils_1 = require("../utils");
 const backoffs_1 = require("./backoffs");
-const scripts_1 = require("./scripts");
 const unrecoverable_error_1 = require("./errors/unrecoverable-error");
 const enums_1 = require("../enums");
 const logger = (0, util_1.debuglog)('bull');
-// Simple options decode map.
-const optsDecodeMap = {
-    de: 'deduplication',
-    fpof: 'failParentOnFailure',
-    idof: 'ignoreDependencyOnFailure',
-    kl: 'keepLogs',
-    rdof: 'removeDependencyOnFailure',
-};
-const optsEncodeMap = Object.assign(Object.assign({}, (0, utils_1.invertObject)(optsDecodeMap)), { 
-    /*/ Legacy for backwards compatibility */ debounce: 'de' });
 exports.PRIORITY_LIMIT = 2 ** 21;
 /**
  * Job
@@ -28,7 +17,6 @@ exports.PRIORITY_LIMIT = 2 ** 21;
  *
  * A Job instance is also passed to the Worker's process function.
  *
- * @class Job
  */
 class Job {
     constructor(queue, 
@@ -86,6 +74,11 @@ 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 = tslib_1.__rest(_a, ["repeatJobKey"]);
         this.opts = Object.assign({
             attempts: 0,
@@ -96,15 +89,27 @@ class Job {
         this.timestamp = opts.timestamp ? opts.timestamp : Date.now();
         this.opts.backoff = backoffs_1.Backoffs.normalize(opts.backoff);
         this.parentKey = (0, utils_1.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;
     }
     /**
@@ -170,6 +175,7 @@ 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);
@@ -184,9 +190,15 @@ 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);
@@ -205,17 +217,17 @@ class Job {
         }
         return job;
     }
-    setScripts() {
-        this.scripts = new scripts_1.Scripts(this.queue);
+    createScripts() {
+        this.scripts = (0, utils_1.createScripts)(this.queue);
     }
-    static optsFromJSON(rawOpts) {
+    static optsFromJSON(rawOpts, optsDecode = utils_1.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 {
@@ -252,10 +264,10 @@ 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.
      */
@@ -282,6 +294,7 @@ class Job {
             progress: this.progress,
             attemptsMade: this.attemptsMade,
             attemptsStarted: this.attemptsStarted,
+            stalledCounter: this.stalledCounter,
             finishedOn: this.finishedOn,
             processedOn: this.processedOn,
             timestamp: this.timestamp,
@@ -294,16 +307,16 @@ class Job {
             nrjid: this.nextRepeatableJobId,
         });
     }
-    static optsAsJSON(opts = {}) {
+    static optsAsJSON(opts = {}, optsEncode = utils_1.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 {
@@ -402,6 +415,18 @@ 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.
      *
@@ -421,19 +446,35 @@ 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 = (0, utils_1.tryCatch)(JSON.stringify, JSON, [
-            returnValue,
-        ]);
-        if (stringifiedReturnValue === utils_1.errorObject) {
-            throw utils_1.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(enums_1.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 = (0, utils_1.tryCatch)(JSON.stringify, JSON, [
+                returnValue,
+            ]);
+            if (stringifiedReturnValue === utils_1.errorObject) {
+                throw utils_1.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 &&
@@ -457,7 +498,9 @@ class Job {
      */
     async moveToFailed(err, token, fetchNext = false) {
         this.failedReason = err === null || err === void 0 ? void 0 : err.message;
-        return this.queue.trace(enums_1.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(enums_1.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) {
@@ -470,11 +513,7 @@ 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
@@ -502,15 +541,14 @@ 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.
@@ -602,7 +640,20 @@ 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.
      */
@@ -617,52 +668,108 @@ 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 = (0, utils_1.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: (0, utils_1.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) }
                 : {}));
@@ -671,32 +778,24 @@ 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),
@@ -802,6 +901,7 @@ 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;
@@ -828,6 +928,12 @@ class Job {
     }
     validateOptions(jobData) {
         var _a;
+        const exclusiveOptions = [
+            'removeDependencyOnFailure',
+            'failParentOnFailure',
+            'continueParentOnFailure',
+            'ignoreDependencyOnFailure',
+        ];
         const exceedLimit = this.opts.sizeLimit &&
             (0, utils_1.lengthInUtf8Bytes)(jobData.data) > this.opts.sizeLimit;
         if (exceedLimit) {
@@ -836,15 +942,10 @@ 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');
@@ -857,6 +958,12 @@ class Job {
                 throw new Error(`Priority should be between 0 and ${exports.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/cjs/classes/main-base.js

@@ -8,7 +8,7 @@ const child_processor_1 = require("./child-processor");
 const enums_1 = require("../enums");
 const utils_1 = require("../utils");
 exports.default = (send, receiver) => {
-    const childProcessor = new child_processor_1.ChildProcessor(send);
+    const childProcessor = new child_processor_1.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/cjs/classes/queue-base.js

@@ -6,12 +6,8 @@ const utils_1 = require("../utils");
 const redis_connection_1 = require("./redis-connection");
 const job_1 = require("./job");
 const queue_keys_1 = require("./queue-keys");
-const scripts_1 = require("./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.
  *
  */
@@ -37,7 +33,12 @@ class QueueBase extends events_1.EventEmitter {
         if (name.includes(':')) {
             throw new Error('Queue name cannot contain :');
         }
-        this.connection = new Connection(opts.connection, (0, utils_1.isRedisInstance)(opts.connection), hasBlockingConnection, opts.skipVersionCheck);
+        this.connection = new Connection(opts.connection, {
+            shared: (0, utils_1.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) {
@@ -48,7 +49,7 @@ class QueueBase extends events_1.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.
@@ -56,8 +57,8 @@ class QueueBase extends events_1.EventEmitter {
     get client() {
         return this.connection.client;
     }
-    setScripts() {
-        this.scripts = new scripts_1.Scripts(this);
+    createScripts() {
+        this.scripts = (0, utils_1.createScripts)(this);
     }
     /**
      * Returns the version of the Redis instance the client is connected to,

package/dist/node_modules/bullmq/dist/cjs/classes/queue-getters.js

@@ -5,11 +5,7 @@ exports.QueueGetters = void 0;
 const queue_base_1 = require("./queue-base");
 const utils_1 = require("../utils");
 /**
- *
- * @class QueueGetters
- * @extends QueueBase
- *
- * @description Provides different getters for different aspects of a queue.
+ * Provides different getters for different aspects of a queue.
  */
 class QueueGetters extends queue_base_1.QueueBase {
     getJob(jobId) {
@@ -95,10 +91,10 @@ class QueueGetters extends queue_base_1.QueueBase {
     /**
      * Job counts by type
      *
-     * Queue#getJobCountByTypes('completed') => completed count
-     * Queue#getJobCountByTypes('completed,failed') => completed + failed count
-     * Queue#getJobCountByTypes('completed', 'failed') => completed + failed count
-     * Queue#getJobCountByTypes('completed', 'waiting', 'failed') => completed + waiting + failed count
+     * Queue#getJobCountByTypes('completed') =\> completed count
+     * Queue#getJobCountByTypes('completed,failed') =\> completed + failed count
+     * Queue#getJobCountByTypes('completed', 'failed') =\> completed + failed count
+     * Queue#getJobCountByTypes('completed', 'waiting', 'failed') =\> completed + waiting + failed count
      */
     async getJobCountByTypes(...types) {
         const result = await this.getJobCounts(...types);
@@ -249,11 +245,12 @@ class QueueGetters extends queue_base_1.QueueBase {
      * A qualified job id is a string representing the job id in a given queue,
      * for example: "bull:myqueue:jobid".
      *
-     * @param parentId The id of the parent job
-     * @param type "processed" | "pending"
-     * @param opts
+     * @param parentId - The id of the parent job
+     * @param type - "processed" | "pending"
+     * @param opts - Options for the query.
      *
-     * @returns  { items: { id: string, v?: any, err?: string } [], jobs: JobJsonRaw[], total: number}
+     * @returns an object with the following shape:
+     * `{ items: { id: string, v?: any, err?: string } [], jobs: JobJsonRaw[], total: number}`
      */
     async getDependencies(parentId, type, start, end) {
         const key = this.toKey(type == 'processed'
@@ -425,7 +422,7 @@ class QueueGetters extends queue_base_1.QueueBase {
         };
     }
     parseClientList(list, matcher) {
-        const lines = list.split('\n');
+        const lines = list.split(/\r?\n/);
         const clients = [];
         lines.forEach((line) => {
             const client = {};
@@ -445,6 +442,29 @@ class QueueGetters extends queue_base_1.QueueBase {
         });
         return clients;
     }
+    /**
+     * Export the metrics for the queue in the Prometheus format.
+     * Automatically exports all the counts returned by getJobCounts().
+     *
+     * @returns - Returns a string with the metrics in the Prometheus format.
+     *
+     * @see {@link https://prometheus.io/docs/instrumenting/exposition_formats/}
+     *
+     **/
+    async exportPrometheusMetrics(globalVariables) {
+        const counts = await this.getJobCounts();
+        const metrics = [];
+        // Match the test's expected HELP text
+        metrics.push('# HELP bullmq_job_count Number of jobs in the queue by state');
+        metrics.push('# TYPE bullmq_job_count gauge');
+        const variables = !globalVariables
+            ? ''
+            : Object.keys(globalVariables).reduce((acc, curr) => `${acc}, ${curr}="${globalVariables[curr]}"`, '');
+        for (const [state, count] of Object.entries(counts)) {
+            metrics.push(`bullmq_job_count{queue="${this.name}", state="${state}"${variables}} ${count}`);
+        }
+        return metrics.join('\n');
+    }
 }
 exports.QueueGetters = QueueGetters;
 //# sourceMappingURL=queue-getters.js.map