bullmq 1.81.4 → 1.82.2

package/dist/esm/classes/scripts.d.ts

@@ -1,10 +1,9 @@
 /**
  * Includes all the scripts needed by the queue and jobs.
  */
+/// <reference types="node" />
 import { JobJson, JobJsonRaw, JobsOptions, RedisClient, KeepJobs } from '../interfaces';
 import { JobState, FinishedStatus, FinishedPropValAttribute } from '../types';
-import { Worker } from './worker';
-import { QueueScheduler } from './queue-scheduler';
 import { QueueBase } from './queue-base';
 import { Job, MoveToChildrenOpts } from './job';
 export declare type MinimalQueue = Pick<QueueBase, 'name' | 'client' | 'toKey' | 'keys' | 'opts' | 'closing' | 'waitUntilReady' | 'removeListener' | 'emit' | 'on' | 'redisVersion'>;
@@ -15,29 +14,31 @@ export declare type ParentOpts = {
 };
 export declare type JobData = [JobJsonRaw | number, string?];
 export declare class Scripts {
-    static isJobInList(queue: MinimalQueue, listKey: string, jobId: string): Promise<boolean>;
-    static addJob(client: RedisClient, queue: MinimalQueue, job: JobJson, opts: JobsOptions, jobId: string, parentOpts?: ParentOpts): Promise<string>;
-    static pause(queue: MinimalQueue, pause: boolean): Promise<void>;
-    static removeRepeatableArgs(queue: MinimalQueue, repeatJobId: string, repeatJobKey: string): string[];
-    static removeRepeatable(queue: MinimalQueue, repeatJobId: string, repeatJobKey: string): Promise<void>;
-    static remove(queue: MinimalQueue, jobId: string): Promise<number>;
-    static extendLock(queue: MinimalQueue, jobId: string, token: string, duration: number): Promise<number>;
-    static updateData<T = any, R = any, N extends string = string>(queue: MinimalQueue, job: Job<T, R, N>, data: T): Promise<void>;
-    static updateProgress<T = any, R = any, N extends string = string>(queue: MinimalQueue, job: Job<T, R, N>, progress: number | object): Promise<void>;
-    static moveToFinishedArgs<T = any, R = any, N extends string = string>(queue: MinimalQueue, job: Job<T, R, N>, val: any, propVal: FinishedPropValAttribute, shouldRemove: boolean | number | KeepJobs, target: FinishedStatus, token: string, fetchNext?: boolean): string[];
-    private static moveToFinished;
-    static finishedErrors(code: number, jobId: string, command: string, state?: string): Error;
-    static drainArgs(queue: MinimalQueue, delayed: boolean): (string | number)[];
-    static drain(queue: MinimalQueue, delayed: boolean): Promise<void>;
-    static moveToCompleted<T = any, R = any, N extends string = string>(queue: MinimalQueue, job: Job<T, R, N>, returnvalue: R, removeOnComplete: boolean | number | KeepJobs, token: string, fetchNext: boolean): Promise<JobData | []>;
-    static moveToFailedArgs<T = any, R = any, N extends string = string>(queue: MinimalQueue, job: Job<T, R, N>, failedReason: string, removeOnFailed: boolean | number | KeepJobs, token: string, fetchNext?: boolean): string[];
-    static isFinished(queue: MinimalQueue, jobId: string, returnValue?: boolean): Promise<number | [number, string]>;
-    static getState(queue: MinimalQueue, jobId: string): Promise<JobState | 'unknown'>;
-    static changeDelay(queue: MinimalQueue, jobId: string, delay: number): Promise<void>;
-    static changeDelayArgs(queue: MinimalQueue, jobId: string, timestamp: number): string[];
-    static moveToDelayedArgs(queue: MinimalQueue, jobId: string, timestamp: number, token: string): string[];
-    static moveToWaitingChildrenArgs(queue: MinimalQueue, jobId: string, token: string, opts?: MoveToChildrenOpts): string[];
-    static moveToDelayed(queue: MinimalQueue, jobId: string, timestamp: number, token?: string): Promise<void>;
+    protected queue: MinimalQueue;
+    constructor(queue: MinimalQueue);
+    isJobInList(listKey: string, jobId: string): Promise<boolean>;
+    addJob(client: RedisClient, job: JobJson, opts: JobsOptions, jobId: string, parentOpts?: ParentOpts): Promise<string>;
+    pause(pause: boolean): Promise<void>;
+    private removeRepeatableArgs;
+    removeRepeatable(repeatJobId: string, repeatJobKey: string): Promise<number>;
+    remove(jobId: string): Promise<number>;
+    extendLock(jobId: string, token: string, duration: number): Promise<number>;
+    updateData<T = any, R = any, N extends string = string>(job: Job<T, R, N>, data: T): Promise<void>;
+    updateProgress<T = any, R = any, N extends string = string>(job: Job<T, R, N>, progress: number | object): Promise<void>;
+    protected moveToFinishedArgs<T = any, R = any, N extends string = string>(job: Job<T, R, N>, val: any, propVal: FinishedPropValAttribute, shouldRemove: boolean | number | KeepJobs, target: FinishedStatus, token: string, fetchNext?: boolean): (string | number | boolean | Buffer)[];
+    protected moveToFinished<DataType = any, ReturnType = any, NameType extends string = string>(job: Job<DataType, ReturnType, NameType>, val: any, propVal: FinishedPropValAttribute, shouldRemove: boolean | number | KeepJobs, target: FinishedStatus, token: string, fetchNext: boolean): Promise<JobData | []>;
+    finishedErrors(code: number, jobId: string, command: string, state?: string): Error;
+    private drainArgs;
+    drain(delayed: boolean): Promise<void>;
+    moveToCompleted<T = any, R = any, N extends string = string>(job: Job<T, R, N>, returnvalue: R, removeOnComplete: boolean | number | KeepJobs, token: string, fetchNext: boolean): Promise<JobData | []>;
+    moveToFailedArgs<T = any, R = any, N extends string = string>(job: Job<T, R, N>, failedReason: string, removeOnFailed: boolean | number | KeepJobs, token: string, fetchNext?: boolean): (string | number | boolean | Buffer)[];
+    isFinished(jobId: string, returnValue?: boolean): Promise<number | [number, string]>;
+    getState(jobId: string): Promise<JobState | 'unknown'>;
+    changeDelay(jobId: string, delay: number): Promise<void>;
+    private changeDelayArgs;
+    moveToDelayedArgs(jobId: string, timestamp: number, token: string): string[];
+    moveToWaitingChildrenArgs(jobId: string, token: string, opts?: MoveToChildrenOpts): string[];
+    moveToDelayed(jobId: string, timestamp: number, token?: string): Promise<void>;
     /**
      * Move parent job to waiting-children state.
      *
@@ -49,16 +50,16 @@ export declare class Scripts {
      * @throws JobNotInState
      * This exception is thrown if job is not in active state.
      */
-    static moveToWaitingChildren(queue: MinimalQueue, jobId: string, token: string, opts?: MoveToChildrenOpts): Promise<boolean>;
+    moveToWaitingChildren(jobId: string, token: string, opts?: MoveToChildrenOpts): Promise<boolean>;
     /**
      * Remove jobs in a specific state.
      *
      * @returns Id jobs from the deleted records.
      */
-    static cleanJobsInSet(queue: MinimalQueue, set: string, timestamp: number, limit?: number): Promise<string[]>;
-    static retryJobArgs<T = any, R = any, N extends string = string>(queue: MinimalQueue, job: Job<T, R, N>): string[];
-    private static retryJobsArgs;
-    static retryJobs(queue: MinimalQueue, state?: FinishedStatus, count?: number, timestamp?: number): Promise<number>;
+    cleanJobsInSet(set: string, timestamp: number, limit?: number): Promise<string[]>;
+    retryJobArgs<T = any, R = any, N extends string = string>(job: Job<T, R, N>): string[];
+    protected retryJobsArgs(state: FinishedStatus, count: number, timestamp: number): (string | number)[];
+    retryJobs(state?: FinishedStatus, count?: number, timestamp?: number): Promise<number>;
     /**
      * Attempts to reprocess a job
      *
@@ -73,14 +74,14 @@ export declare class Scripts {
      * -1 means the job is currently locked and can't be retried.
      * -2 means the job was not found in the expected set
      */
-    static reprocessJob<T = any, R = any, N extends string = string>(queue: MinimalQueue, job: Job<T, R, N>, state: 'failed' | 'completed'): Promise<void>;
-    static moveToActive<T, R, N extends string>(worker: Worker<T, R, N>, token: string, jobId?: string): Promise<[] | [number | JobJsonRaw, string?]>;
+    reprocessJob<T = any, R = any, N extends string = string>(job: Job<T, R, N>, state: 'failed' | 'completed'): Promise<void>;
+    moveToActive<T, R, N extends string>(token: string, jobId?: string): Promise<[] | [number | JobJsonRaw, string?]>;
     /**
      * It checks if the job in the top of the delay set should be moved back to the
      * top of the  wait queue (so that it will be processed as soon as possible)
      */
-    static updateDelaySet(queue: MinimalQueue, delayedTimestamp: number): Promise<[number, string]>;
-    static promote(queue: MinimalQueue, jobId: string): Promise<number>;
+    updateDelaySet(delayedTimestamp: number): Promise<[number, string]>;
+    promote(jobId: string): Promise<number>;
     /**
      * Looks for unlocked jobs in the active queue.
      *
@@ -90,8 +91,8 @@ export declare class Scripts {
      * (e.g. if the job handler keeps crashing),
      * we limit the number stalled job recoveries to settings.maxStalledCount.
      */
-    static moveStalledJobsToWait(queue: QueueScheduler): Promise<any>;
-    static obliterate(queue: MinimalQueue, opts: {
+    moveStalledJobsToWait(): Promise<any>;
+    obliterate(opts: {
         force: boolean;
         count: number;
     }): Promise<number>;

package/dist/esm/classes/scripts.js

@@ -13,10 +13,13 @@ import * as semver from 'semver';
 import { ErrorCode } from '../enums';
 import { array2obj, getParentKey } from '../utils';
 export class Scripts {
-    static async isJobInList(queue, listKey, jobId) {
-        const client = await queue.client;
+    constructor(queue) {
+        this.queue = queue;
+    }
+    async isJobInList(listKey, jobId) {
+        const client = await this.queue.client;
         let result;
-        if (semver.lt(queue.redisVersion, '6.0.6')) {
+        if (semver.lt(this.queue.redisVersion, '6.0.6')) {
             result = await client.isJobInList([listKey, jobId]);
         }
         else {
@@ -24,12 +27,12 @@ export class Scripts {
         }
         return Number.isInteger(result);
     }
-    static async addJob(client, queue, job, opts, jobId, parentOpts = {
+    async addJob(client, job, opts, jobId, parentOpts = {
         parentKey: null,
         waitChildrenKey: null,
         parentDependenciesKey: null,
     }) {
-        const queueKeys = queue.keys;
+        const queueKeys = this.queue.keys;
         const keys = [
             queueKeys.wait,
             queueKeys.paused,
@@ -71,68 +74,68 @@ export class Scripts {
         }
         return result;
     }
-    static async pause(queue, pause) {
-        const client = await queue.client;
+    async pause(pause) {
+        const client = await this.queue.client;
         let src = 'wait', dst = 'paused';
         if (!pause) {
             src = 'paused';
             dst = 'wait';
         }
-        const keys = [src, dst, 'meta'].map((name) => queue.toKey(name));
-        keys.push(queue.keys.events);
+        const keys = [src, dst, 'meta'].map((name) => this.queue.toKey(name));
+        keys.push(this.queue.keys.events);
         return client.pause(keys.concat([pause ? 'paused' : 'resumed']));
     }
-    static removeRepeatableArgs(queue, repeatJobId, repeatJobKey) {
-        const queueKeys = queue.keys;
+    removeRepeatableArgs(repeatJobId, repeatJobKey) {
+        const queueKeys = this.queue.keys;
         const keys = [queueKeys.repeat, queueKeys.delayed];
         const args = [repeatJobId, repeatJobKey, queueKeys['']];
         return keys.concat(args);
     }
-    static async removeRepeatable(queue, repeatJobId, repeatJobKey) {
-        const client = await queue.client;
-        const args = this.removeRepeatableArgs(queue, repeatJobId, repeatJobKey);
+    async removeRepeatable(repeatJobId, repeatJobKey) {
+        const client = await this.queue.client;
+        const args = this.removeRepeatableArgs(repeatJobId, repeatJobKey);
         return client.removeRepeatable(args);
     }
-    static async remove(queue, jobId) {
-        const client = await queue.client;
-        const keys = [jobId].map(name => queue.toKey(name));
+    async remove(jobId) {
+        const client = await this.queue.client;
+        const keys = [jobId].map(name => this.queue.toKey(name));
         return client.removeJob(keys.concat([jobId]));
     }
-    static async extendLock(queue, jobId, token, duration) {
-        const client = await queue.client;
+    async extendLock(jobId, token, duration) {
+        const client = await this.queue.client;
         const args = [
-            queue.toKey(jobId) + ':lock',
-            queue.keys.stalled,
+            this.queue.toKey(jobId) + ':lock',
+            this.queue.keys.stalled,
             token,
             duration,
             jobId,
         ];
         return client.extendLock(args);
     }
-    static async updateData(queue, job, data) {
-        const client = await queue.client;
-        const keys = [queue.toKey(job.id)];
+    async updateData(job, data) {
+        const client = await this.queue.client;
+        const keys = [this.queue.toKey(job.id)];
         const dataJson = JSON.stringify(data);
         const result = await client.updateData(keys.concat([dataJson]));
         if (result < 0) {
             throw this.finishedErrors(result, job.id, 'updateData');
         }
     }
-    static async updateProgress(queue, job, progress) {
-        const client = await queue.client;
-        const keys = [queue.toKey(job.id), queue.keys.events];
+    async updateProgress(job, progress) {
+        const client = await this.queue.client;
+        const keys = [this.queue.toKey(job.id), this.queue.keys.events];
         const progressJson = JSON.stringify(progress);
         const result = await client.updateProgress(keys.concat([job.id, progressJson]));
         if (result < 0) {
             throw this.finishedErrors(result, job.id, 'updateProgress');
         }
-        queue.emit('progress', job, progress);
+        this.queue.emit('progress', job, progress);
     }
-    static moveToFinishedArgs(queue, job, val, propVal, shouldRemove, target, token, fetchNext = true) {
+    moveToFinishedArgs(job, val, propVal, shouldRemove, target, token, fetchNext = true) {
         var _a, _b, _c;
-        const queueKeys = queue.keys;
-        const opts = queue.opts;
-        const metricsKey = queue.toKey(`metrics:${target}`);
+        const queueKeys = this.queue.keys;
+        const opts = this.queue.opts;
+        const metricsKey = this.queue.toKey(`metrics:${target}`);
         const keys = [
             queueKeys.wait,
             queueKeys.active,
@@ -143,7 +146,7 @@ export class Scripts {
             queueKeys.delayed,
             queueKeys.delay,
             queueKeys[target],
-            queue.toKey(job.id),
+            this.queue.toKey(job.id),
             queueKeys.meta,
             metricsKey,
         ];
@@ -159,7 +162,7 @@ export class Scripts {
             typeof val === 'undefined' ? 'null' : val,
             target,
             JSON.stringify({ jobId: job.id, val: val }),
-            !fetchNext || queue.closing ? 0 : 1,
+            !fetchNext || this.queue.closing ? 0 : 1,
             queueKeys[''],
             pack({
                 token,
@@ -177,9 +180,9 @@ export class Scripts {
         ];
         return keys.concat(args);
     }
-    static async moveToFinished(queue, job, val, propVal, shouldRemove, target, token, fetchNext) {
-        const client = await queue.client;
-        const args = this.moveToFinishedArgs(queue, job, val, propVal, shouldRemove, target, token, fetchNext);
+    async moveToFinished(job, val, propVal, shouldRemove, target, token, fetchNext) {
+        const client = await this.queue.client;
+        const args = this.moveToFinishedArgs(job, val, propVal, shouldRemove, target, token, fetchNext);
         const result = await client.moveToFinished(args);
         if (result < 0) {
             throw this.finishedErrors(result, job.id, 'finished', 'active');
@@ -188,7 +191,7 @@ export class Scripts {
             return raw2jobData(result);
         }
     }
-    static finishedErrors(code, jobId, command, state) {
+    finishedErrors(code, jobId, command, state) {
         switch (code) {
             case ErrorCode.JobNotExist:
                 return new Error(`Missing key for job ${jobId}. ${command}`);
@@ -202,8 +205,8 @@ export class Scripts {
                 return new Error(`Missing key for parent job ${jobId}. ${command}`);
         }
     }
-    static drainArgs(queue, delayed) {
-        const queueKeys = queue.keys;
+    drainArgs(delayed) {
+        const queueKeys = this.queue.keys;
         const keys = [
             queueKeys.wait,
             queueKeys.paused,
@@ -213,26 +216,26 @@ export class Scripts {
         const args = [queueKeys['']];
         return keys.concat(args);
     }
-    static async drain(queue, delayed) {
-        const client = await queue.client;
-        const args = this.drainArgs(queue, delayed);
+    async drain(delayed) {
+        const client = await this.queue.client;
+        const args = this.drainArgs(delayed);
         return client.drain(args);
     }
-    static moveToCompleted(queue, job, returnvalue, removeOnComplete, token, fetchNext) {
-        return this.moveToFinished(queue, job, returnvalue, 'returnvalue', removeOnComplete, 'completed', token, fetchNext);
+    moveToCompleted(job, returnvalue, removeOnComplete, token, fetchNext) {
+        return this.moveToFinished(job, returnvalue, 'returnvalue', removeOnComplete, 'completed', token, fetchNext);
     }
-    static moveToFailedArgs(queue, job, failedReason, removeOnFailed, token, fetchNext = false) {
-        return this.moveToFinishedArgs(queue, job, failedReason, 'failedReason', removeOnFailed, 'failed', token, fetchNext);
+    moveToFailedArgs(job, failedReason, removeOnFailed, token, fetchNext = false) {
+        return this.moveToFinishedArgs(job, failedReason, 'failedReason', removeOnFailed, 'failed', token, fetchNext);
     }
-    static async isFinished(queue, jobId, returnValue = false) {
-        const client = await queue.client;
-        const keys = ['completed', 'failed', jobId].map(function (key) {
-            return queue.toKey(key);
+    async isFinished(jobId, returnValue = false) {
+        const client = await this.queue.client;
+        const keys = ['completed', 'failed', jobId].map((key) => {
+            return this.queue.toKey(key);
         });
         return client.isFinished(keys.concat([jobId, returnValue ? '1' : '']));
     }
-    static async getState(queue, jobId) {
-        const client = await queue.client;
+    async getState(jobId) {
+        const client = await this.queue.client;
         const keys = [
             'completed',
             'failed',
@@ -241,24 +244,24 @@ export class Scripts {
             'wait',
             'paused',
             'waiting-children',
-        ].map(function (key) {
-            return queue.toKey(key);
+        ].map((key) => {
+            return this.queue.toKey(key);
         });
-        if (semver.lt(queue.redisVersion, '6.0.6')) {
+        if (semver.lt(this.queue.redisVersion, '6.0.6')) {
             return client.getState(keys.concat([jobId]));
         }
         return client.getStateV2(keys.concat([jobId]));
     }
-    static async changeDelay(queue, jobId, delay) {
-        const client = await queue.client;
+    async changeDelay(jobId, delay) {
+        const client = await this.queue.client;
         const delayTimestamp = Date.now() + delay;
-        const args = this.changeDelayArgs(queue, jobId, delayTimestamp);
+        const args = this.changeDelayArgs(jobId, delayTimestamp);
         const result = await client.changeDelay(args);
         if (result < 0) {
             throw this.finishedErrors(result, jobId, 'changeDelay', 'delayed');
         }
     }
-    static changeDelayArgs(queue, jobId, timestamp) {
+    changeDelayArgs(jobId, timestamp) {
         //
         // Bake in the job id first 12 bits into the timestamp
         // to guarantee correct execution order of delayed jobs
@@ -270,14 +273,14 @@ export class Scripts {
         if (timestamp > 0) {
             timestamp = timestamp * 0x1000 + (+jobId & 0xfff);
         }
-        const keys = ['delayed', jobId].map(function (name) {
-            return queue.toKey(name);
+        const keys = ['delayed', jobId].map(name => {
+            return this.queue.toKey(name);
         });
-        keys.push.apply(keys, [queue.keys.events, queue.keys.delay]);
+        keys.push.apply(keys, [this.queue.keys.events, this.queue.keys.delay]);
         return keys.concat([JSON.stringify(timestamp), jobId]);
     }
     // Note: We have an issue here with jobs using custom job ids
-    static moveToDelayedArgs(queue, jobId, timestamp, token) {
+    moveToDelayedArgs(jobId, timestamp, token) {
         //
         // Bake in the job id first 12 bits into the timestamp
         // to guarantee correct execution order of delayed jobs
@@ -289,21 +292,21 @@ export class Scripts {
         if (timestamp > 0) {
             timestamp = timestamp * 0x1000 + (+jobId & 0xfff);
         }
-        const keys = ['active', 'delayed', jobId].map(function (name) {
-            return queue.toKey(name);
+        const keys = ['active', 'delayed', jobId].map(name => {
+            return this.queue.toKey(name);
         });
-        keys.push.apply(keys, [queue.keys.events, queue.keys.delay]);
+        keys.push.apply(keys, [this.queue.keys.events, this.queue.keys.delay]);
         return keys.concat([JSON.stringify(timestamp), jobId, token]);
     }
-    static moveToWaitingChildrenArgs(queue, jobId, token, opts) {
+    moveToWaitingChildrenArgs(jobId, token, opts) {
         var _a;
         let timestamp = Math.max(0, (_a = opts.timestamp) !== null && _a !== void 0 ? _a : 0);
         const childKey = getParentKey(opts.child);
         if (timestamp > 0) {
             timestamp = timestamp * 0x1000 + (+jobId & 0xfff);
         }
-        const keys = [`${jobId}:lock`, 'active', 'waiting-children', jobId].map(function (name) {
-            return queue.toKey(name);
+        const keys = [`${jobId}:lock`, 'active', 'waiting-children', jobId].map(name => {
+            return this.queue.toKey(name);
         });
         return keys.concat([
             token,
@@ -312,9 +315,9 @@ export class Scripts {
             jobId,
         ]);
     }
-    static async moveToDelayed(queue, jobId, timestamp, token = '0') {
-        const client = await queue.client;
-        const args = this.moveToDelayedArgs(queue, jobId, timestamp, token);
+    async moveToDelayed(jobId, timestamp, token = '0') {
+        const client = await this.queue.client;
+        const args = this.moveToDelayedArgs(jobId, timestamp, token);
         const result = await client.moveToDelayed(args);
         if (result < 0) {
             throw this.finishedErrors(result, jobId, 'moveToDelayed', 'active');
@@ -331,9 +334,9 @@ export class Scripts {
      * @throws JobNotInState
      * This exception is thrown if job is not in active state.
      */
-    static async moveToWaitingChildren(queue, jobId, token, opts = {}) {
-        const client = await queue.client;
-        const args = this.moveToWaitingChildrenArgs(queue, jobId, token, opts);
+    async moveToWaitingChildren(jobId, token, opts = {}) {
+        const client = await this.queue.client;
+        const args = this.moveToWaitingChildrenArgs(jobId, token, opts);
         const result = await client.moveToWaitingChildren(args);
         switch (result) {
             case 0:
@@ -349,39 +352,39 @@ export class Scripts {
      *
      * @returns Id jobs from the deleted records.
      */
-    static async cleanJobsInSet(queue, set, timestamp, limit = 0) {
-        const client = await queue.client;
+    async cleanJobsInSet(set, timestamp, limit = 0) {
+        const client = await this.queue.client;
         return client.cleanJobsInSet([
-            queue.toKey(set),
-            queue.toKey('events'),
-            queue.toKey(''),
+            this.queue.toKey(set),
+            this.queue.toKey('events'),
+            this.queue.toKey(''),
             timestamp,
             limit,
             set,
         ]);
     }
-    static retryJobArgs(queue, job) {
+    retryJobArgs(job) {
         const jobId = job.id;
-        const keys = ['active', 'wait', jobId].map(function (name) {
-            return queue.toKey(name);
+        const keys = ['active', 'wait', jobId].map(name => {
+            return this.queue.toKey(name);
         });
-        keys.push(queue.keys.events);
+        keys.push(this.queue.keys.events);
         const pushCmd = (job.opts.lifo ? 'R' : 'L') + 'PUSH';
         return keys.concat([pushCmd, jobId]);
     }
-    static retryJobsArgs(queue, state, count, timestamp) {
+    retryJobsArgs(state, count, timestamp) {
         const keys = [
-            queue.toKey(''),
-            queue.keys.events,
-            queue.toKey(state),
-            queue.toKey('wait'),
+            this.queue.toKey(''),
+            this.queue.keys.events,
+            this.queue.toKey(state),
+            this.queue.toKey('wait'),
         ];
         const args = [count, timestamp];
         return keys.concat(args);
     }
-    static async retryJobs(queue, state = 'failed', count = 1000, timestamp = new Date().getTime()) {
-        const client = await queue.client;
-        const args = this.retryJobsArgs(queue, state, count, timestamp);
+    async retryJobs(state = 'failed', count = 1000, timestamp = new Date().getTime()) {
+        const client = await this.queue.client;
+        const args = this.retryJobsArgs(state, count, timestamp);
         return client.retryJobs(args);
     }
     /**
@@ -398,13 +401,13 @@ export class Scripts {
      * -1 means the job is currently locked and can't be retried.
      * -2 means the job was not found in the expected set
      */
-    static async reprocessJob(queue, job, state) {
-        const client = await queue.client;
+    async reprocessJob(job, state) {
+        const client = await this.queue.client;
         const keys = [
-            queue.toKey(job.id),
-            queue.keys.events,
-            queue.toKey(state),
-            queue.toKey('wait'),
+            this.queue.toKey(job.id),
+            this.queue.keys.events,
+            this.queue.toKey(state),
+            this.queue.toKey('wait'),
         ];
         const args = [
             job.id,
@@ -419,10 +422,10 @@ export class Scripts {
                 throw this.finishedErrors(result, job.id, 'reprocessJob', state);
         }
     }
-    static async moveToActive(worker, token, jobId) {
-        const client = await worker.client;
-        const opts = worker.opts;
-        const queueKeys = worker.keys;
+    async moveToActive(token, jobId) {
+        const client = await this.queue.client;
+        const opts = this.queue.opts;
+        const queueKeys = this.queue.keys;
         const keys = [
             queueKeys.wait,
             queueKeys.active,
@@ -457,30 +460,30 @@ export class Scripts {
      * It checks if the job in the top of the delay set should be moved back to the
      * top of the  wait queue (so that it will be processed as soon as possible)
      */
-    static async updateDelaySet(queue, delayedTimestamp) {
-        const client = await queue.client;
+    async updateDelaySet(delayedTimestamp) {
+        const client = await this.queue.client;
         const keys = [
-            queue.keys.delayed,
-            queue.keys.wait,
-            queue.keys.priority,
-            queue.keys.paused,
-            queue.keys.meta,
-            queue.keys.events,
-            queue.keys.delay,
+            this.queue.keys.delayed,
+            this.queue.keys.wait,
+            this.queue.keys.priority,
+            this.queue.keys.paused,
+            this.queue.keys.meta,
+            this.queue.keys.events,
+            this.queue.keys.delay,
         ];
-        const args = [queue.toKey(''), delayedTimestamp];
+        const args = [this.queue.toKey(''), delayedTimestamp];
         return client.updateDelaySet(keys.concat(args));
     }
-    static async promote(queue, jobId) {
-        const client = await queue.client;
+    async promote(jobId) {
+        const client = await this.queue.client;
         const keys = [
-            queue.keys.delayed,
-            queue.keys.wait,
-            queue.keys.paused,
-            queue.keys.priority,
-            queue.keys.events,
+            this.queue.keys.delayed,
+            this.queue.keys.wait,
+            this.queue.keys.paused,
+            this.queue.keys.priority,
+            this.queue.keys.events,
         ];
-        const args = [queue.toKey(''), jobId];
+        const args = [this.queue.toKey(''), jobId];
         return client.promote(keys.concat(args));
     }
     /**
@@ -492,30 +495,33 @@ export class Scripts {
      * (e.g. if the job handler keeps crashing),
      * we limit the number stalled job recoveries to settings.maxStalledCount.
      */
-    static async moveStalledJobsToWait(queue) {
-        const client = await queue.client;
-        const opts = queue.opts;
+    async moveStalledJobsToWait() {
+        const client = await this.queue.client;
+        const opts = this.queue.opts;
         const keys = [
-            queue.keys.stalled,
-            queue.keys.wait,
-            queue.keys.active,
-            queue.keys.failed,
-            queue.keys['stalled-check'],
-            queue.keys.meta,
-            queue.keys.paused,
-            queue.keys.events,
+            this.queue.keys.stalled,
+            this.queue.keys.wait,
+            this.queue.keys.active,
+            this.queue.keys.failed,
+            this.queue.keys['stalled-check'],
+            this.queue.keys.meta,
+            this.queue.keys.paused,
+            this.queue.keys.events,
         ];
         const args = [
             opts.maxStalledCount,
-            queue.toKey(''),
+            this.queue.toKey(''),
             Date.now(),
             opts.stalledInterval,
         ];
         return client.moveStalledJobsToWait(keys.concat(args));
     }
-    static async obliterate(queue, opts) {
-        const client = await queue.client;
-        const keys = [queue.keys.meta, queue.toKey('')];
+    async obliterate(opts) {
+        const client = await this.queue.client;
+        const keys = [
+            this.queue.keys.meta,
+            this.queue.toKey(''),
+        ];
         const args = [opts.count, opts.force ? 'force' : null];
         const result = await client.obliterate(keys.concat(args));
         if (result < 0) {