Class QueuePro<DataType, ResultType, NameType>

constructor

• new QueuePro<DataType = any, ResultType = any, NameType extends string = string>(
      name: string,
      opts?: QueueProOptions,
  ): QueuePro<DataType, ResultType, NameType>

  Type Parameters

  • DataType = any
  • ResultType = any
  • NameType extends string = string

  Parameters

  • name: string
  • Optionalopts: QueueProOptions

  Returns QueuePro<DataType, ResultType, NameType>

opts

jobScheduler

• get jobScheduler(): Promise<JobSchedulerPro>

  Returns Promise<JobSchedulerPro>

metaValues

• get metaValues(): Record<string, string | number>

  Returns Record<string, string | number>

repeat

• get repeat(): Promise<RepeatPro>

  Returns Promise<RepeatPro>

add

• add(
      name: NameType,
      data: DataType,
      opts?: JobsProOptions,
  ): Promise<JobPro<DataType, ResultType, NameType>>

  Adds a Job to the queue.

  Parameters

  • name: NameType
  • data: DataType
  • Optionalopts: JobsProOptions

  Returns Promise<JobPro<DataType, ResultType, NameType>>

addBulk

• addBulk(
      jobs: { data: DataType; name: NameType; opts?: BulkJobProOptions }[],
  ): Promise<JobPro<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.

  Parameters

  • jobs: { data: DataType; name: NameType; opts?: BulkJobProOptions }[]

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

  Returns Promise<JobPro<DataType, ResultType, NameType>[]>

deleteGroup

• deleteGroup(groupId: string | number): Promise<void>

  Cleans all the jobs that are part of a group.

  Parameters

  • groupId: string | number

  Returns Promise<void>

deleteGroupConcurrency

• deleteGroupConcurrency(groupId: string | number): Promise<number>

  Deletes group concurrency.

  Parameters

  • groupId: string | number

  Returns Promise<number>

  Deprecated

  • use removeGroupConcurrency

deleteGroups

• deleteGroups(): Promise<void>

  Cleans all the groups in this queue

  Returns Promise<void>

getCountsPerPriorityForGroup

• getCountsPerPriorityForGroup(
      groupId: string,
      priorities: number[],
  ): Promise<{ [index: string]: number }>

  Returns the number of jobs per priority.

  Parameters

  • groupId: string
  • priorities: number[]

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

getGroupActiveCount

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

  Gets the active count of jobs inside a given group id. It will only return data when using concurrency per group, otherwise it will return NaN.

  Parameters

  • groupId: string | number

  Returns Promise<number>

getGroupConcurrency

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

  Gets group concurrency.

  Parameters

  • groupId: string | number

  Returns Promise<number>

getGroupJobs

• getGroupJobs(
      groupId: string | number,
      start?: number,
      end?: number,
  ): Promise<JobPro<DataType, ResultType, NameType>[]>

  Get jobs that are part of a given group.

  Parameters

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

  Returns Promise<JobPro<DataType, ResultType, NameType>[]>

getGroupJobsCount

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

  Gets the count of jobs inside a given group id.

  Parameters

  • groupId: string | number

  Returns Promise<number>

getGroupMeta

• getGroupMeta(groupId: string | number): Promise<GroupMetaOptions>

  Gets group meta options.

  Parameters

  • groupId: string | number

  Returns Promise<GroupMetaOptions>

getGroupRateLimit

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

  Gets group rate limit options.

  Parameters

  • groupId: string | number

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

getGroupRateLimitTtl

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

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

  Parameters

  • groupId: string | number

    group identifier
  • OptionalmaxJobs: number

    max jobs to be considered in rate limit state. If not passed it will return the remaining ttl without considering if max jobs is excedeed.

  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/

getGroups

• getGroups(
      start?: number,
      end?: number,
  ): Promise<{ id: string; status: GroupStatus }[]>

  Get the group ids with jobs current jobs in them.

  TODO: Support group id filtering.

  Parameters

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

  Returns Promise<{ id: string; status: GroupStatus }[]>

getGroupsByStatus

• getGroupsByStatus(
      status: GroupStatus,
      start?: number,
      end?: number,
  ): Promise<{ count: number; id: string }[]>

  Gets all the groups that are in a particular status.

  Parameters

  • status: GroupStatus

    GroupStatus so we can filter by status
  • start: number = 0

    start index, used for pagination.
  • end: number = -1

    end index, used for pagination.

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

  an array of objects with the group id and status.

getGroupsCount

• getGroupsCount(): Promise<number>

  Get the total number of groups with jobs in them.

  Returns Promise<number>

getGroupsCountByStatus

• getGroupsCountByStatus(): Promise<
      { limited: number; maxed: number; paused: number; waiting: number },
  >

  Get the total number of groups with jobs in them, in their different statuses.

  Returns Promise<{ limited: number; maxed: number; paused: number; waiting: number }>

getGroupsJobsCount

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

  Gets the count of all the jobs belonging to any group.

  Parameters

  • limit: number = 100

    limit of groups per each iteration

  Returns Promise<number>

getGroupStatus

• getGroupStatus(groupId: string): Promise<GroupStatus>

  Get the given group status.

  Parameters

  • groupId: string

    The group id to get the status for.

  Returns Promise<GroupStatus>

  GroupStatus - The status of the group or null if the group does not exist.

getVersion

• getVersion(): Promise<string>

  Get library version.

  Returns Promise<string>

  the content of the meta.library field.

obliterate

• obliterate(opts?: { count?: number; force?: boolean }): Promise<void>

  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.

  Parameters

  • Optionalopts: { count?: number; force?: boolean }

    Obliterate options.

  Returns Promise<void>

pauseGroup

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

  Pauses the processing of a specific group globally.

  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 or group list.

  Parameters

  • groupId: string | number

  Returns Promise<boolean>

removeGroupConcurrency

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

  Removes group concurrency.

  Parameters

  • groupId: string | number

  Returns Promise<number>

removeGroupMeta

• removeGroupMeta(groupId: string | number): Promise<number>

  Remove group configuration.

  Parameters

  • groupId: string | number

  Returns Promise<number>

removeGroupRateLimit

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

  Removes group rate limit.

  Parameters

  • groupId: string | number

  Returns Promise<number>

repairMaxedGroup

• repairMaxedGroup(groupId: string, concurrency?: number): Promise<any>

  Repairs a maxed group.

  It seems that in some unknown situations a group can become maxed although there are no active jobs in the group. This function will try to repair this situation.

  Parameters

  • groupId: string

    the group to repair
  • Optionalconcurrency: number

    maximum number of simultaneous jobs that the workers can handle within a specific group

  Returns Promise<any>

repairStalledKey

• repairStalledKey(): Promise<any>

  Repairs stalled key when you are migrating from v4 or below to v6 or above. This key used a zset and now it uses a set, this is why this method is needed. An error like: 'WRONGTYPE Operation against a key holding the wrong kind of value' in moveStalledJobsToWait script is a good indicator of this change. Note: Migration from v5 to v6 won't need to call this method

  Returns Promise<any>

resumeGroup

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

  Resumes the processing of a specific group globally.

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

  Parameters

  • groupId: string | number

    the group to resume

  Returns Promise<boolean>

setGroupConcurrency

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

  Sets group concurrency.

  Parameters

  • groupId: string | number
  • concurrency: number

  Returns Promise<number>

setGroupRateLimit

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

  Sets group rate limit.

  Parameters

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

  Returns Promise<number>