Class Queue<T>

Readonlyname

add

• add(name: string, data: T, opts?: JobOptions): Promise<Job<T>>

  Parameters

  • name: string
  • data: T
  • Optionalopts: JobOptions

  Returns Promise<Job<T>>

addBulk

• addBulk(jobs: { data: T; name: string; opts?: JobOptions }[]): Promise<Job<T>[]>

  Parameters

  • jobs: { data: T; name: string; opts?: JobOptions }[]

  Returns Promise<Job<T>[]>

addJobLog

• addJobLog(id: string, logRow: string, _keepLogs?: number): Promise<number>

  Parameters

  • id: string
  • logRow: string
  • Optional_keepLogs: number

  Returns Promise<number>

changeJobDelay

• changeJobDelay(id: string, delay: number): Promise<void>

  Parameters

  • id: string
  • delay: number

  Returns Promise<void>

changeJobPriority

• changeJobPriority(id: string, opts: ChangePriorityOpts): Promise<void>

  Parameters

  • id: string
  • opts: ChangePriorityOpts

  Returns Promise<void>

clean

• clean(grace: number, limit: number, type?: string): string[]

  Parameters

  • grace: number
  • limit: number
  • Optionaltype: string

  Returns string[]

cleanAsync

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

  Parameters

  • grace: number
  • limit: number
  • Optionaltype: string

  Returns Promise<string[]>

clearJobLogs

• clearJobLogs(id: string, keepLogs?: number): Promise<void>

  Parameters

  • id: string
  • OptionalkeepLogs: number

  Returns Promise<void>

close

• close(): void

  Returns void

count

• count(): number

  Returns number

countAsync

• countAsync(): Promise<number>

  Returns Promise<number>

disconnect

• disconnect(): Promise<void>

  Returns Promise<void>

drain

• drain(): void

  Returns void

drainAsync

• drainAsync(): Promise<number>

  Returns Promise<number>

extendJobLock

• extendJobLock(id: string, token: string, duration: number): Promise<number>

  Parameters

  • id: string
  • token: string
  • duration: number

  Returns Promise<number>

getActive

• getActive(start?: number, end?: number): Job<T>[]

  Parameters

  • Optionalstart: number
  • Optionalend: number

  Returns Job<T>[]

getActiveAsync

• getActiveAsync(start?: number, end?: number): Promise<Job<T>[]>

  Parameters

  • Optionalstart: number
  • Optionalend: number

  Returns Promise<Job<T>[]>

getActiveCount

• getActiveCount(): Promise<number>

  Returns Promise<number>

getChildrenValues

• getChildrenValues(id: string): Promise<Record<string, unknown>>

  Parameters

  • id: string

  Returns Promise<Record<string, unknown>>

getCompleted

• getCompleted(start?: number, end?: number): Job<T>[]

  Parameters

  • Optionalstart: number
  • Optionalend: number

  Returns Job<T>[]

getCompletedAsync

• getCompletedAsync(start?: number, end?: number): Promise<Job<T>[]>

  Parameters

  • Optionalstart: number
  • Optionalend: number

  Returns Promise<Job<T>[]>

getCompletedCount

• getCompletedCount(): Promise<number>

  Returns Promise<number>

getCountsPerPriority

• getCountsPerPriority(): Record<number, number>

  Returns Record<number, number>

getCountsPerPriorityAsync

• getCountsPerPriorityAsync(): Promise<Record<number, number>>

  Returns Promise<Record<number, number>>

getCountsPerPriorityForGroup

• getCountsPerPriorityForGroup(groupId: string): Promise<Record<number, number>>

  Parameters

  • groupId: string

  Returns Promise<Record<number, number>>

getDeduplicationJobId

• getDeduplicationJobId(deduplicationId: string): Promise<string | null>

  Parameters

  • deduplicationId: string

  Returns Promise<string | null>

getDelayed

• getDelayed(start?: number, end?: number): Job<T>[]

  Parameters

  • Optionalstart: number
  • Optionalend: number

  Returns Job<T>[]

getDelayedAsync

• getDelayedAsync(start?: number, end?: number): Promise<Job<T>[]>

  Parameters

  • Optionalstart: number
  • Optionalend: number

  Returns Promise<Job<T>[]>

getDelayedCount

