Class Scripts

constructor

• new Scripts(queue: ScriptQueueContext): Scripts

  Parameters

  • queue: ScriptQueueContext

  Returns Scripts

moveToFinishedKeys

addJob

• addJob(
      client: RedisClient,
      job: JobJson,
      opts: RedisJobOptions,
      jobId: string,
      parentKeyOpts?: ParentKeyOpts,
  ): Promise<string>

  Parameters

  • client: RedisClient
  • job: JobJson
  • opts: RedisJobOptions
  • jobId: string
  • parentKeyOpts: ParentKeyOpts = {}

  Returns Promise<string>

addJobScheduler

• addJobScheduler(
      jobSchedulerId: string,
      nextMillis: number,
      templateData: string,
      templateOpts: RedisJobOptions,
      opts: RepeatableOptions,
      delayedJobOpts: JobsOptions,
      producerId?: string,
  ): Promise<[string, number]>

  Parameters

  • jobSchedulerId: string
  • nextMillis: number
  • templateData: string
  • templateOpts: RedisJobOptions
  • opts: RepeatableOptions
  • delayedJobOpts: JobsOptions
  • OptionalproducerId: string

  Returns Promise<[string, number]>

addLog

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

  Parameters

  • jobId: string
  • logRow: string
  • OptionalkeepLogs: number

  Returns Promise<number>

addRepeatableJob

• addRepeatableJob(
      customKey: string,
      nextMillis: number,
      opts: RepeatableOptions,
      legacyCustomKey: string,
  ): Promise<string>

  Parameters

  • customKey: string
  • nextMillis: number
  • opts: RepeatableOptions
  • legacyCustomKey: string

  Returns Promise<string>

changeDelay

• changeDelay(jobId: string, delay: number): Promise<void>

  Change delay of a delayed job.

  Reschedules a delayed job by setting a new delay from the current time. For example, calling changeDelay(5000) will reschedule the job to execute 5000 milliseconds (5 seconds) from now, regardless of the original delay.

  Parameters

  • jobId: string

    the ID of the job to change the delay for.

  • delay: number

    milliseconds from now when the job should be processed.

  Returns Promise<void>

  delay in milliseconds.

  Throws

  JobNotExist This exception is thrown if jobId is missing.

  Throws

  JobNotInState This exception is thrown if job is not in delayed state.

changePriority

• changePriority(jobId: string, priority?: number, lifo?: boolean): Promise<void>

  Parameters

  • jobId: string
  • priority: number = 0
  • lifo: boolean = false

  Returns Promise<void>

cleanJobsInSet

• cleanJobsInSet(
      set: string,
      timestamp: number,
      limit?: number,
  ): Promise<string[]>

  Remove jobs in a specific state.

  Parameters

  • set: string
  • timestamp: number
  • limit: number = 0

  Returns Promise<string[]>

  Id jobs from the deleted records.

drain

• drain(delayed: boolean): Promise<void>

  Parameters

  • delayed: boolean

  Returns Promise<void>

execCommand

• execCommand(
      client: ChainableCommander | RedisClient,
      commandName: string,
      args: any[],
  ): any

  Parameters

  • client: ChainableCommander | RedisClient
  • commandName: string
  • args: any[]

  Returns any

extendLock

• extendLock(
      jobId: string,
      token: string,
      duration: number,
      client?: ChainableCommander | RedisClient,
  ): Promise<number>

  Parameters

  • jobId: string
  • token: string
  • duration: number
  • Optionalclient: ChainableCommander | RedisClient

  Returns Promise<number>

extendLocks

• extendLocks(
      jobIds: string[],
      tokens: string[],
      duration: number,
  ): Promise<string[]>

  Parameters

  • jobIds: string[]
  • tokens: string[]
  • duration: number

  Returns Promise<string[]>

finishedErrors

• finishedErrors(
      __namedParameters: {
          code: number;
          command: string;
          jobId?: string;
          parentKey?: string;
          state?: string;
      },
  ): Error

  Parameters

  • __namedParameters: {
        code: number;
        command: string;
        jobId?: string;
        parentKey?: string;
        state?: string;
    }

  Returns Error

