Class Queue<DataType, ReturnType, NameType>

constructor

• new Queue<DataType, ReturnType, NameType>(name, opts?): Queue<DataType, ReturnType, NameType>

• Type Parameters

  • DataType = any

  • ReturnType = any

  • NameType extends string = string

  Parameters

  • name: string

  • Optional opts: QueueProOptions

  Returns Queue<DataType, ReturnType, NameType>

opts

metaValues

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

• Returns Record<string, string | number>

add

• add(name, data, opts?): Promise<Job<DataType, ReturnType, NameType>>

• Adds a Job to the queue.

  Parameters

  • name: NameType

  • data: DataType

  • Optional opts: JobsProOptions

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

addBulk

• addBulk(jobs): Promise<Job<DataType, ReturnType, 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<Job<DataType, ReturnType, NameType>[]>

deleteGroup

• deleteGroup(groupId): Promise<void>

• Cleans all the jobs that are part of a group.

  Parameters

  • groupId: string | number

  Returns Promise<void>

deleteGroupConcurrency

• deleteGroupConcurrency(groupId): Promise<number>

• Deletes group concurrency.

  Parameters

  • groupId: string | number

  Returns Promise<number>

deleteGroups

• deleteGroups(): Promise<void>

• Cleans all the groups in this queue

  Returns Promise<void>

getCountsPerPriorityForGroup

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

• Returns the number of jobs per priority.

  Parameters

  • groupId: string

  • priorities: number[]

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

getGroupActiveCount

• getGroupActiveCount(groupId): 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): Promise<number>

• Gets group concurrency.

  Parameters

  • groupId: string | number

  Returns Promise<number>

getGroupJobs

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

• Get jobs that are part of a given group.

  Parameters

  • groupId: string | number

  • start: number = 0

  • end: number = -1

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

getGroupJobsCount

• getGroupJobsCount(groupId): Promise<number>

• Gets the count of jobs inside a given group id.

  Parameters

  • groupId: string | number

  Returns Promise<number>

getGroupRateLimitTtl

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

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

  Parameters

  • groupId: string | number

    group identifier

  • Optional maxJobs: 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/

getGroupStatus

• getGroupStatus(groupId): 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.

getGroups

• getGroups(start?, end?): 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, start?, end?): 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?): 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>

getVersion

• getVersion(): Promise<string>

• Get library version.

  Returns Promise<string>

  the content of the meta.library field.

obliterate

• obliterate(opts?): Promise<void>

• Parameters

  • Optional opts: {
        count?: number;
        force?: boolean;
    }

    • Optional count?: number

    • Optional force?: boolean

  Returns Promise<void>

pauseGroup

• pauseGroup(groupId): 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>

repairMaxedGroup

• repairMaxedGroup(groupId, concurrency?): 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

  • Optional concurrency: 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): 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, concurrency): Promise<number>

• Sets group concurrency.

  Parameters

  • groupId: string | number

  • concurrency: number

  Returns Promise<number>