• getDelayedCount(): Promise<number>

  Returns Promise<number>

getDependencies

• getDependencies(
      parentId: string,
      type?: "processed" | "unprocessed",
      start?: number,
      end?: number,
  ): Promise<
      {
          nextProcessedCursor?: number;
          nextUnprocessedCursor?: number;
          processed?: Record<string, unknown>;
          unprocessed?: string[];
      },
  >

  Parameters

  • parentId: string
  • Optionaltype: "processed" | "unprocessed"
  • Optionalstart: number
  • Optionalend: number

  Returns Promise<
      {
          nextProcessedCursor?: number;
          nextUnprocessedCursor?: number;
          processed?: Record<string, unknown>;
          unprocessed?: string[];
      },
  >

getDlq

• getDlq(filter?: DlqFilter): DlqEntry<T>[]

  Parameters

  • Optionalfilter: DlqFilter

  Returns DlqEntry<T>[]

getDlqAsync

• getDlqAsync(filter?: DlqFilter): Promise<DlqEntry<T>[]>

  Parameters

  • Optionalfilter: DlqFilter

  Returns Promise<DlqEntry<T>[]>

getDlqConfig

• getDlqConfig(): DlqConfig

  Returns DlqConfig

getDlqConfigAsync

• getDlqConfigAsync(): Promise<DlqConfig>

  Returns Promise<DlqConfig>

getDlqJobsAsync

• getDlqJobsAsync(count?: number): Promise<Job<T>[]>

  Parameters

  • Optionalcount: number

  Returns Promise<Job<T>[]>

getDlqStats

• getDlqStats(): DlqStats

  Returns DlqStats

getDlqStatsAsync

• getDlqStatsAsync(): Promise<DlqStats>

  Returns Promise<DlqStats>

getFailed

• getFailed(start?: number, end?: number): Job<T>[]

  Parameters

  • Optionalstart: number
  • Optionalend: number

  Returns Job<T>[]

getFailedAsync

• getFailedAsync(start?: number, end?: number): Promise<Job<T>[]>

  Parameters

  • Optionalstart: number
  • Optionalend: number

  Returns Promise<Job<T>[]>

getFailedCount

• getFailedCount(): Promise<number>

  Returns Promise<number>

getGlobalConcurrency

• getGlobalConcurrency(): Promise<number | null>

  Returns Promise<number | null>

getGlobalRateLimit

• getGlobalRateLimit(): Promise<{ duration: number; max: number } | null>

  Returns Promise<{ duration: number; max: number } | null>

getGroupActiveCount

• getGroupActiveCount(groupId: string): Promise<number>

  Parameters

  • groupId: string

  Returns Promise<number>

getGroupConcurrency

• getGroupConcurrency(groupId: string): Promise<number | null>

  Parameters

  • groupId: string

  Returns Promise<number | null>

getGroupJobs

• getGroupJobs(groupId: string, start?: number, end?: number): Promise<Job<T>[]>

  Parameters

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

  Returns Promise<Job<T>[]>

getGroupJobsCount

• getGroupJobsCount(groupId: string): Promise<number>

  Parameters

  • groupId: string

  Returns Promise<number>

getGroupRateLimit

• getGroupRateLimit(
      groupId: string,
  ): Promise<{ duration: number; max: number } | null>

  Parameters

  • groupId: string

  Returns Promise<{ duration: number; max: number } | null>

getGroupRateLimitTtl

• getGroupRateLimitTtl(groupId: string, maxJobs?: number): Promise<number>

  Parameters

  • groupId: string
  • OptionalmaxJobs: number

  Returns Promise<number>

getGroupsJobsCount

• getGroupsJobsCount(maxCount?: number): Promise<number>

  Parameters

  • OptionalmaxCount: number

  Returns Promise<number>

getJob

• getJob(id: string): Promise<Job<T> | null>

  Parameters

  • id: string

  Returns Promise<Job<T> | null>

getJobCounts

• getJobCounts(): JobCounts | Promise<JobCounts>

  Returns JobCounts | Promise<JobCounts>

getJobCountsAsync

• getJobCountsAsync(): Promise<JobCounts>

  Returns Promise<JobCounts>

getJobDependencies