getCounts

• getCounts(types: JobType[]): Promise<number[]>

  Parameters

  • types: JobType[]

  Returns Promise<number[]>

getCountsPerPriority

• getCountsPerPriority(priorities: number[]): Promise<number[]>

  Parameters

  • priorities: number[]

  Returns Promise<number[]>

getDependencyCounts

• getDependencyCounts(jobId: string, types: string[]): Promise<number[]>

  Parameters

  • jobId: string
  • types: string[]

  Returns Promise<number[]>

getJobScheduler

• getJobScheduler(id: string): Promise<[any, string]>

  Parameters

  • id: string

  Returns Promise<[any, string]>

getJobSchedulerArgs

• getJobSchedulerArgs(id: string): string[]

  Parameters

  • id: string

  Returns string[]

getMetrics

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

  Parameters

  • type: "failed" | "completed"
  • start: number = 0
  • end: number = -1

  Returns Promise<[string[], string[], number]>

getRanges

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

  Parameters

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

  Returns Promise<[string][]>

getRateLimitTtl

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

  Parameters

  • OptionalmaxJobs: number

  Returns Promise<number>

getRateLimitTtlArgs

• getRateLimitTtlArgs(maxJobs?: number): (string | number)[]

  Parameters

  • OptionalmaxJobs: number

  Returns (string | number)[]

getRepeatConcatOptions

• getRepeatConcatOptions(
      repeatConcatOptions: string,
      repeatJobKey: string,
  ): string

  Parameters

  • repeatConcatOptions: string
  • repeatJobKey: string

  Returns string

getState

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

  Parameters

  • jobId: string

  Returns Promise<"unknown" | JobState>

isFinished

• isFinished(
      jobId: string,
      returnValue?: boolean,
  ): Promise<number | [number, string]>

  Parameters

  • jobId: string
  • returnValue: boolean = false

  Returns Promise<number | [number, string]>

isJobInList

• isJobInList(listKey: string, jobId: string): Promise<boolean>

  Parameters

  • listKey: string
  • jobId: string

  Returns Promise<boolean>

isMaxed

• isMaxed(): Promise<boolean>

  Returns Promise<boolean>

isMaxedArgs

• isMaxedArgs(): string[]

  Returns string[]

moveJobFromActiveToWait

• moveJobFromActiveToWait(jobId: string, token?: string): Promise<any>

  Moves a job back from Active to Wait. This script is used when a job has been manually rate limited and needs to be moved back to wait from active status.

  Parameters

  • jobId: string

    Job id

  • token: string = '0'

  Returns Promise<any>

moveStalledJobsToWait

• moveStalledJobsToWait(): Promise<string[]>

  Looks for unlocked jobs in the active queue.

  The job was being worked on, but the worker process died and it failed to renew the lock. We call these jobs 'stalled'. This is the most common case. We resolve these by moving them back to wait to be re-processed. To prevent jobs from cycling endlessly between active and wait, (e.g. if the job handler keeps crashing), we limit the number stalled job recoveries to settings.maxStalledCount.

  Returns Promise<string[]>

moveToActive

• moveToActive(client: RedisClient, token: string, name?: string): Promise<any[]>

  Parameters

  • client: RedisClient
  • token: string
  • Optionalname: string

  Returns Promise<any[]>

moveToCompletedArgs

• moveToCompletedArgs<T = any, R = any, N extends string = string>(
      job: MinimalJob<T, R, N>,
      returnvalue: R,
      removeOnComplete: number | boolean | KeepJobs,
      token: string,
      fetchNext?: boolean,
  ): (string | number | boolean | Buffer<ArrayBufferLike>)[]

  Type Parameters

  • T = any
  • R = any
  • N extends string = string

  Parameters

  • job: MinimalJob<T, R, N>
  • returnvalue: R
  • removeOnComplete: number | boolean | KeepJobs
  • token: string
  • fetchNext: boolean = false

  Returns (string | number | boolean | Buffer<ArrayBufferLike>)[]

