Class Queue<DataType, ReturnType, NameType>

closing

jobsOpts

keys

Readonly name

opts

Readonly qualifiedName

toKey

token

client

• get client(): Promise<RedisClient>

• Returns a promise that resolves to a redis client. Normally used only by subclasses.

  Returns Promise<RedisClient>

defaultJobOptions

• get defaultJobOptions(): JobsOptions

• Returns this instance current default job options.

  Returns JobsOptions

redisVersion

• get redisVersion(): string

• Returns the version of the Redis instance the client is connected to,

  Returns string

repeat

• get repeat(): Promise<Repeat>

• Returns Promise<Repeat>

addJobLog

• addJobLog(jobId, logRow, keepLogs?): Promise<number>

• Logs one row of job's log data.

  Parameters

  • jobId: string

    The job id to log against.

  • logRow: string

    string with log data to be logged.

  • Optional keepLogs: number

    max number of log entries to keep (0 for unlimited).

  Returns Promise<number>

  The total number of log entries for this job so far.

clean

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

• Cleans jobs from a queue. Similar to drain but keeps jobs within a certain grace period.

  Parameters

  • grace: number

    The grace period

  • limit: number

    Max number of jobs to clean

  • Optional type: "completed" | "failed" | "wait" | "active" | "delayed" | "prioritized" | "paused"

    The type of job to clean Possible values are completed, wait, active, paused, delayed, failed. Defaults to completed.

  Returns Promise<string[]>

  Id jobs from the deleted records

close

• close(): Promise<void>

• Close the queue instance.

  Returns Promise<void>

count

• count(): Promise<number>

• Returns the number of jobs waiting to be processed. This includes jobs that are "waiting" or "delayed" or "prioritized" or "waiting-children".

  Returns Promise<number>

disconnect

• disconnect(): Promise<void>

• Force disconnects a connection.

  Returns Promise<void>

drain

• drain(delayed?): Promise<void>

• Drains the queue, i.e., removes all jobs that are waiting or delayed, but not active, completed or failed.

  Parameters

  • Optional delayed: boolean

    Pass true if it should also clean the delayed jobs.

  Returns Promise<void>

emit

• emit<U>(event, ...args): boolean

• Type Parameters

  • U extends keyof QueueListener<DataType, ResultType, NameType>

  Parameters

  • event: U

  • Rest ...args: Parameters<QueueListener<DataType, ReturnType, NameType>[U]>

  Returns boolean

getActive

• getActive(start?, end?): Promise<Job<DataType, ReturnType, NameType>[]>

• Returns the jobs that are in the "active" status.

  Parameters

  • Optional start: number

    zero based index from where to start returning jobs.

  • Optional end: number

    zero based index where to stop returning jobs.

  Returns Promise<Job<DataType, ReturnType, NameType>[]>

getActiveCount

• getActiveCount(): Promise<number>

• Returns the number of jobs in active status.

  Returns Promise<number>

getCompleted

• getCompleted(start?, end?): Promise<Job<DataType, ReturnType, NameType>[]>

• Returns the jobs that are in the "completed" status.

  Parameters

  • Optional start: number

    zero based index from where to start returning jobs.

  • Optional end: number

    zero based index where to stop returning jobs.

  Returns Promise<Job<DataType, ReturnType, NameType>[]>

getCompletedCount

• getCompletedCount(): Promise<number>

• Returns the number of jobs in completed status.

  Returns Promise<number>

getDelayed

• getDelayed(start?, end?): Promise<Job<DataType, ReturnType, NameType>[]>

• Returns the jobs that are in the "delayed" status.

  Parameters

  • Optional start: number

    zero based index from where to start returning jobs.

  • Optional end: number

    zero based index where to stop returning jobs.

  Returns Promise<Job<DataType, ReturnType, NameType>[]>

getDelayedCount

• getDelayedCount(): Promise<number>

• Returns the number of jobs in delayed status.

  Returns Promise<number>

getDependencies

• getDependencies(parentId, type, start, end): Promise<{
      items: {
          err?: string;
          id: string;
          v?: any;
      }[];
      jobs: JobJsonRaw[];
      total: number;
  }>

• Returns the qualified job ids and the raw job data (if available) of the children jobs of the given parent job. It is possible to get either the already processed children, in this case an array of qualified job ids and their result values will be returned, or the pending children, in this case an array of qualified job ids will be returned. A qualified job id is a string representing the job id in a given queue, for example: "bull:myqueue:jobid".

  Parameters

  • parentId: string

    The id of the parent job

  • type: "processed" | "pending"

    "processed" | "pending"

  • start: number

  • end: number

  Returns Promise<{
      items: {
          err?: string;
          id: string;
          v?: any;
      }[];
      jobs: JobJsonRaw[];
      total: number;
  }>