• getJobDependencies(
      id: string,
      opts?: GetDependenciesOpts,
  ): Promise<JobDependencies>

  Parameters

  • id: string
  • Optionalopts: GetDependenciesOpts

  Returns Promise<JobDependencies>

getJobDependenciesCount

• getJobDependenciesCount(
      id: string,
      opts?: GetDependenciesOpts,
  ): Promise<JobDependenciesCount>

  Parameters

  • id: string
  • Optionalopts: GetDependenciesOpts

  Returns Promise<JobDependenciesCount>

getJobLogs

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

  Parameters

  • id: string
  • Optionalstart: number
  • Optionalend: number
  • Optional_asc: boolean

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

getJobs

• getJobs(
      opts?: {
          asc?: boolean;
          end?: number;
          start?: number;
          state?: string | string[];
      },
  ): Job<T>[]

  Parameters

  • Optionalopts: { asc?: boolean; end?: number; start?: number; state?: string | string[] }

  Returns Job<T>[]

getJobsAsync

• getJobsAsync(
      opts?: {
          asc?: boolean;
          end?: number;
          start?: number;
          state?: string | string[];
      },
  ): Promise<Job<unknown>[]>

  Parameters

  • Optionalopts: { asc?: boolean; end?: number; start?: number; state?: string | string[] }

  Returns Promise<Job<unknown>[]>

getJobScheduler

• getJobScheduler(schedulerId: string): Promise<SchedulerInfo | null>

  Parameters

  • schedulerId: string

  Returns Promise<SchedulerInfo | null>

getJobSchedulers

• getJobSchedulers(
      start?: number,
      end?: number,
      asc?: boolean,
  ): Promise<SchedulerInfo[]>

  Parameters

  • Optionalstart: number
  • Optionalend: number
  • Optionalasc: boolean

  Returns Promise<SchedulerInfo[]>

getJobSchedulersCount

• getJobSchedulersCount(): Promise<number>

  Returns Promise<number>

getJobState

• getJobState(id: string): Promise<JobStateType>

  Parameters

  • id: string

  Returns Promise<JobStateType>

getMetrics

• getMetrics(
      type: "completed" | "failed",
      start?: number,
      end?: number,
  ): Promise<QueueMetrics>

  Parameters

  • type: "completed" | "failed"
  • Optionalstart: number
  • Optionalend: number

  Returns Promise<QueueMetrics>

getPrioritized

• getPrioritized(start?: number, end?: number): Promise<Job<T>[]>

  Parameters

  • Optionalstart: number
  • Optionalend: number

  Returns Promise<Job<T>[]>

getPrioritizedCount

• getPrioritizedCount(): Promise<number>

  Returns Promise<number>

getRateLimitTtl

• getRateLimitTtl(maxJobs?: number): Promise<number>

  Parameters

  • OptionalmaxJobs: number

  Returns Promise<number>

getStallConfig

• getStallConfig(): StallConfig

  Returns StallConfig

getStallConfigAsync

• getStallConfigAsync(): Promise<StallConfig>

  Returns Promise<StallConfig>

getWaiting

• getWaiting(start?: number, end?: number): Job<T>[]

  Parameters

  • Optionalstart: number
  • Optionalend: number

  Returns Job<T>[]

getWaitingAsync

• getWaitingAsync(start?: number, end?: number): Promise<Job<T>[]>

  Parameters

  • Optionalstart: number
  • Optionalend: number

  Returns Promise<Job<T>[]>

getWaitingChildren

• getWaitingChildren(start?: number, end?: number): Promise<Job<T>[]>

  Parameters

  • Optionalstart: number
  • Optionalend: number

  Returns Promise<Job<T>[]>

getWaitingChildrenCount

• getWaitingChildrenCount(): Promise<number>

  Returns Promise<number>

getWaitingCount

• getWaitingCount(): Promise<number>

  Returns Promise<number>

getWorkers

• getWorkers(): Promise<WorkerInfo[]>

  Returns Promise<WorkerInfo[]>

getWorkersCount

• getWorkersCount(): Promise<number>

  Returns Promise<number>

isGroupPaused

• isGroupPaused(groupId: string): Promise<boolean>

  Parameters

  • groupId: string

  Returns Promise<boolean>

isMaxed

• isMaxed(): Promise<boolean>

  Returns Promise<boolean>

isPaused