moveToDelayed

• moveToDelayed(
      jobId: string,
      timestamp: number,
      delay: number,
      token?: string,
      opts?: MoveToDelayedOpts,
  ): Promise<void>

  Parameters

  • jobId: string
  • timestamp: number
  • delay: number
  • token: string = '0'
  • opts: MoveToDelayedOpts = {}

  Returns Promise<void>

moveToDelayedArgs

• moveToDelayedArgs(
      jobId: string,
      timestamp: number,
      token: string,
      delay: number,
      opts?: MoveToDelayedOpts,
  ): (string | number | Buffer<ArrayBufferLike>)[]

  Parameters

  • jobId: string
  • timestamp: number
  • token: string
  • delay: number
  • opts: MoveToDelayedOpts = {}

  Returns (string | number | Buffer<ArrayBufferLike>)[]

moveToFailedArgs

• moveToFailedArgs<T = any, R = any, N extends string = string>(
      job: MinimalJob<T, R, N>,
      failedReason: string,
      removeOnFailed: number | boolean | KeepJobs,
      token: string,
      fetchNext?: boolean,
      fieldsToUpdate?: Record<string, any>,
  ): (string | number | boolean | Buffer<ArrayBufferLike>)[]

  Type Parameters

  • T = any
  • R = any
  • N extends string = string

  Parameters

  • job: MinimalJob<T, R, N>
  • failedReason: string
  • removeOnFailed: number | boolean | KeepJobs
  • token: string
  • fetchNext: boolean = false
  • OptionalfieldsToUpdate: Record<string, any>

  Returns (string | number | boolean | Buffer<ArrayBufferLike>)[]

moveToFinished

• moveToFinished(
      jobId: string,
      args: (string | number | boolean | Buffer<ArrayBufferLike>)[],
  ): Promise<any[]>

  Parameters

  • jobId: string
  • args: (string | number | boolean | Buffer<ArrayBufferLike>)[]

  Returns Promise<any[]>

moveToWaitingChildren

• moveToWaitingChildren(
      jobId: string,
      token: string,
      opts?: MoveToWaitingChildrenOpts,
  ): Promise<boolean>

  Move parent job to waiting-children state.

  Parameters

  • jobId: string
  • token: string
  • opts: MoveToWaitingChildrenOpts = {}

  Returns Promise<boolean>

  true if job is successfully moved, false if there are pending dependencies.

  Throws

  JobNotExist This exception is thrown if jobId is missing.

  Throws

  JobLockNotExist This exception is thrown if job lock is missing.

  Throws

  JobNotInState This exception is thrown if job is not in active state.

moveToWaitingChildrenArgs

• moveToWaitingChildrenArgs(
      jobId: string,
      token: string,
      opts?: MoveToWaitingChildrenOpts,
  ): (string | number)[]

  Parameters

  • jobId: string
  • token: string
  • Optionalopts: MoveToWaitingChildrenOpts

  Returns (string | number)[]

obliterate

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

  Parameters

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

  Returns Promise<number>

paginate

• paginate(
      key: string,
      opts: { end: number; fetchJobs?: boolean; start: number },
  ): Promise<
      {
          cursor: string;
          items: { err?: string; id: string; v?: any }[];
          jobs?: JobJsonRaw[];
          total: number;
      },
  >

  Paginate a set or hash keys.

  Parameters

  • key: string
  • opts: { end: number; fetchJobs?: boolean; start: number }

    options to define the pagination behaviour

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

pause

• pause(pause: boolean): Promise<void>

  Parameters

  • pause: boolean

  Returns Promise<void>

promote

• promote(jobId: string): Promise<void>

  Parameters

  • jobId: string

  Returns Promise<void>

promoteJobs

• promoteJobs(count?: number): Promise<number>

  Parameters

  • count: number = 1000

  Returns Promise<number>

remove

• remove(jobId: string, removeChildren: boolean): Promise<number>

  Parameters

  • jobId: string
  • removeChildren: boolean

  Returns Promise<number>

