bullmq 3.6.1 → 3.6.2

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

@@ -1,67 +0,0 @@
-/// <reference types="node" />
-import { EventEmitter } from 'events';
-import { QueueBaseOptions, RedisClient } from '../interfaces';
-import { MinimalQueue } from '../types';
-import { RedisConnection } from './redis-connection';
-import { Job } from './job';
-import { KeysMap } from './queue-keys';
-import { Scripts } from './scripts';
-/**
- * @class QueueBase
- * @extends EventEmitter
- *
- * @description Base class for all classes that need to interact with queues.
- * This class is normally not used directly, but extended by the other classes.
- *
- */
-export declare class QueueBase extends EventEmitter implements MinimalQueue {
-    readonly name: string;
-    opts: QueueBaseOptions;
-    toKey: (type: string) => string;
-    keys: KeysMap;
-    closing: Promise<void>;
-    protected scripts: Scripts;
-    protected connection: RedisConnection;
-    /**
-     *
-     * @param name - The name of the queue.
-     * @param opts - Options for the queue.
-     * @param Connection - An optional "Connection" class used to instantiate a Connection. This is useful for
-     * testing with mockups and/or extending the Connection class and passing an alternate implementation.
-     */
-    constructor(name: string, opts?: QueueBaseOptions, Connection?: typeof RedisConnection);
-    /**
-     * Returns a promise that resolves to a redis client. Normally used only by subclasses.
-     */
-    get client(): Promise<RedisClient>;
-    /**
-     * Returns the version of the Redis instance the client is connected to,
-     */
-    get redisVersion(): string;
-    /**
-     * Helper to easily extend Job class calls.
-     */
-    protected get Job(): typeof Job;
-    /**
-     * Emits an event. Normally used by subclasses to emit events.
-     *
-     * @param event - The emitted event.
-     * @param args -
-     * @returns
-     */
-    emit(event: string | symbol, ...args: any[]): boolean;
-    waitUntilReady(): Promise<RedisClient>;
-    protected base64Name(): string;
-    protected clientName(suffix?: string): string;
-    /**
-     *
-     * @returns Closes the connection and returns a promise that resolves when the connection is closed.
-     */
-    close(): Promise<void>;
-    /**
-     *
-     * Force disconnects a connection.
-     */
-    disconnect(): Promise<void>;
-    protected checkConnectionError<T>(fn: () => Promise<T>, delayInMs?: number): Promise<T>;
-}

package/dist/esm/classes/queue-events.d.ts

