Class Queue3<T>

constructor

• new Queue3<T>(name, opts?): Queue3<T>

• This is the Queue constructor. It creates a new Queue that is persisted in Redis. Every time the same queue is instantiated it tries to process all the old jobs that may exist from a previous unfinished session.

  Type Parameters

  • T = any

  Parameters

  • name: string
  • Optional opts: CommonOptions

  Returns Queue3<T>

name

queueEvents

add

• add(jobName, data, opts?): Promise<Job<any, any, string>>

• Parameters

  • jobName: string
  • data: any
  • Optional opts: JobsOptions

  Returns Promise<Job<any, any, string>>

base64Name

• base64Name(): string

• Returns Queue name in base64 encoded format

  Returns string

clean

• clean(grace, limit, type?): Promise<string[]>

• Tells the queue remove all jobs created outside of a grace period in milliseconds. You can clean the jobs with the following states: completed, wait (typo for waiting), active, delayed, and failed.

  Parameters

  • grace: number

    Grace period in milliseconds.
  • limit: number

    Maximum amount of jobs to clean per call. If not provided will clean all matching jobs.
  • type: "wait" | "completed" | "failed" | "active" | "delayed" | "paused" = 'completed'

    Status of the job to clean. Values are completed, wait, active, paused, delayed, and failed. Defaults to completed.

  Returns Promise<string[]>

clientName

• clientName(): string

• Returns Queue name with keyPrefix (default: 'bull')

  Returns string

close

• close(): Promise<any>

• Closes the underlying redis client. Use this to perform a graceful shutdown.

  close can be called from anywhere, with one caveat: if called from within a job handler the queue won't close until after the job has been processed

  Returns Promise<any>

count

• count(): Promise<number>

• Returns a promise that returns the number of jobs in the queue, waiting or paused. Since there may be other processes adding or processing jobs, this value may be true only for a very small amount of time.

  Returns Promise<number>

detachListener

• detachListener(event, listener?): Queue3<T>

• Parameters

  • event: string | symbol
  • Optional listener: ((...args) => void)
    • • (...args): void

      • Parameters

        • Rest ...args: any[]

        Returns void

  Returns Queue3<T>

empty

• empty(): Promise<void>

• Empties a queue deleting all the input lists and associated jobs.

  Returns Promise<void>

getActive

• getActive(start?, end?): Promise<Job<any, any, string>[]>

• Returns a promise that will return an array with the active jobs between start and end.

  Parameters

  • start: number = 0
  • end: number = -1

  Returns Promise<Job<any, any, string>[]>

getActiveCount

• getActiveCount(): Promise<number>

• Returns a promise that resolves with the quantity of active jobs.

  Returns Promise<number>

getCompleted

• getCompleted(start?, end?): Promise<Job<any, any, string>[]>

• Returns a promise that will return an array with the completed jobs between start and end.

  Parameters

  • start: number = 0
  • end: number = -1

  Returns Promise<Job<any, any, string>[]>

getCompletedCount

• getCompletedCount(): Promise<number>

• Returns a promise that resolves with the quantity of completed jobs.

  Returns Promise<number>

getDelayed

• getDelayed(start?, end?): Promise<Job<any, any, string>[]>

• Returns a promise that will return an array with the delayed jobs between start and end.

  Parameters

  • start: number = 0
  • end: number = -1

  Returns Promise<Job<any, any, string>[]>

getDelayedCount

• getDelayedCount(): Promise<number>

• Returns a promise that resolves with the quantity of delayed jobs.

  Returns Promise<number>

getFailed

• getFailed(start?, end?): Promise<Job<any, any, string>[]>

• Returns a promise that will return an array with the failed jobs between start and end.

  Parameters

  • start: number = 0
  • end: number = -1

  Returns Promise<Job<any, any, string>[]>

getFailedCount

• getFailedCount(): Promise<number>

• Returns a promise that resolves with the quantity of failed jobs.

  Returns Promise<number>

getJob

• getJob(jobId): Promise<Job<any, any, string>>

• Returns a promise that will return the job instance associated with the jobId parameter. If the specified job cannot be located, the promise callback parameter will be set to null.

  Parameters

  • jobId: string

  Returns Promise<Job<any, any, string>>

getJobCountByTypes

• getJobCountByTypes(...types): Promise<number>

• Returns a promise that resolves with the job counts for the given queue of the given types.

  Parameters

  • Rest ...types: JobType[]

  Returns Promise<number>

getJobCounts

• getJobCounts(...types): Promise<{
      [index: string]: number;
  }>

• Returns a promise that resolves with the job counts for the given queue.

  Parameters

  • Rest ...types: JobType[]

  Returns Promise<{
      [index: string]: number;
  }>