removeChildDependency

• removeChildDependency(jobId: string, parentKey: string): Promise<boolean>

  Parameters

  • jobId: string
  • parentKey: string

  Returns Promise<boolean>

removeJobScheduler

• removeJobScheduler(jobSchedulerId: string): Promise<number>

  Parameters

  • jobSchedulerId: string

  Returns Promise<number>

removeRepeatable

• removeRepeatable(
      legacyRepeatJobId: string,
      repeatConcatOptions: string,
      repeatJobKey: string,
  ): Promise<number>

  Parameters

  • legacyRepeatJobId: string
  • repeatConcatOptions: string
  • repeatJobKey: string

  Returns Promise<number>

removeUnprocessedChildren

• removeUnprocessedChildren(jobId: string): Promise<void>

  Parameters

  • jobId: string

  Returns Promise<void>

reprocessJob

• reprocessJob<T = any, R = any, N extends string = string>(
      job: MinimalJob<T, R, N>,
      state: "failed" | "completed",
  ): Promise<void>

  Attempts to reprocess a job

  Type Parameters

  • T = any
  • R = any
  • N extends string = string

  Parameters

  • job: MinimalJob<T, R, N>

    The job to reprocess

  • state: "failed" | "completed"

    The expected job state. If the job is not found on the provided state, then it's not reprocessed. Supported states: 'failed', 'completed'

  Returns Promise<void>

  A promise that resolves when the job has been successfully moved to the wait queue.

  Throws

  Will throw an error with a code property indicating the failure reason:

  • code 0: Job does not exist
  • code -1: Job is currently locked and can't be retried
  • code -2: Job was not found in the expected set

retryJob

• retryJob(
      jobId: string,
      lifo: boolean,
      token?: string,
      opts?: RetryJobOpts,
  ): Promise<void>

  Parameters

  • jobId: string
  • lifo: boolean
  • token: string = '0'
  • opts: RetryJobOpts = {}

  Returns Promise<void>

retryJobArgs

• retryJobArgs(
      jobId: string,
      lifo: boolean,
      token: string,
      opts?: MoveToDelayedOpts,
  ): (string | number | Buffer<ArrayBufferLike>)[]

  Parameters

  • jobId: string
  • lifo: boolean
  • token: string
  • opts: MoveToDelayedOpts = {}

  Returns (string | number | Buffer<ArrayBufferLike>)[]

retryJobs

• retryJobs(
      state?: FinishedStatus,
      count?: number,
      timestamp?: number,
  ): Promise<number>

  Parameters

  • state: FinishedStatus = 'failed'
  • count: number = 1000
  • timestamp: number = ...

  Returns Promise<number>

updateData

• updateData<T = any, R = any, N extends string = string>(
      job: MinimalJob<T, R, N>,
      data: T,
  ): Promise<void>

  Type Parameters

  • T = any
  • R = any
  • N extends string = string

  Parameters

  • job: MinimalJob<T, R, N>
  • data: T

  Returns Promise<void>

updateJobSchedulerNextMillis

• updateJobSchedulerNextMillis(
      jobSchedulerId: string,
      nextMillis: number,
      templateData: string,
      delayedJobOpts: JobsOptions,
      producerId?: string,
  ): Promise<string>

  Parameters

  • jobSchedulerId: string
  • nextMillis: number
  • templateData: string
  • delayedJobOpts: JobsOptions
  • OptionalproducerId: string

  Returns Promise<string>

updateProgress

• updateProgress(jobId: string, progress: JobProgress): Promise<void>

  Parameters

  • jobId: string
  • progress: JobProgress

  Returns Promise<void>

updateRepeatableJobMillis

• updateRepeatableJobMillis(
      client: RedisClient,
      customKey: string,
      nextMillis: number,
      legacyCustomKey: string,
  ): Promise<string>

  Parameters

  • client: RedisClient
  • customKey: string
  • nextMillis: number
  • legacyCustomKey: string

  Returns Promise<string>