@@ -1,179 +0,0 @@
-import { IoredisListener, QueueEventsOptions } from '../interfaces';
-import { QueueBase } from './queue-base';
-import { RedisConnection } from './redis-connection';
-export interface QueueEventsListener extends IoredisListener {
-    /**
-     * Listen to 'active' event.
-     *
-     * This event is triggered when a job enters the 'active' state.
-     */
-    active: (args: {
-        jobId: string;
-        prev?: string;
-    }, id: string) => void;
-    /**
-     * Listen to 'added' event.
-     *
-     * This event is triggered when a job is created.
-     */
-    added: (args: {
-        jobId: string;
-        name: string;
-    }, id: string) => void;
-    /**
-     * Listen to 'cleaned' event.
-     *
-     * This event is triggered when a cleaned method is triggered.
-     */
-    cleaned: (args: {
-        count: string;
-    }, id: string) => void;
-    /**
-     * Listen to 'completed' event.
-     *
-     * This event is triggered when a job has successfully completed.
-     */
-    completed: (args: {
-        jobId: string;
-        returnvalue: string;
-        prev?: string;
-    }, id: string) => void;
-    /**
-     * Listen to 'delayed' event.
-     *
-     * This event is triggered when a job is delayed.
-     */
-    delayed: (args: {
-        jobId: string;
-        delay: number;
-    }, id: string) => void;
-    /**
-     * Listen to 'drained' event.
-     *
-     * This event is triggered when the queue has drained the waiting list.
-     * Note that there could still be delayed jobs waiting their timers to expire
-     * and this event will still be triggered as long as the waiting list has emptied.
-     */
-    drained: (id: string) => void;
-    /**
-     * Listen to 'duplicated' event.
-     *
-     * This event is triggered when a job is not created because it already exist.
-     */
-    duplicated: (args: {
-        jobId: string;
-    }, id: string) => void;
-    /**
-     * Listen to 'error' event.
-     *
-     * This event is triggered when an exception is thrown.
-     */
-    error: (args: Error) => void;
-    /**
-     * Listen to 'failed' event.
-     *
-     * This event is triggered when a job has thrown an exception.
-     */
-    failed: (args: {
-        jobId: string;
-        failedReason: string;
-        prev?: string;
-    }, id: string) => void;
-    /**
-     * Listen to 'paused' event.
-     *
-     * This event is triggered when a queue is paused.
-     */
-    paused: (args: {}, id: string) => void;
-    /**
-     * Listen to 'progress' event.
-     *
-     * This event is triggered when a job updates it progress, i.e. the
-     * Job##updateProgress() method is called. This is useful to notify
-     * progress or any other data from within a processor to the rest of the
-     * world.
-     */
-    progress: (args: {
-        jobId: string;
-        data: number | object;
-    }, id: string) => void;
-    /**
-     * Listen to 'removed' event.
-     *
-     * This event is triggered when a job has been manually
-     * removed from the queue.
-     */
-    removed: (args: {
-        jobId: string;
-        prev: string;
-    }, id: string) => void;
-    /**
-     * Listen to 'resumed' event.
-     *
-     * This event is triggered when a queue is resumed.
-     */
-    resumed: (args: {}, id: string) => void;
-    /**
-     * Listen to 'retries-exhausted' event.
-     *
-     * This event is triggered when a job has retried the maximum attempts.
-     */
-    'retries-exhausted': (args: {
-        jobId: string;
-        attemptsMade: string;
-    }, id: string) => void;
-    /**
-     * Listen to 'stalled' event.
-     *
-     * This event is triggered when a job has been moved from 'active' back
-     * to 'waiting'/'failed' due to the processor not being able to renew
-     * the lock on the said job.
-     */
-    stalled: (args: {
-        jobId: string;
-    }, id: string) => void;
-    /**
-     * Listen to 'waiting' event.
-     *
-     * This event is triggered when a job enters the 'waiting' state.
-     */
-    waiting: (args: {
-        jobId: string;
-        prev?: string;
-    }, id: string) => void;
-    /**
-     * Listen to 'waiting-children' event.
-     *
-     * This event is triggered when a job enters the 'waiting-children' state.
-     */
-    'waiting-children': (args: {
-        jobId: string;
-    }, id: string) => void;
-}
-/**
- * The QueueEvents class is used for listening to the global events
- * emitted by a given queue.
- *
- * This class requires a dedicated redis connection.
- *
- */
-export declare class QueueEvents extends QueueBase {
-    private running;
-    constructor(name: string, { connection, autorun, ...opts }?: QueueEventsOptions, Connection?: typeof RedisConnection);
-    emit<U extends keyof QueueEventsListener>(event: U, ...args: Parameters<QueueEventsListener[U]>): boolean;
-    off<U extends keyof QueueEventsListener>(eventName: U, listener: QueueEventsListener[U]): this;
-    on<U extends keyof QueueEventsListener>(event: U, listener: QueueEventsListener[U]): this;
-    once<U extends keyof QueueEventsListener>(event: U, listener: QueueEventsListener[U]): this;
-    /**
-     * Manually starts running the event consumming loop. This shall be used if you do not
-     * use the default "autorun" option on the constructor.
-     */
-    run(): Promise<void>;
-    private consumeEvents;
-    /**
-     * Stops consuming events and close the underlying Redis connection if necessary.
-     *
-     * @returns
-     */
-    close(): Promise<void>;
-}

package/dist/esm/classes/queue-getters.d.ts