• isPaused(): boolean

  Returns boolean

isPausedAsync

• isPausedAsync(): Promise<boolean>

  Returns Promise<boolean>

moveJobToCompleted

• moveJobToCompleted(
      id: string,
      returnValue: unknown,
      token?: string,
  ): Promise<unknown>

  Parameters

  • id: string
  • returnValue: unknown
  • Optionaltoken: string

  Returns Promise<unknown>

moveJobToDelayed

• moveJobToDelayed(id: string, timestamp: number, token?: string): Promise<void>

  Parameters

  • id: string
  • timestamp: number
  • Optionaltoken: string

  Returns Promise<void>

moveJobToFailed

• moveJobToFailed(id: string, error: Error, token?: string): Promise<void>

  Parameters

  • id: string
  • error: Error
  • Optionaltoken: string

  Returns Promise<void>

moveJobToWait

• moveJobToWait(id: string, token?: string): Promise<boolean>

  Parameters

  • id: string
  • Optionaltoken: string

  Returns Promise<boolean>

moveJobToWaitingChildren

• moveJobToWaitingChildren(
      id: string,
      token?: string,
      opts?: { child?: { id: string; queue: string } },
  ): Promise<boolean>

  Parameters

  • id: string
  • Optionaltoken: string
  • Optionalopts: { child?: { id: string; queue: string } }

  Returns Promise<boolean>

obliterate

• obliterate(): void

  Returns void

obliterateAsync

• obliterateAsync(): Promise<void>

  Returns Promise<void>

pause

• pause(): void

  Returns void

pauseAsync

• pauseAsync(): Promise<void>

  Returns Promise<void>

pauseGroup

• pauseGroup(groupId: string): Promise<boolean>

  Parameters

  • groupId: string

  Returns Promise<boolean>

promoteJob

• promoteJob(id: string): Promise<void>

  Parameters

  • id: string

  Returns Promise<void>

promoteJobs

• promoteJobs(opts?: { count?: number }): Promise<number>

  Parameters

  • Optionalopts: { count?: number }

  Returns Promise<number>

purgeDlq

• purgeDlq(): number

  Returns number

purgeDlqAsync

• purgeDlqAsync(): Promise<number>

  Returns Promise<number>

rateLimit

• rateLimit(expireTimeMs: number): Promise<void>

  Parameters

  • expireTimeMs: number

  Returns Promise<void>

remove

• remove(id: string): void

  Parameters

  • id: string

  Returns void

removeAsync

• removeAsync(id: string): Promise<void>

  Parameters

  • id: string

  Returns Promise<void>

removeDeduplicationKey

• removeDeduplicationKey(deduplicationId: string): Promise<number>

  Parameters

  • deduplicationId: string

  Returns Promise<number>

removeDlqJob

• removeDlqJob(id: string): Promise<boolean>

  Remove one DLQ entry and resolve when the removal completes.

  Parameters

  • id: string

  Returns Promise<boolean>

removeDlqJobAsync

• removeDlqJobAsync(id: string): Promise<boolean>

  Explicit async alias for removeDlqJob.

  Parameters

  • id: string

  Returns Promise<boolean>

removeGlobalConcurrency

• removeGlobalConcurrency(): void

  Returns void

removeGlobalConcurrencyAsync

• removeGlobalConcurrencyAsync(): Promise<void>

  Returns Promise<void>

removeGlobalRateLimit

• removeGlobalRateLimit(): void

  Returns void

removeGlobalRateLimitAsync

• removeGlobalRateLimitAsync(): Promise<void>

  Returns Promise<void>

removeGroupConcurrency

• removeGroupConcurrency(groupId: string): Promise<number>

  Parameters

  • groupId: string

  Returns Promise<number>

removeGroupRateLimit

• removeGroupRateLimit(groupId: string): Promise<number>

  Parameters

  • groupId: string

  Returns Promise<number>

removeJobScheduler

• removeJobScheduler(schedulerId: string): Promise<boolean>

  Parameters

  • schedulerId: string

  Returns Promise<boolean>

resume

• resume(): void

  Returns void

resumeAsync

• resumeAsync(): Promise<void>

  Returns Promise<void>

resumeGroup

• resumeGroup(groupId: string): Promise<boolean>

  Parameters

  • groupId: string

  Returns Promise<boolean>

