bullmq 3.2.2 → 3.2.4

package/dist/cjs/commands/includes/isLocked.lua

@@ -13,19 +13,19 @@ local function isLocked( prefix, jobId)
   local lockKey = jobKey .. ':lock'
   local lock = rcall("GET", lockKey)
   if not lock then
-      local dependencies = rcall("SMEMBERS", jobKey .. ":dependencies")
-      if (#dependencies > 0) then
-          for i, childJobKey in ipairs(dependencies) do
-              -- We need to get the jobId for this job.
-              local childJobId = getJobIdFromKey(childJobKey)
-              local childJobPrefix = getJobKeyPrefix(childJobKey, childJobId)
-              local result = isLocked( childJobPrefix, childJobId )
-              if result then
-                  return true
-              end
-          end
+    local dependencies = rcall("SMEMBERS", jobKey .. ":dependencies")
+    if (#dependencies > 0) then
+      for i, childJobKey in ipairs(dependencies) do
+        -- We need to get the jobId for this job.
+        local childJobId = getJobIdFromKey(childJobKey)
+        local childJobPrefix = getJobKeyPrefix(childJobKey, childJobId)
+        local result = isLocked( childJobPrefix, childJobId )
+        if result then
+          return true
+        end
       end
-      return false
+    end
+    return false
   end
   return true
 end

package/dist/cjs/commands/includes/moveJobFromWaitToActive.lua

@@ -24,6 +24,10 @@ local function moveJobFromWaitToActive(keys, keyPrefix, jobId, processedOn, opts
 
   if(maxJobs) then
     local rateLimiterKey = keys[6];
+
+    expireTime = tonumber(rcall("PTTL", rateLimiterKey))
+    if expireTime == 0 then rcall("DEL", rateLimiterKey) end
+
     local jobCounter = tonumber(rcall("INCR", rateLimiterKey))
 
     if jobCounter == 1 then

package/dist/cjs/interfaces/connection.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import { EventEmitter } from 'events';
 import { Cluster, Redis } from 'ioredis';
-export declare type RedisClient = Redis | Cluster;
+export type RedisClient = Redis | Cluster;
 export interface IConnection extends EventEmitter {
     waitUntilReady(): Promise<boolean>;
     client: Promise<RedisClient>;

package/dist/cjs/interfaces/flow-job.d.ts

@@ -8,9 +8,9 @@ interface FlowJobBase<T> {
     opts?: Omit<T, 'repeat'>;
     children?: FlowChildJob[];
 }
-export declare type FlowChildJob = FlowJobBase<Omit<JobsOptions, 'parent'>>;
-export declare type FlowJob = FlowJobBase<JobsOptions>;
-export declare type FlowQueuesOpts = Record<string, Omit<QueueOptions, 'connection' | 'prefix'>>;
+export type FlowChildJob = FlowJobBase<Omit<JobsOptions, 'parent'>>;
+export type FlowJob = FlowJobBase<JobsOptions>;
+export type FlowQueuesOpts = Record<string, Omit<QueueOptions, 'connection' | 'prefix'>>;
 export interface FlowOpts {
     /**
      * Map of options for Queue classes.

package/dist/cjs/interfaces/redis-options.d.ts

@@ -2,7 +2,7 @@ import type * as IORedis from 'ioredis';
 interface BaseOptions {
     skipVersionCheck?: boolean;
 }
-export declare type RedisOptions = IORedis.RedisOptions & BaseOptions;
-export declare type ClusterOptions = IORedis.ClusterOptions & BaseOptions;
-export declare type ConnectionOptions = RedisOptions | ClusterOptions | IORedis.Redis | IORedis.Cluster;
+export type RedisOptions = IORedis.RedisOptions & BaseOptions;
+export type ClusterOptions = IORedis.ClusterOptions & BaseOptions;
+export type ConnectionOptions = RedisOptions | ClusterOptions | IORedis.Redis | IORedis.Cluster;
 export {};

package/dist/cjs/interfaces/redis-streams.d.ts

@@ -1,4 +1,4 @@
-export declare type StreamName = string;
-export declare type EntryId = string;
-export declare type EntryRaw = [EntryId, string[]];
-export declare type StreamReadRaw = [StreamName, EntryRaw[]][];
+export type StreamName = string;
+export type EntryId = string;
+export type EntryRaw = [EntryId, string[]];
+export type StreamReadRaw = [StreamName, EntryRaw[]][];

package/dist/cjs/interfaces/sandboxed-job-processor.d.ts

@@ -2,4 +2,4 @@ import { SandboxedJob } from './sandboxed-job';
 /**
  * @see {@link https://docs.bullmq.io/guide/workers/sandboxed-processors}
  */
-export declare type SandboxedJobProcessor<T = any, R = any> = ((job: SandboxedJob<T, R>) => R | PromiseLike<R>) | ((job: SandboxedJob<T, R>, callback: (error: unknown, result: R) => void) => void);
+export type SandboxedJobProcessor<T = any, R = any> = ((job: SandboxedJob<T, R>) => R | PromiseLike<R>) | ((job: SandboxedJob<T, R>, callback: (error: unknown, result: R) => void) => void);

package/dist/cjs/interfaces/worker-options.d.ts

@@ -6,7 +6,7 @@ import { MetricsOptions } from './metrics-options';
 /**
  * An async function that receives `Job`s and handles them.
  */
-export declare type Processor<T = any, R = any, N extends string = string> = (job: Job<T, R, N>, token?: string) => Promise<R>;
+export type Processor<T = any, R = any, N extends string = string> = (job: Job<T, R, N>, token?: string) => Promise<R>;
 export interface WorkerOptions extends QueueBaseOptions {
     /**
      * Condition to start processor at instance creation.

package/dist/cjs/scripts/addJob-8.js

@@ -91,14 +91,14 @@ end
   Function to return the next delayed job timestamp.
 ]] 
 local function getNextDelayedTimestamp(delayedKey)
-    local result = rcall("ZRANGE", delayedKey, 0, 0, "WITHSCORES")
-    if #result then
-      local nextTimestamp = tonumber(result[2])
-      if (nextTimestamp ~= nil) then 
-        nextTimestamp = nextTimestamp / 0x1000
-      end
-      return nextTimestamp
+  local result = rcall("ZRANGE", delayedKey, 0, 0, "WITHSCORES")
+  if #result then
+    local nextTimestamp = tonumber(result[2])
+    if (nextTimestamp ~= nil) then 
+      nextTimestamp = nextTimestamp / 0x1000
     end
+    return nextTimestamp
+  end
 end
 if parentKey ~= nil then
   if rcall("EXISTS", parentKey) ~= 1 then
@@ -154,21 +154,21 @@ if args[2] == "" then
 else
   jobId = args[2]
   jobIdKey = args[1] .. jobId
-  if rcall("EXISTS", jobIdKey) == 1 then
-    if parentKey ~= nil then
-      if rcall("ZSCORE", KEYS[7], jobId) ~= false then
-        local returnvalue = rcall("HGET", jobIdKey, "returnvalue")
-        updateParentDepsIfNeeded(parentKey, parent['queueKey'], parentDependenciesKey,
-          parent['id'], jobIdKey, returnvalue, timestamp)
-      else
-        if parentDependenciesKey ~= nil then
-          rcall("SADD", parentDependenciesKey, jobIdKey)
-        end
+end
+if rcall("EXISTS", jobIdKey) == 1 then
+  if parentKey ~= nil then
+    if rcall("ZSCORE", KEYS[7], jobId) ~= false then
+      local returnvalue = rcall("HGET", jobIdKey, "returnvalue")
+      updateParentDepsIfNeeded(parentKey, parent['queueKey'], parentDependenciesKey,
+        parent['id'], jobIdKey, returnvalue, timestamp)
+    else
+      if parentDependenciesKey ~= nil then
+        rcall("SADD", parentDependenciesKey, jobIdKey)
       end
-      rcall("HMSET", jobIdKey, "parentKey", parentKey, "parent", parentData)
     end
-    return jobId .. "" -- convert to string
+    rcall("HMSET", jobIdKey, "parentKey", parentKey, "parent", parentData)
   end
+  return jobId .. "" -- convert to string
 end
 -- Store the job.
 local jsonOpts = cjson.encode(opts)
@@ -193,42 +193,42 @@ local delayedTimestamp = (delay > 0 and (timestamp + delay)) or 0
 -- Check if job is a parent, if so add to the parents set
 local waitChildrenKey = args[6]
 if waitChildrenKey ~= nil then
-    rcall("ZADD", waitChildrenKey, timestamp, jobId)
-    rcall("XADD", KEYS[8], "*", "event", "waiting-children", "jobId", jobId)
+  rcall("ZADD", waitChildrenKey, timestamp, jobId)
+  rcall("XADD", KEYS[8], "*", "event", "waiting-children", "jobId", jobId)
 elseif (delayedTimestamp ~= 0) then
-    local score = delayedTimestamp * 0x1000 + bit.band(jobCounter, 0xfff)
-    rcall("ZADD", KEYS[5], score, jobId)
-    rcall("XADD", KEYS[8], "*", "event", "delayed", "jobId", jobId, "delay",
-          delayedTimestamp)
-    -- If wait list is empty, and this delayed job is the next one to be processed,
-    -- then we need to signal the workers by adding a dummy job (jobId 0:delay) to the wait list.
-    local target = getTargetQueueList(KEYS[3], KEYS[1], KEYS[2])
-    if rcall("LLEN", target) == 0 then
-      local nextTimestamp = getNextDelayedTimestamp(KEYS[5])
-      if not nextTimestamp or (delayedTimestamp < nextTimestamp) then
-        local delay = delayedTimestamp - tonumber(timestamp)
-        rcall("LPUSH", target, "0:" .. delay)
-      end
+  local score = delayedTimestamp * 0x1000 + bit.band(jobCounter, 0xfff)
+  rcall("ZADD", KEYS[5], score, jobId)
+  rcall("XADD", KEYS[8], "*", "event", "delayed", "jobId", jobId, "delay",
+        delayedTimestamp)
+  -- If wait list is empty, and this delayed job is the next one to be processed,
+  -- then we need to signal the workers by adding a dummy job (jobId 0:delay) to the wait list.
+  local target = getTargetQueueList(KEYS[3], KEYS[1], KEYS[2])
+  if rcall("LLEN", target) == 0 then
+    local nextTimestamp = getNextDelayedTimestamp(KEYS[5])
+    if not nextTimestamp or (delayedTimestamp < nextTimestamp) then
+      local delay = delayedTimestamp - tonumber(timestamp)
+      rcall("LPUSH", target, "0:" .. delay)
     end
+  end
 else
-    local target = getTargetQueueList(KEYS[3], KEYS[1], KEYS[2])
-    -- Standard or priority add
-    if priority == 0 then
-        -- LIFO or FIFO
-        local pushCmd = opts['lifo'] and 'RPUSH' or 'LPUSH';
-        rcall(pushCmd, target, jobId)
-    else
-        -- Priority add
-        addJobWithPriority(KEYS[6], priority, target, jobId)
-    end
-    -- Emit waiting event
-    rcall("XADD", KEYS[8], "*", "event", "waiting", "jobId", jobId)
+  local target = getTargetQueueList(KEYS[3], KEYS[1], KEYS[2])
+  -- Standard or priority add
+  if priority == 0 then
+    -- LIFO or FIFO
+    local pushCmd = opts['lifo'] and 'RPUSH' or 'LPUSH';
+    rcall(pushCmd, target, jobId)
+  else
+    -- Priority add
+    addJobWithPriority(KEYS[6], priority, target, jobId)
+  end
+  -- Emit waiting event
+  rcall("XADD", KEYS[8], "*", "event", "waiting", "jobId", jobId)
 end
 -- Check if this job is a child of another job, if so add it to the parents dependencies
 -- TODO: Should not be possible to add a child job to a parent that is not in the "waiting-children" status.
 -- fail in this case.
 if parentDependenciesKey ~= nil then
-    rcall("SADD", parentDependenciesKey, jobIdKey)
+  rcall("SADD", parentDependenciesKey, jobIdKey)
 end
 return jobId .. "" -- convert to string
 `;

package/dist/cjs/scripts/moveToActive-9.js

@@ -52,6 +52,8 @@ local function moveJobFromWaitToActive(keys, keyPrefix, jobId, processedOn, opts
   local expireTime
   if(maxJobs) then
     local rateLimiterKey = keys[6];
+    expireTime = tonumber(rcall("PTTL", rateLimiterKey))
+    if expireTime == 0 then rcall("DEL", rateLimiterKey) end
     local jobCounter = tonumber(rcall("INCR", rateLimiterKey))
     if jobCounter == 1 then
       local limiterDuration = opts['limiter'] and opts['limiter']['duration']
@@ -87,14 +89,14 @@ end
   Function to return the next delayed job timestamp.
 ]] 
 local function getNextDelayedTimestamp(delayedKey)
-    local result = rcall("ZRANGE", delayedKey, 0, 0, "WITHSCORES")
-    if #result then
-      local nextTimestamp = tonumber(result[2])
-      if (nextTimestamp ~= nil) then 
-        nextTimestamp = nextTimestamp / 0x1000
-      end
-      return nextTimestamp
+  local result = rcall("ZRANGE", delayedKey, 0, 0, "WITHSCORES")
+  if #result then
+    local nextTimestamp = tonumber(result[2])
+    if (nextTimestamp ~= nil) then 
+      nextTimestamp = nextTimestamp / 0x1000
     end
+    return nextTimestamp
+  end
 end
 --[[
   Updates the delay set, by moving delayed jobs that should
@@ -154,17 +156,17 @@ local function promoteDelayedJobs(delayedKey, waitKey, priorityKey, pausedKey,
     end
 end
 local function getRateLimitTTL(opts, limiterKey)
-    local maxJobs = tonumber(opts['limiter'] and opts['limiter']['max'])
-    if maxJobs then
-        local jobCounter = tonumber(rcall("GET", limiterKey))
-        if jobCounter ~= nil and jobCounter >= maxJobs then
-            local pttl = rcall("PTTL", KEYS[6])
-            if pttl > 0 then 
-                return pttl 
-            end
-        end
+  local maxJobs = tonumber(opts['limiter'] and opts['limiter']['max'])
+  if maxJobs then
+    local jobCounter = tonumber(rcall("GET", limiterKey))
+    if jobCounter ~= nil and jobCounter >= maxJobs then
+      local pttl = rcall("PTTL", KEYS[6])
+      if pttl > 0 then 
+        return pttl 
+      end
     end
-    return 0
+  end
+  return 0
 end
 -- Check if there are delayed jobs that we can move to wait.
 promoteDelayedJobs(KEYS[7], KEYS[1], KEYS[3], KEYS[8], KEYS[9], KEYS[4], ARGV[1], ARGV[2])

package/dist/cjs/scripts/moveToActive-9.js.map

@@ -1 +1 @@
-{"version":3,"file":"moveToActive-9.js","sourceRoot":"","sources":["../../../src/scripts/moveToActive-9.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwMf,CAAC;AACW,QAAA,YAAY,GAAG;IAC1B,IAAI,EAAE,cAAc;IACpB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}
+{"version":3,"file":"moveToActive-9.js","sourceRoot":"","sources":["../../../src/scripts/moveToActive-9.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0Mf,CAAC;AACW,QAAA,YAAY,GAAG;IAC1B,IAAI,EAAE,cAAc;IACpB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

package/dist/cjs/scripts/moveToDelayed-8.js

@@ -87,14 +87,14 @@ end
   Function to return the next delayed job timestamp.
 ]] 
 local function getNextDelayedTimestamp(delayedKey)
-    local result = rcall("ZRANGE", delayedKey, 0, 0, "WITHSCORES")
-    if #result then
-      local nextTimestamp = tonumber(result[2])
-      if (nextTimestamp ~= nil) then 
-        nextTimestamp = nextTimestamp / 0x1000
-      end
-      return nextTimestamp
+  local result = rcall("ZRANGE", delayedKey, 0, 0, "WITHSCORES")
+  if #result then
+    local nextTimestamp = tonumber(result[2])
+    if (nextTimestamp ~= nil) then 
+      nextTimestamp = nextTimestamp / 0x1000
     end
+    return nextTimestamp
+  end
 end
 local jobKey = KEYS[5]
 if rcall("EXISTS", jobKey) == 1 then

package/dist/cjs/scripts/moveToFinished-12.js

@@ -108,14 +108,14 @@ end
   Function to return the next delayed job timestamp.
 ]] 
 local function getNextDelayedTimestamp(delayedKey)
-    local result = rcall("ZRANGE", delayedKey, 0, 0, "WITHSCORES")
-    if #result then
-      local nextTimestamp = tonumber(result[2])
-      if (nextTimestamp ~= nil) then 
-        nextTimestamp = nextTimestamp / 0x1000
-      end
-      return nextTimestamp
+  local result = rcall("ZRANGE", delayedKey, 0, 0, "WITHSCORES")
+  if #result then
+    local nextTimestamp = tonumber(result[2])
+    if (nextTimestamp ~= nil) then 
+      nextTimestamp = nextTimestamp / 0x1000
     end
+    return nextTimestamp
+  end
 end
 --[[
   Function to move job from wait state to active.
@@ -138,6 +138,8 @@ local function moveJobFromWaitToActive(keys, keyPrefix, jobId, processedOn, opts
   local expireTime
   if(maxJobs) then
     local rateLimiterKey = keys[6];
+    expireTime = tonumber(rcall("PTTL", rateLimiterKey))
+    if expireTime == 0 then rcall("DEL", rateLimiterKey) end
     local jobCounter = tonumber(rcall("INCR", rateLimiterKey))
     if jobCounter == 1 then
       local limiterDuration = opts['limiter'] and opts['limiter']['duration']
@@ -414,17 +416,17 @@ local function updateParentDepsIfNeeded(parentKey, parentQueueKey, parentDepende
   end
 end
 local function getRateLimitTTL(opts, limiterKey)
-    local maxJobs = tonumber(opts['limiter'] and opts['limiter']['max'])
-    if maxJobs then
-        local jobCounter = tonumber(rcall("GET", limiterKey))
-        if jobCounter ~= nil and jobCounter >= maxJobs then
-            local pttl = rcall("PTTL", KEYS[6])
-            if pttl > 0 then 
-                return pttl 
-            end
-        end
+  local maxJobs = tonumber(opts['limiter'] and opts['limiter']['max'])
+  if maxJobs then
+    local jobCounter = tonumber(rcall("GET", limiterKey))
+    if jobCounter ~= nil and jobCounter >= maxJobs then
+      local pttl = rcall("PTTL", KEYS[6])
+      if pttl > 0 then 
+        return pttl 
+      end
     end
-    return 0
+  end
+  return 0
 end
 local jobIdKey = KEYS[10]
 if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists

package/dist/cjs/scripts/moveToFinished-12.js.map

@@ -1 +1 @@
-{"version":3,"file":"moveToFinished-12.js","sourceRoot":"","sources":["../../../src/scripts/moveToFinished-12.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0iBf,CAAC;AACW,QAAA,cAAc,GAAG;IAC5B,IAAI,EAAE,gBAAgB;IACtB,OAAO;IACP,IAAI,EAAE,EAAE;CACT,CAAC"}
+{"version":3,"file":"moveToFinished-12.js","sourceRoot":"","sources":["../../../src/scripts/moveToFinished-12.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4iBf,CAAC;AACW,QAAA,cAAc,GAAG;IAC5B,IAAI,EAAE,gBAAgB;IACtB,OAAO;IACP,IAAI,EAAE,EAAE;CACT,CAAC"}

package/dist/cjs/scripts/removeJob-1.js

@@ -34,19 +34,19 @@ local function isLocked( prefix, jobId)
   local lockKey = jobKey .. ':lock'
   local lock = rcall("GET", lockKey)
   if not lock then
-      local dependencies = rcall("SMEMBERS", jobKey .. ":dependencies")
-      if (#dependencies > 0) then
-          for i, childJobKey in ipairs(dependencies) do
-              -- We need to get the jobId for this job.
-              local childJobId = getJobIdFromKey(childJobKey)
-              local childJobPrefix = getJobKeyPrefix(childJobKey, childJobId)
-              local result = isLocked( childJobPrefix, childJobId )
-              if result then
-                  return true
-              end
-          end
+    local dependencies = rcall("SMEMBERS", jobKey .. ":dependencies")
+    if (#dependencies > 0) then
+      for i, childJobKey in ipairs(dependencies) do
+        -- We need to get the jobId for this job.
+        local childJobId = getJobIdFromKey(childJobKey)
+        local childJobPrefix = getJobKeyPrefix(childJobKey, childJobId)
+        local result = isLocked( childJobPrefix, childJobId )
+        if result then
+          return true
+        end
       end
-      return false
+    end
+    return false
   end
   return true
 end

package/dist/cjs/types/backoff-strategy.d.ts

@@ -1,2 +1,2 @@
 import { Job } from '../classes/job';
-export declare type BackoffStrategy = (attemptsMade?: number, type?: string, err?: Error, job?: Job) => Promise<number> | number;
+export type BackoffStrategy = (attemptsMade?: number, type?: string, err?: Error, job?: Job) => Promise<number> | number;

package/dist/cjs/types/finished-status.d.ts

@@ -1,2 +1,2 @@
-export declare type FinishedStatus = 'completed' | 'failed';
-export declare type FinishedPropValAttribute = 'returnvalue' | 'failedReason';
+export type FinishedStatus = 'completed' | 'failed';
+export type FinishedPropValAttribute = 'returnvalue' | 'failedReason';

package/dist/cjs/types/job-json-sandbox.d.ts

@@ -1,5 +1,5 @@
 import { JobJson } from '../interfaces';
-export declare type JobJsonSandbox = JobJson & {
+export type JobJsonSandbox = JobJson & {
     queueName: string;
     prefix: string;
 };

package/dist/cjs/types/job-options.d.ts

@@ -1,5 +1,5 @@
 import { BaseJobOptions } from '../interfaces';
-export declare type JobsOptions = BaseJobOptions & {
+export type JobsOptions = BaseJobOptions & {
     /**
      * If true, moves parent to failed.
      */
@@ -8,7 +8,7 @@ export declare type JobsOptions = BaseJobOptions & {
 /**
  * These fields are the ones stored in Redis with smaller keys for compactness.
  */
-export declare type RedisJobOptions = BaseJobOptions & {
+export type RedisJobOptions = BaseJobOptions & {
     /**
      * If true, moves parent to failed.
      */

package/dist/cjs/types/job-type.d.ts

@@ -1,3 +1,3 @@
 import { FinishedStatus } from './finished-status';
-export declare type JobState = FinishedStatus | 'active' | 'delayed' | 'waiting' | 'waiting-children';
-export declare type JobType = JobState | 'paused' | 'repeat' | 'wait';
+export type JobState = FinishedStatus | 'active' | 'delayed' | 'waiting' | 'waiting-children';
+export type JobType = JobState | 'paused' | 'repeat' | 'wait';

package/dist/cjs/types/repeat-strategy.d.ts

@@ -1,2 +1,2 @@
 import { RepeatOptions } from '../interfaces/repeat-options';
-export declare type RepeatStrategy = (millis: number, opts: RepeatOptions, name?: string) => number;
+export type RepeatStrategy = (millis: number, opts: RepeatOptions, name?: string) => number;

package/dist/esm/classes/job.d.ts

@@ -3,7 +3,7 @@ import { JobJson, JobJsonRaw, ParentKeys, RedisClient } from '../interfaces';
 import { FinishedStatus, JobsOptions, JobState, JobJsonSandbox } from '../types';
 import { QueueEvents } from './queue-events';
 import { MinimalQueue, ParentOpts, Scripts } from './scripts';
-export declare type BulkJobOptions = Omit<JobsOptions, 'repeat'>;
+export type BulkJobOptions = Omit<JobsOptions, 'repeat'>;
 export interface MoveToWaitingChildrenOpts {
     child?: {
         id: string;

package/dist/esm/classes/queue-getters.d.ts

@@ -65,56 +65,55 @@ export declare class QueueGetters<DataType, ResultType, NameType extends string>
     getWaitingChildrenCount(): Promise<number>;
     /**
      * Returns the jobs that are in the "waiting" status.
-     * @param start zero based index from where to start returning jobs.
-     * @param end zeroo based index where to stop returning jobs.
-  
-    */
+     * @param start - zero based index from where to start returning jobs.
+     * @param end - zero based index where to stop returning jobs.
+     */
     getWaiting(start?: number, end?: number): Promise<Job<DataType, ResultType, NameType>[]>;
     /**
      * Returns the jobs that are in the "waiting" status.
-     * @param start zero based index from where to start returning jobs.
-     * @param end zeroo based index where to stop returning jobs.
+     * @param start - zero based index from where to start returning jobs.
+     * @param end - zero based index where to stop returning jobs.
      */
     getWaitingChildren(start?: number, end?: number): Promise<Job<DataType, ResultType, NameType>[]>;
     /**
      * Returns the jobs that are in the "active" status.
-     * @param start zero based index from where to start returning jobs.
-     * @param end zeroo based index where to stop returning jobs.
+     * @param start - zero based index from where to start returning jobs.
+     * @param end - zero based index where to stop returning jobs.
      */
     getActive(start?: number, end?: number): Promise<Job<DataType, ResultType, NameType>[]>;
     /**
      * Returns the jobs that are in the "delayed" status.
-     * @param start zero based index from where to start returning jobs.
-     * @param end zeroo based index where to stop returning jobs.
+     * @param start - zero based index from where to start returning jobs.
+     * @param end - zero based index where to stop returning jobs.
      */
     getDelayed(start?: number, end?: number): Promise<Job<DataType, ResultType, NameType>[]>;
     /**
      * Returns the jobs that are in the "completed" status.
-     * @param start zero based index from where to start returning jobs.
-     * @param end zeroo based index where to stop returning jobs.
+     * @param start - zero based index from where to start returning jobs.
+     * @param end - zero based index where to stop returning jobs.
      */
     getCompleted(start?: number, end?: number): Promise<Job<DataType, ResultType, NameType>[]>;
     /**
      * Returns the jobs that are in the "failed" status.
-     * @param start zero based index from where to start returning jobs.
-     * @param end zeroo based index where to stop returning jobs.
+     * @param start - zero based index from where to start returning jobs.
+     * @param end - zero based index where to stop returning jobs.
      */
     getFailed(start?: number, end?: number): Promise<Job<DataType, ResultType, NameType>[]>;
     getRanges(types: JobType[], start?: number, end?: number, asc?: boolean): Promise<string[]>;
     /**
      * Returns the jobs that are on the given statuses (note that JobType is synonym for job status)
-     * @param types the statuses of the jobs to return.
-     * @param start zero based index from where to start returning jobs.
-     * @param end zeroo based index where to stop returning jobs.
-     * @param asc if true, the jobs will be returned in ascending order.
+     * @param types - the statuses of the jobs to return.
+     * @param start - zero based index from where to start returning jobs.
+     * @param end - zero based index where to stop returning jobs.
+     * @param asc - if true, the jobs will be returned in ascending order.
      */
     getJobs(types?: JobType[] | JobType, start?: number, end?: number, asc?: boolean): Promise<Job<DataType, ResultType, NameType>[]>;
     /**
      * Returns the logs for a given Job.
-     * @param jobId the id of the job to get the logs for.
-     * @param start zero based index from where to start returning jobs.
-     * @param end zeroo based index where to stop returning jobs.
-     * @param asc if true, the jobs will be returned in ascending order.
+     * @param jobId - the id of the job to get the logs for.
+     * @param start - zero based index from where to start returning jobs.
+     * @param end - zero based index where to stop returning jobs.
+     * @param asc - if true, the jobs will be returned in ascending order.
      */
     getJobLogs(jobId: string, start?: number, end?: number, asc?: boolean): Promise<{
         logs: string[];