@@ -1,164 +0,0 @@
-import { QueueBase } from './queue-base';
-import { Job } from './job';
-import { JobState, JobType } from '../types';
-import { Metrics } from '../interfaces';
-/**
- *
- * @class QueueGetters
- * @extends QueueBase
- *
- * @description Provides different getters for different aspects of a queue.
- */
-export declare class QueueGetters<DataType, ResultType, NameType extends string> extends QueueBase {
-    getJob(jobId: string): Promise<Job<DataType, ResultType, NameType> | undefined>;
-    private commandByType;
-    /**
-     * Helper to easily extend Job class calls.
-     */
-    protected get Job(): typeof Job;
-    private sanitizeJobTypes;
-    /**
-      Returns the number of jobs waiting to be processed. This includes jobs that are "waiting" or "delayed".
-    */
-    count(): Promise<number>;
-    /**
-     * 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
-     */
-    getJobCountByTypes(...types: JobType[]): Promise<number>;
-    /**
-     * Returns the job counts for each type specified or every list/set in the queue by default.
-     *
-     * @returns An object, key (type) and value (count)
-     */
-    getJobCounts(...types: JobType[]): Promise<{
-        [index: string]: number;
-    }>;
-    /**
-     * Get current job state.
-     *
-     * @returns Returns one of these values:
-     * 'completed', 'failed', 'delayed', 'active', 'waiting', 'waiting-children', 'unknown'.
-     */
-    getJobState(jobId: string): Promise<JobState | 'unknown'>;
-    /**
-     * Returns the number of jobs in completed status.
-     */
-    getCompletedCount(): Promise<number>;
-    /**
-     * Returns the number of jobs in failed status.
-     */
-    getFailedCount(): Promise<number>;
-    /**
-     * Returns the number of jobs in delayed status.
-     */
-    getDelayedCount(): Promise<number>;
-    /**
-     * Returns the number of jobs in active status.
-     */
-    getActiveCount(): Promise<number>;
-    /**
-     * Returns the number of jobs in waiting or paused statuses.
-     */
-    getWaitingCount(): Promise<number>;
-    /**
-     * Returns the number of jobs in waiting-children status.
-     */
-    getWaitingChildrenCount(): Promise<number>;
-    /**
-     * Returns the jobs that are in the "waiting" status.
-     * @param start - zero based index from where to start returning jobs.
-     * @param end - zero based index where to stop returning jobs.
-     */
-    getWaiting(start?: number, end?: number): Promise<Job<DataType, ResultType, NameType>[]>;
-    /**
-     * Returns the jobs that are in the "waiting" status.
-     * @param start - zero based index from where to start returning jobs.
-     * @param end - zero based index where to stop returning jobs.
-     */
-    getWaitingChildren(start?: number, end?: number): Promise<Job<DataType, ResultType, NameType>[]>;
-    /**
-     * Returns the jobs that are in the "active" status.
-     * @param start - zero based index from where to start returning jobs.
-     * @param end - zero based index where to stop returning jobs.
-     */
-    getActive(start?: number, end?: number): Promise<Job<DataType, ResultType, NameType>[]>;
-    /**
-     * Returns the jobs that are in the "delayed" status.
-     * @param start - zero based index from where to start returning jobs.
-     * @param end - zero based index where to stop returning jobs.
-     */
-    getDelayed(start?: number, end?: number): Promise<Job<DataType, ResultType, NameType>[]>;
-    /**
-     * Returns the jobs that are in the "completed" status.
-     * @param start - zero based index from where to start returning jobs.
-     * @param end - zero based index where to stop returning jobs.
-     */
-    getCompleted(start?: number, end?: number): Promise<Job<DataType, ResultType, NameType>[]>;
-    /**
-     * Returns the jobs that are in the "failed" status.
-     * @param start - zero based index from where to start returning jobs.
-     * @param end - zero based index where to stop returning jobs.
-     */
-    getFailed(start?: number, end?: number): Promise<Job<DataType, ResultType, NameType>[]>;
-    getRanges(types: JobType[], start?: number, end?: number, asc?: boolean): Promise<string[]>;
-    /**
-     * Returns the jobs that are on the given statuses (note that JobType is synonym for job status)
-     * @param types - the statuses of the jobs to return.
-     * @param start - zero based index from where to start returning jobs.
-     * @param end - zero based index where to stop returning jobs.
-     * @param asc - if true, the jobs will be returned in ascending order.
-     */
-    getJobs(types?: JobType[] | JobType, start?: number, end?: number, asc?: boolean): Promise<Job<DataType, ResultType, NameType>[]>;
-    /**
-     * Returns the logs for a given Job.
-     * @param jobId - the id of the job to get the logs for.
-     * @param start - zero based index from where to start returning jobs.
-     * @param end - zero based index where to stop returning jobs.
-     * @param asc - if true, the jobs will be returned in ascending order.
-     */
-    getJobLogs(jobId: string, start?: number, end?: number, asc?: boolean): Promise<{
-        logs: string[];
-        count: number;
-    }>;
-    private baseGetClients;
-    /**
-     * Get the worker list related to the queue. i.e. all the known
-     * workers that are available to process jobs for this queue.
-     * Note: GCP does not support SETNAME, so this call will not work
-     *
-     * @returns - Returns an array with workers info.
-     */
-    getWorkers(): Promise<{
-        [index: string]: string;
-    }[]>;
-    /**
-     * Get queue events list related to the queue.
-     * Note: GCP does not support SETNAME, so this call will not work
-     *
-     * @returns - Returns an array with queue events info.
-     */
-    getQueueEvents(): Promise<{
-        [index: string]: string;
-    }[]>;
-    /**
-     * Get queue metrics related to the queue.
-     *
-     * This method returns the gathered metrics for the queue.
-     * The metrics are represented as an array of job counts
-     * per unit of time (1 minute).
-     *
-     * @param start - Start point of the metrics, where 0
-     * is the newest point to be returned.
-     * @param end - End point of the metrics, where -1 is the
-     * oldest point to be returned.
-     *
-     * @returns - Returns an object with queue metrics.
-     */
-    getMetrics(type: 'completed' | 'failed', start?: number, end?: number): Promise<Metrics>;
-    private parseClientList;
-}