getFailed

• getFailed(start?, end?): Promise<Job<DataType, ReturnType, NameType>[]>

• Returns the jobs that are in the "failed" status.

  Parameters

  • Optional start: number

    zero based index from where to start returning jobs.

  • Optional end: number

    zero based index where to stop returning jobs.

  Returns Promise<Job<DataType, ReturnType, NameType>[]>

getFailedCount

• getFailedCount(): Promise<number>

• Returns the number of jobs in failed status.

  Returns Promise<number>

getJob

• getJob(jobId): Promise<Job<DataType, ReturnType, NameType>>

• Parameters

  • jobId: string

  Returns Promise<Job<DataType, ReturnType, NameType>>

getJobCountByTypes

• getJobCountByTypes(...types): 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

  Parameters

  • Rest ...types: JobType[]

  Returns Promise<number>

getJobCounts

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

• Returns the job counts for each type specified or every list/set in the queue by default.

  Parameters

  • Rest ...types: JobType[]

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

  An object, key (type) and value (count)

getJobLogs

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

• Returns the logs for a given Job.

  Parameters

  • jobId: string

    the id of the job to get the logs for.

  • Optional start: number

    zero based index from where to start returning jobs.

  • Optional end: number

    zero based index where to stop returning jobs.

  • Optional asc: boolean

    if true, the jobs will be returned in ascending order.

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

getJobState

• getJobState(jobId): Promise<"unknown" | JobState>

• Get current job state.

  Parameters

  • jobId: string

  Returns Promise<"unknown" | JobState>

  Returns one of these values: 'completed', 'failed', 'delayed', 'active', 'waiting', 'waiting-children', 'unknown'.

getJobs

• getJobs(types?, start?, end?, asc?): Promise<Job<DataType, ReturnType, NameType>[]>

• Returns the jobs that are on the given statuses (note that JobType is synonym for job status)

  Parameters

  • Optional types: JobType | JobType[]

    the statuses of the jobs to return.

  • Optional start: number

    zero based index from where to start returning jobs.

  • Optional end: number

    zero based index where to stop returning jobs.

  • Optional asc: boolean

    if true, the jobs will be returned in ascending order.

  Returns Promise<Job<DataType, ReturnType, NameType>[]>

getMetrics

• getMetrics(type, start?, end?): Promise<Metrics>

• 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).

  Parameters

  • type: "completed" | "failed"

  • Optional start: number

    Start point of the metrics, where 0 is the newest point to be returned.

  • Optional end: number

    End point of the metrics, where -1 is the oldest point to be returned.

  Returns Promise<Metrics>

  • Returns an object with queue metrics.

getPrioritized

• getPrioritized(start?, end?): Promise<Job<DataType, ReturnType, NameType>[]>

• Returns the jobs that are in the "prioritized" status.

  Parameters

  • Optional start: number

    zero based index from where to start returning jobs.

  • Optional end: number

    zero based index where to stop returning jobs.

  Returns Promise<Job<DataType, ReturnType, NameType>[]>

getPrioritizedCount

• getPrioritizedCount(): Promise<number>

• Returns the number of jobs in prioritized status.

  Returns Promise<number>

getQueueEvents

• getQueueEvents(): 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 Promise<{
      [index: string]: string;
  }[]>

  • Returns an array with queue events info.

getRanges

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

• Parameters

  • types: JobType[]

  • Optional start: number

  • Optional end: number

  • Optional asc: boolean

  Returns Promise<string[]>

getRateLimitTtl

• getRateLimitTtl(): Promise<number>

• Returns the time to live for a rate limited key in milliseconds.

  Returns Promise<number>

  -2 if the key does not exist. -1 if the key exists but has no associated expire.

  See

  https://redis.io/commands/pttl/

getRepeatableJobs

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

• Get all repeatable meta jobs.

  Parameters

  • Optional start: number

    Offset of first job to return.

  • Optional end: number

    Offset of last job to return.

  • Optional asc: boolean

    Determine the order in which jobs are returned based on their next execution time.

  Returns Promise<RepeatableJob[]>

getWaiting

• getWaiting(start?, end?): Promise<Job<DataType, ReturnType, NameType>[]>

• Returns the jobs that are in the "waiting" status.

  Parameters

  • Optional start: number

    zero based index from where to start returning jobs.

  • Optional end: number

    zero based index where to stop returning jobs.

  Returns Promise<Job<DataType, ReturnType, NameType>[]>