getJobLogs

• getJobLogs(jobId, start?, end?): Promise<{
      count: number;
      logs: string[];
  }>

• Returns a object with the logs according to the start and end arguments. The returned count value is the total amount of logs, useful for implementing pagination.

  Parameters

  • jobId: string
  • start: number = 0
  • end: number = -1

  Returns Promise<{
      count: number;
      logs: string[];
  }>

getJobs

• getJobs(types, start?, end?, asc?): Promise<Job<any, any, string>[]>

• Returns a promise that will return an array of job instances of the given types. Optional parameters for range and ordering are provided.

  Parameters

  • types: JobType | JobType[]
  • start: number = 0
  • end: number = -1
  • asc: boolean = false

  Returns Promise<Job<any, any, string>[]>

getNextJob

• getNextJob(): Promise<Job<any, any, string>>

• Returns Promise<Job<any, any, string>>

getPausedCount

• getPausedCount(): Promise<number>

• Returns a promise that resolves with the quantity of paused jobs.

  Returns Promise<number>

getRepeatableCount

• getRepeatableCount(): Promise<number>

• Returns a promise that resolves to the quantity of repeatable jobs.

  Returns Promise<number>

getRepeatableJobs

• getRepeatableJobs(start?, end?, asc?): Promise<JobInformation3[]>

• Returns JobInformation of repeatable jobs (ordered descending). Provide a start and/or an end index to limit the number of results. Start defaults to 0, end to -1 and asc to false.

  Parameters

  • start: number = 0
  • end: number = -1
  • asc: boolean = false

  Returns Promise<JobInformation3[]>

getWaiting

• getWaiting(start?, end?): Promise<Job<any, any, string>[]>

• Returns a promise that will return an array with the waiting jobs between start and end.

  Parameters

  • start: number = 0
  • end: number = -1

  Returns Promise<Job<any, any, string>[]>

getWaitingCount

• getWaitingCount(): Promise<number>

• Returns a promise that resolves with the quantity of waiting jobs.

  Returns Promise<number>

getWorkers

• getWorkers(): Promise<{
      [key: string]: string;
  }[]>

• Returns Redis clients array which belongs to current Queue

  Returns Promise<{
      [key: string]: string;
  }[]>

isReady

• isReady(): Promise<Queue3<T>>

• Returns a promise that resolves when Redis is connected and the queue is ready to accept jobs. This replaces the ready event emitted on Queue in previous versions.

  Returns Promise<Queue3<T>>

isWorkerPaused

• isWorkerPaused(): boolean

• Returns boolean

nextRepeatableJob

• nextRepeatableJob(name, data, opts?, skipCheckExists?): Promise<Job<any, any, string>>

• ???

  Parameters

  • name: string
  • data: any
  • Optional opts: JobsOptions
  • Optional skipCheckExists: boolean

  Returns Promise<Job<any, any, string>>

off

• off(event, listener?): Queue3<T>

• Parameters

  • event: string | symbol
  • Optional listener: ((...args) => void)
    • • (...args): void

      • Parameters

        • Rest ...args: any[]

        Returns void

  Returns Queue3<T>

on

• on(event, callback): Queue3<T>

• Listens to queue events

  Parameters

  • event: string
  • callback: ((...args) => void)
    • • (...args): void

      • Parameters

        • Rest ...args: any[]

        Returns void

  Returns Queue3<T>
• on(event, callback): Queue3<T>

• An error occurred

  Parameters

  • event: "error"
  • callback: ErrorEventCallback3

  Returns Queue3<T>
• on(event, callback): Queue3<T>

• A Job is waiting to be processed as soon as a worker is idling.

  Parameters

  • event: "waiting"
  • callback: WaitingEventCallback3

  Returns Queue3<T>
• on(event, callback): Queue3<T>

• A job has started. You can use jobPromise.cancel() to abort it

  Parameters

  • event: "active"
  • callback: ActiveEventCallback3<T>

  Returns Queue3<T>
• on(event, callback): Queue3<T>

• A job has been marked as stalled. This is useful for debugging job workers that crash or pause the event loop.

  Parameters

  • event: "stalled"
  • callback: StalledEventCallback3<T>

  Returns Queue3<T>
• on(event, callback): Queue3<T>

• A job's progress was updated

  Parameters

  • event: "progress"
  • callback: ProgressEventCallback3<T>

  Returns Queue3<T>
• on(event, callback): Queue3<T>

• A job successfully completed with a result

  Parameters

  • event: "completed"
  • callback: CompletedEventCallback3<T>

  Returns Queue3<T>
• on(event, callback): Queue3<T>

• A job failed with err as the reason

  Parameters

  • event: "failed"
  • callback: FailedEventCallback3<T>

  Returns Queue3<T>