package/dist/esm/classes/queue-keys.d.ts

@@ -1,10 +0,0 @@
-export type KeysMap = {
-    [index in string]: string;
-};
-export declare class QueueKeys {
-    readonly prefix: string;
-    constructor(prefix?: string);
-    getKeys(name: string): KeysMap;
-    toKey(name: string, type: string): string;
-    getPrefixedQueueName(name: string): string;
-}

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

@@ -1,232 +0,0 @@
-import { BaseJobOptions, BulkJobOptions, IoredisListener, QueueOptions, RepeatOptions } from '../interfaces';
-import { FinishedStatus, JobsOptions } from '../types';
-import { Job } from './job';
-import { QueueGetters } from './queue-getters';
-import { Repeat } from './repeat';
-import { RedisConnection } from './redis-connection';
-export interface ObliterateOpts {
-    /**
-     * Use force = true to force obliteration even with active jobs in the queue
-     * @defaultValue false
-     */
-    force?: boolean;
-    /**
-     * Use count with the maximum number of deleted keys per iteration
-     * @defaultValue 1000
-     */
-    count?: number;
-}
-export interface QueueListener<DataType, ResultType, NameType extends string> extends IoredisListener {
-    /**
-     * Listen to 'cleaned' event.
-     *
-     * This event is triggered when the queue calls clean method.
-     */
-    cleaned: (jobs: string[], type: string) => void;
-    /**
-     * Listen to 'error' event.
-     *
-     * This event is triggered when an error is thrown.
-     */
-    error: (err: Error) => void;
-    /**
-     * Listen to 'paused' event.
-     *
-     * This event is triggered when the queue is paused.
-     */
-    paused: () => void;
-    /**
-     * Listen to 'progress' event.
-     *
-     * This event is triggered when the job updates its progress.
-     */
-    progress: (job: Job<DataType, ResultType, NameType>, progress: number | object) => void;
-    /**
-     * Listen to 'removed' event.
-     *
-     * This event is triggered when a job is removed.
-     */
-    removed: (job: Job<DataType, ResultType, NameType>) => void;
-    /**
-     * Listen to 'resumed' event.
-     *
-     * This event is triggered when the queue is resumed.
-     */
-    resumed: () => void;
-    /**
-     * Listen to 'waiting' event.
-     *
-     * This event is triggered when the queue creates a new job.
-     */
-    waiting: (job: Job<DataType, ResultType, NameType>) => void;
-}
-/**
- * Queue
- *
- * This class provides methods to add jobs to a queue and some othe high-level
- * administration such as pausing or deleting queues.
- *
- */
-export declare class Queue<DataType = any, ResultType = any, NameType extends string = string> extends QueueGetters<DataType, ResultType, NameType> {
-    token: string;
-    jobsOpts: BaseJobOptions;
-    private _repeat;
-    constructor(name: string, opts?: QueueOptions, Connection?: typeof RedisConnection);
-    emit<U extends keyof QueueListener<DataType, ResultType, NameType>>(event: U, ...args: Parameters<QueueListener<DataType, ResultType, NameType>[U]>): boolean;
-    off<U extends keyof QueueListener<DataType, ResultType, NameType>>(eventName: U, listener: QueueListener<DataType, ResultType, NameType>[U]): this;
-    on<U extends keyof QueueListener<DataType, ResultType, NameType>>(event: U, listener: QueueListener<DataType, ResultType, NameType>[U]): this;
-    once<U extends keyof QueueListener<DataType, ResultType, NameType>>(event: U, listener: QueueListener<DataType, ResultType, NameType>[U]): this;
-    /**
-     * Returns this instance current default job options.
-     */
-    get defaultJobOptions(): JobsOptions;
-    get repeat(): Promise<Repeat>;
-    /**
-     * 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 opts - Job options that affects how the job is going to be processed.
-     */
-    add(name: NameType, data: DataType, opts?: JobsOptions): Promise<Job<DataType, ResultType, NameType>>;
-    /**
-     * Adds an array of jobs to the queue. This method may be faster than adding
-     * 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'.
-     */
-    addBulk(jobs: {
-        name: NameType;
-        data: DataType;
-        opts?: BulkJobOptions;
-    }[]): Promise<Job<DataType, ResultType, NameType>[]>;
-    /**
-     * Pauses the processing of this queue globally.
-     *
-     * We use an atomic RENAME operation on the wait queue. Since
-     * we have blocking calls with BRPOPLPUSH on the wait queue, as long as the queue
-     * is renamed to 'paused', no new jobs will be processed (the current ones
-     * will run until finalized).
-     *
-     * Adding jobs requires a LUA script to check first if the paused list exist
-     * and in that case it will add it there instead of the wait list.
-     */
-    pause(): Promise<void>;
-    /**
-     * Close the queue instance.
-     *
-     */
-    close(): Promise<void>;
-    /**
-     * Resumes the processing of this queue globally.
-     *
-     * The method reverses the pause operation by resuming the processing of the
-     * queue.
-     */
-    resume(): Promise<void>;
-    /**
-     * Returns true if the queue is currently paused.
-     */
-    isPaused(): Promise<boolean>;
-    /**
-     * Get all repeatable meta jobs.
-     *
-     * @param start - Offset of first job to return.
-     * @param end - Offset of last job to return.
-     * @param asc - Determine the order in which jobs are returned based on their
-     * next execution time.
-     */
-    getRepeatableJobs(start?: number, end?: number, asc?: boolean): Promise<{
-        key: string;
-        name: string;
-        id: string;
-        endDate: number;
-        tz: string;
-        pattern: string;
-        next: number;
-    }[]>;
-    /**
-     * Removes a repeatable job.
-     *
-     * Note: you need to use the exact same repeatOpts when deleting a repeatable job
-     * than when adding it.
-     *
-     * @see removeRepeatableByKey
-     *
-     * @param name -
-     * @param repeatOpts -
-     * @param jobId -
-     * @returns
-     */
-    removeRepeatable(name: NameType, repeatOpts: RepeatOptions, jobId?: string): Promise<boolean>;
-    /**
-     * Removes a repeatable job by its key. Note that the key is the one used
-     * to store the repeatable job metadata and not one of the job iterations
-     * themselves. You can use "getRepeatableJobs" in order to get the keys.
-     *
-     * @see getRepeatableJobs
-     *
-     * @param key - to the repeatable job.
-     * @returns
-     */
-    removeRepeatableByKey(key: string): Promise<boolean>;
-    /**
-     * Removes the given job from the queue as well as all its
-     * dependencies.
-     *
-     * @param jobId - The id of the job to remove
-     * @returns 1 if it managed to remove the job or 0 if the job or
-     * any of its dependencies were locked.
-     */
-    remove(jobId: string): Promise<number>;
-    /**
-     * Drains the queue, i.e., removes all jobs that are waiting
-     * or delayed, but not active, completed or failed.
-     *
-     * @param delayed - Pass true if it should also clean the
-     * delayed jobs.
-     */
-    drain(delayed?: boolean): Promise<void>;
-    /**
-     * Cleans jobs from a queue. Similar to drain but keeps jobs within a certain
-     * grace period.
-     *
-     * @param grace - The grace period
-     * @param limit - Max number of jobs to clean
-     * @param type - The type of job to clean
-     * Possible values are completed, wait, active, paused, delayed, failed. Defaults to completed.
-     * @returns Id jobs from the deleted records
-     */
-    clean(grace: number, limit: number, type?: 'completed' | 'wait' | 'active' | 'paused' | 'delayed' | 'failed'): Promise<string[]>;
-    /**
-     * Completely destroys the queue and all of its contents irreversibly.
-     * This method will the *pause* the queue and requires that there are no
-     * active jobs. It is possible to bypass this requirement, i.e. not
-     * having active jobs using the "force" option.
-     *
-     * Note: This operation requires to iterate on all the jobs stored in the queue
-     * and can be slow for very large queues.
-     *
-     * @param opts - Obliterate options.
-     */
-    obliterate(opts?: ObliterateOpts): Promise<void>;
-    /**
-     * Retry all the failed jobs.
-     *
-     * @param opts - contains number to limit how many jobs will be moved to wait status per iteration,
-     * state (failed, completed) failed by default or from which timestamp.
-     * @returns
-     */
-    retryJobs(opts?: {
-        count?: number;
-        state?: FinishedStatus;
-        timestamp?: number;
-    }): Promise<void>;
-    /**
-     * Trim the event stream to an approximately maxLength.
-     *
-     * @param maxLength -
-     */
-    trimEvents(maxLength: number): Promise<number>;
-}

