bullmq 3.2.2 → 3.2.4

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

@@ -88,14 +88,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
@@ -151,21 +151,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)
@@ -190,42 +190,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/esm/scripts/moveToActive-9.js

@@ -49,6 +49,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']
@@ -84,14 +86,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
@@ -151,17 +153,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/esm/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;AACF,MAAM,CAAC,MAAM,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;AACF,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,IAAI,EAAE,cAAc;IACpB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

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

@@ -84,14 +84,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/esm/scripts/moveToFinished-12.js

@@ -105,14 +105,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.
@@ -135,6 +135,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']
@@ -411,17 +413,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/esm/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;AACF,MAAM,CAAC,MAAM,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;AACF,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,IAAI,EAAE,gBAAgB;IACtB,OAAO;IACP,IAAI,EAAE,EAAE;CACT,CAAC"}

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

@@ -31,19 +31,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/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bullmq",
-  "version": "3.2.2",
+  "version": "3.2.4",
   "description": "Queue for messages and jobs based on Redis",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",