• on(event, callback): Queue3<T>

• The queue has been paused

  Parameters

  • event: "paused"
  • callback: EventCallback3

  Returns Queue3<T>
• on(event, callback): Queue3<T>

• The queue has been resumed

  Parameters

  • event: "resumed"
  • callback: EventCallback3

  Returns Queue3<T>
• on(event, callback): Queue3<T>

• A job successfully removed.

  Parameters

  • event: "removed"
  • callback: RemovedEventCallback3<T>

  Returns Queue3<T>
• on(event, callback): Queue3<T>

• Old jobs have been cleaned from the queue. jobs is an array of jobs that were removed, and type is the type of those jobs.

  Parameters

  • event: "cleaned"
  • callback: CleanedEventCallback3<T>

  Returns Queue3<T>

  See

  Queue#clean() for details

• on(event, callback): Queue3<T>

• Emitted every time the queue has processed all the waiting jobs (even if there can be some delayed jobs not yet processed)

  Parameters

  • event: "drained"
  • callback: EventCallback3

  Returns Queue3<T>

once

• once(event, listener): Queue3<T>

• Parameters

  • event: string | symbol
  • listener: ((...args) => void)
    • • (...args): void

      • Parameters

        • Rest ...args: any[]

        Returns void

  Returns Queue3<T>

parseClientList

• parseClientList(list): {
      [key: string]: string;
  }[]

• Returns Redis clients array which belongs to current Queue from string with all redis clients

  Parameters

  • list: string

    String with all redis clients

  Returns {
      [key: string]: string;
  }[]

pause

• pause(): Promise<void>

• Returns a promise that resolves when the queue is paused.

  A paused queue will not process new jobs until resumed, but current jobs being processed will continue until they are finalized. The pause can be either global or local. If global, all workers in all queue instances for a given queue will be paused. If local, just this worker will stop processing new jobs after the current lock expires. This can be useful to stop a worker from taking new jobs prior to shutting down.

  Pausing a queue that is already paused does nothing.

  Returns Promise<void>

pauseWorker

• pauseWorker(doNotWaitActive?): Promise<void>

• Parameters

  • Optional doNotWaitActive: boolean

  Returns Promise<void>

process

• process(processor): Promise<void>

• Defines a processing function for the jobs placed into a given Queue.

  The callback is called every time a job is placed in the queue. It is passed an instance of the job as first argument.

  If the callback signature contains the second optional done argument, the callback will be passed a done callback to be called after the job has been completed. The done callback can be called with an Error instance, to signal that the job did not complete successfully, or with a result as second argument (e.g.: done(null, result);) when the job is successful. Errors will be passed as a second argument to the "failed" event; results, as a second argument to the "completed" event.

  If, however, the callback signature does not contain the done argument, a promise must be returned to signal job completion. If the promise is rejected, the error will be passed as a second argument to the "failed" event. If it is resolved, its value will be the "completed" event's second argument.

  Parameters

  • processor: string | Processor<T, any, string>

  Returns Promise<void>

removeAllListeners

• removeAllListeners(event): Queue3<T>

• Parameters

  • event: string | symbol

  Returns Queue3<T>

removeListener

• removeListener(event, listener): Queue3<T>

• Parameters

  • event: string | symbol
  • listener: ((...args) => void)
    • • (...args): void

      • Parameters

        • Rest ...args: any[]

        Returns void

  Returns Queue3<T>

removeRepeatable

• removeRepeatable(name, opts): Promise<boolean>

• Removes a given repeatable job. The RepeatOptions and JobId needs to be the same as the ones used for the job when it was added.

  name: The name of the to be removed job

  Parameters

  • name: string
  • opts: RepeatOptions

  Returns Promise<boolean>

removeRepeatableByKey

• removeRepeatableByKey(repeatJobKey): Promise<void>

• Removes a given repeatable job by key.

  Parameters

  • repeatJobKey: string

  Returns Promise<void>

resume

• resume(): Promise<void>

• Returns a promise that resolves when the queue is resumed after being paused.

  The resume can be either local or global. If global, all workers in all queue instances for a given queue will be resumed. If local, only this worker will be resumed. Note that resuming a queue globally will not resume workers that have been paused locally; for those, resume(true) must be called directly on their instances.

  Resuming a queue that is not paused does nothing.

  Returns Promise<void>

resumeWorker

• resumeWorker(): Promise<void>

• Returns Promise<void>

retryJob

• retryJob(job): Promise<void>

• Parameters

  • job: Job<any, any, string>

  Returns Promise<void>

setWorkerName

• setWorkerName(): Promise<any>

• Set clientName to Redis.client

  Returns Promise<any>