package/dist/esm/classes/redis-connection.d.ts

@@ -1,38 +0,0 @@
-/// <reference types="node" />
-import { EventEmitter } from 'events';
-import { ConnectionOptions, RedisClient } from '../interfaces';
-export interface RawCommand {
-    content: string;
-    name: string;
-    keys: number;
-}
-export declare class RedisConnection extends EventEmitter {
-    private readonly shared;
-    private readonly blocking;
-    static minimumVersion: string;
-    static recommendedMinimumVersion: string;
-    closing: boolean;
-    protected _client: RedisClient;
-    private readonly opts;
-    private initializing;
-    private version;
-    private handleClientError;
-    private handleClientClose;
-    private handleClientReady;
-    constructor(opts?: ConnectionOptions, shared?: boolean, blocking?: boolean);
-    private checkBlockingOptions;
-    private checkUpstashHost;
-    /**
-     * Waits for a redis client to be ready.
-     * @param redis - client
-     */
-    static waitUntilReady(client: RedisClient): Promise<void>;
-    get client(): Promise<RedisClient>;
-    protected loadCommands(providedScripts?: Record<string, RawCommand>): void;
-    private init;
-    disconnect(): Promise<void>;
-    reconnect(): Promise<void>;
-    close(): Promise<void>;
-    private getRedisVersion;
-    get redisVersion(): string;
-}