retryCompleted

• retryCompleted(id?: string): number

  Parameters

  • Optionalid: string

  Returns number

retryCompletedAsync

• retryCompletedAsync(id?: string): Promise<number>

  Parameters

  • Optionalid: string

  Returns Promise<number>

retryDlq

• retryDlq(id?: string): number

  Parameters

  • Optionalid: string

  Returns number

retryDlqAsync

• retryDlqAsync(id?: string): Promise<number>

  Parameters

  • Optionalid: string

  Returns Promise<number>

retryDlqByFilter

• retryDlqByFilter(filter: DlqFilter): number

  Parameters

  • filter: DlqFilter

  Returns number

retryDlqByFilterAsync

• retryDlqByFilterAsync(filter: DlqFilter): Promise<number>

  Parameters

  • filter: DlqFilter

  Returns Promise<number>

retryJob

• retryJob(id: string): Promise<void>

  Parameters

  • id: string

  Returns Promise<void>

retryJobs

• retryJobs(
      opts?: {
          count?: number;
          state?: "completed" | "failed";
          timestamp?: number;
      },
  ): Promise<void>

  Parameters

  • Optionalopts: { count?: number; state?: "completed" | "failed"; timestamp?: number }

  Returns Promise<void>

setDlqConfig

• setDlqConfig(config: Partial<DlqConfig>): void

  Parameters

  • config: Partial<DlqConfig>

  Returns void

setDlqConfigAsync

• setDlqConfigAsync(config: Partial<DlqConfig>): Promise<void>

  Parameters

  • config: Partial<DlqConfig>

  Returns Promise<void>

setGlobalConcurrency

• setGlobalConcurrency(concurrency: number): void

  Parameters

  • concurrency: number

  Returns void

setGlobalConcurrencyAsync

• setGlobalConcurrencyAsync(concurrency: number): Promise<void>

  Parameters

  • concurrency: number

  Returns Promise<void>

setGlobalRateLimit

• setGlobalRateLimit(max: number, duration?: number): void

  Parameters

  • max: number
  • Optionalduration: number

  Returns void

setGlobalRateLimitAsync

• setGlobalRateLimitAsync(max: number, duration?: number): Promise<void>

  Parameters

  • max: number
  • Optionalduration: number

  Returns Promise<void>

setGroupConcurrency

• setGroupConcurrency(groupId: string, concurrency: number): Promise<void>

  Parameters

  • groupId: string
  • concurrency: number

  Returns Promise<void>

setGroupRateLimit

• setGroupRateLimit(groupId: string, max: number, duration: number): Promise<void>

  Parameters

  • groupId: string
  • max: number
  • duration: number

  Returns Promise<void>

setStallConfig

• setStallConfig(config: Partial<StallConfig>): void

  Parameters

  • config: Partial<StallConfig>

  Returns void

setStallConfigAsync

• setStallConfigAsync(config: Partial<StallConfig>): Promise<void>

  Parameters

  • config: Partial<StallConfig>

  Returns Promise<void>

trimEvents

• trimEvents(maxLength: number): Promise<number>

  Parameters

  • maxLength: number

  Returns Promise<number>

updateJobData

• updateJobData(id: string, data: unknown): Promise<void>

  Parameters

  • id: string
  • data: unknown

  Returns Promise<void>

updateJobProgress

• updateJobProgress(id: string, progress: number | object): Promise<void>

  Parameters

  • id: string
  • progress: number | object

  Returns Promise<void>

upsertJobScheduler

• upsertJobScheduler(
      schedulerId: string,
      repeatOpts: RepeatOpts,
      jobTemplate?: JobTemplate<T>,
  ): Promise<SchedulerInfo | null>

  Parameters

  • schedulerId: string
  • repeatOpts: RepeatOpts
  • OptionaljobTemplate: JobTemplate<T>

  Returns Promise<SchedulerInfo | null>

waitJobUntilFinished

• waitJobUntilFinished(
      id: string,
      queueEvents: unknown,
      ttl?: number,
  ): Promise<unknown>

  Parameters

  • id: string
  • queueEvents: unknown
  • Optionalttl: number

  Returns Promise<unknown>

waitUntilReady

• waitUntilReady(): Promise<void>

  Returns Promise<void>