getWaitingChildren

• getWaitingChildren(start?, end?): Promise<Job<DataType, ReturnType, NameType>[]>

• Returns the jobs that are in the "waiting-children" status. I.E. parent jobs that have at least one child that has not completed yet.

  Parameters

  • Optional start: number

    zero based index from where to start returning jobs.

  • Optional end: number

    zero based index where to stop returning jobs.

  Returns Promise<Job<DataType, ReturnType, NameType>[]>

getWaitingChildrenCount

• getWaitingChildrenCount(): Promise<number>

• Returns the number of jobs in waiting-children status.

  Returns Promise<number>

getWaitingCount

• getWaitingCount(): Promise<number>

• Returns the number of jobs in waiting or paused statuses.

  Returns Promise<number>

getWorkers

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

• 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 Promise<{
      [index: string]: string;
  }[]>

  • Returns an array with workers info.

isPaused

• isPaused(): Promise<boolean>

• Returns true if the queue is currently paused.

  Returns Promise<boolean>

off

• off<U>(eventName, listener): Queue<DataType, ReturnType, NameType>

• Type Parameters

  • U extends keyof QueueListener<DataType, ResultType, NameType>

  Parameters

  • eventName: U

  • listener: QueueListener<DataType, ReturnType, NameType>[U]

  Returns Queue<DataType, ReturnType, NameType>

on

• on<U>(event, listener): Queue<DataType, ReturnType, NameType>

• Type Parameters

  • U extends keyof QueueListener<DataType, ResultType, NameType>

  Parameters

  • event: U

  • listener: QueueListener<DataType, ReturnType, NameType>[U]

  Returns Queue<DataType, ReturnType, NameType>

once

• once<U>(event, listener): Queue<DataType, ReturnType, NameType>

• Type Parameters

  • U extends keyof QueueListener<DataType, ResultType, NameType>

  Parameters

  • event: U

  • listener: QueueListener<DataType, ReturnType, NameType>[U]

  Returns Queue<DataType, ReturnType, NameType>

pause

• pause(): Promise<void>

• 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.

  Returns Promise<void>

promoteJobs

• promoteJobs(opts?): Promise<void>

• Promote all the delayed jobs.

  Parameters

  • Optional opts: {
        count?: number;
    }

    • Optional count?: number

  Returns Promise<void>

remove

• remove(jobId, opts?): Promise<number>

• Removes the given job from the queue as well as all its dependencies.

  Parameters

  • jobId: string

    The id of the job to remove

  • Optional opts: {
        removeChildren?: boolean;
    }

    Options to remove a job

    • Optional removeChildren?: boolean

  Returns Promise<number>

  1 if it managed to remove the job or 0 if the job or any of its dependencies were locked.

removeDeprecatedPriorityKey

• removeDeprecatedPriorityKey(): Promise<number>

• Delete old priority helper key.

  Returns Promise<number>

removeRepeatable

• removeRepeatable(name, repeatOpts, jobId?): Promise<boolean>

• Removes a repeatable job.

  Note: you need to use the exact same repeatOpts when deleting a repeatable job than when adding it.

  Parameters

  • name: NameType

    job name

  • repeatOpts: RepeatOptions

  • Optional jobId: string

  Returns Promise<boolean>

  See

  removeRepeatableByKey

removeRepeatableByKey

• removeRepeatableByKey(key): 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.

  Parameters

  • key: string

  Returns Promise<boolean>

  See

  getRepeatableJobs

resume

• resume(): Promise<void>

• Resumes the processing of this queue globally.

  The method reverses the pause operation by resuming the processing of the queue.

  Returns Promise<void>

retryJobs

• retryJobs(opts?): Promise<void>

• Retry all the failed jobs.

  Parameters

  • Optional opts: {
        count?: number;
        state?: FinishedStatus;
        timestamp?: number;
    }

    • Optional count?: number

    • Optional state?: FinishedStatus

    • Optional timestamp?: number

  Returns Promise<void>

trimEvents

• trimEvents(maxLength): Promise<number>

• Trim the event stream to an approximately maxLength.

  Parameters

  • maxLength: number

  Returns Promise<number>

updateJobProgress

• updateJobProgress(jobId, progress): Promise<void>

• Updates the given job's progress.

  Parameters

  • jobId: string

    The id of the job to update

  • progress: number | object

    number or object to be saved as progress.

  Returns Promise<void>

waitUntilReady

• waitUntilReady(): Promise<RedisClient>

• Returns Promise<RedisClient>