bullmq 3.1.2 → 3.2.0

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

@@ -110,7 +110,7 @@ local jobCounter = rcall("INCR", KEYS[4])
 ]]
 -- Includes
 local function updateParentDepsIfNeeded(parentKey, parentQueueKey, parentDependenciesKey,
-  parentId, jobIdKey, returnvalue )
+  parentId, jobIdKey, returnvalue, timestamp )
   local processedSet = parentKey .. ":processed"
   rcall("HSET", processedSet, jobIdKey, returnvalue)
   local activeParent = rcall("ZSCORE", parentQueueKey .. ":waiting-children", parentId)
@@ -118,9 +118,22 @@ local function updateParentDepsIfNeeded(parentKey, parentQueueKey, parentDepende
     rcall("ZREM", parentQueueKey .. ":waiting-children", parentId)
     local parentTarget = getTargetQueueList(parentQueueKey .. ":meta", parentQueueKey .. ":wait",
       parentQueueKey .. ":paused")
-    local priority = tonumber(rcall("HGET", parentKey, "priority"))
+    local jobAttributes = rcall("HMGET", parentKey, "priority", "delay")
+    local priority = tonumber(jobAttributes[1]) or 0
+    local delay = tonumber(jobAttributes[2]) or 0
+    if delay > 0 then
+      local delayedTimestamp = tonumber(timestamp) + delay 
+      local score = delayedTimestamp * 0x1000
+      local parentDelayedKey = parentQueueKey .. ":delayed" 
+      rcall("ZADD", parentDelayedKey, score, parentId)
+      if rcall("LLEN", parentTarget) == 0 then
+        local nextTimestamp = getNextDelayedTimestamp(parentDelayedKey)
+        if not nextTimestamp or (delayedTimestamp <= nextTimestamp) then
+          rcall("LPUSH", parentTarget, "0:" .. delayedTimestamp - tonumber(timestamp))
+        end
+      end
     -- Standard or priority add
-    if priority == 0 then
+    elseif priority == 0 then
       rcall("RPUSH", parentTarget, parentId)
     else
       addJobWithPriority(parentQueueKey .. ":priority", priority, parentTarget, parentId)
@@ -131,6 +144,7 @@ end
 -- Trim events before emiting them to avoid trimming events emitted in this script
 trimEvents(KEYS[3], KEYS[8])
 local parentDependenciesKey = args[7]
+local timestamp = args[4]
 if args[2] == "" then
   jobId = jobCounter
   jobIdKey = args[1] .. jobId
@@ -142,7 +156,7 @@ else
       if rcall("ZSCORE", KEYS[7], jobId) ~= false then
         local returnvalue = rcall("HGET", jobIdKey, "returnvalue")
         updateParentDepsIfNeeded(parentKey, parent['queueKey'], parentDependenciesKey,
-          parent['id'], jobIdKey, returnvalue)
+          parent['id'], jobIdKey, returnvalue, timestamp)
       else
         if parentDependenciesKey ~= nil then
           rcall("SADD", parentDependenciesKey, jobIdKey)
@@ -157,7 +171,6 @@ end
 local jsonOpts = cjson.encode(opts)
 local delay = opts['delay'] or 0
 local priority = opts['priority'] or 0
-local timestamp = args[4]
 local optionalValues = {}
 if parentKey ~= nil then
   table.insert(optionalValues, "parentKey")
@@ -180,17 +193,18 @@ if waitChildrenKey ~= nil then
     rcall("ZADD", waitChildrenKey, timestamp, jobId)
     rcall("XADD", KEYS[8], "*", "event", "waiting-children", "jobId", jobId)
 elseif (delayedTimestamp ~= 0) then
-    local timestamp = delayedTimestamp * 0x1000 + bit.band(jobCounter, 0xfff)
-    rcall("ZADD", KEYS[5], timestamp, jobId)
+    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) to the wait list.
+    -- 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 delayedTimestamp < nextTimestamp then
-        rcall("LPUSH", target, 0)
+      if not nextTimestamp or (delayedTimestamp < nextTimestamp) then
+        local delay = delayedTimestamp - tonumber(timestamp)
+        rcall("LPUSH", target, "0:" .. delay)
       end
     end
 else

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

@@ -1 +1 @@
-{"version":3,"file":"addJob-8.js","sourceRoot":"","sources":["../../../src/scripts/addJob-8.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwNf,CAAC;AACF,MAAM,CAAC,MAAM,MAAM,GAAG;IACpB,IAAI,EAAE,QAAQ;IACd,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}
+{"version":3,"file":"addJob-8.js","sourceRoot":"","sources":["../../../src/scripts/addJob-8.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsOf,CAAC;AACF,MAAM,CAAC,MAAM,MAAM,GAAG;IACpB,IAAI,EAAE,QAAQ;IACd,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

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

@@ -189,11 +189,11 @@ local function trimEvents(metaKey, eventStreamKey)
   end
 end
 -- Check if we need to check for stalled jobs now.
-local function checkStalledJobs(stalledKey, waitKey, activeKey, failedKey, stalledCheckKey,
-    metaKey, pausedKey, eventStreamKey, maxStalledJobCount, queueKeyPrefix, timestamp, maxCheckTime)
-    if rcall("EXISTS", stalledCheckKey) == 1 then 
-        return {{}, {}}
-    end
+local function checkStalledJobs(stalledKey, waitKey, activeKey, failedKey,
+                                stalledCheckKey, metaKey, pausedKey,
+                                eventStreamKey, maxStalledJobCount,
+                                queueKeyPrefix, timestamp, maxCheckTime)
+    if rcall("EXISTS", stalledCheckKey) == 1 then return {{}, {}} end
     rcall("SET", stalledCheckKey, timestamp, "PX", maxCheckTime)
     -- Trim events before emiting them to avoid trimming events emitted in this script
     trimEvents(metaKey, eventStreamKey)
@@ -206,7 +206,7 @@ local function checkStalledJobs(stalledKey, waitKey, activeKey, failedKey, stall
         local MAX_STALLED_JOB_COUNT = tonumber(maxStalledJobCount)
         -- Remove from active list
         for i, jobId in ipairs(stalling) do
-            if jobId == '0' then
+            if string.sub(jobId, 1, 2) == "0:" then
                 -- If the jobId is a delay marker ID we just remove it.
                 local removed = rcall("LREM", activeKey, 1, jobId)
             else
@@ -227,13 +227,13 @@ local function checkStalledJobs(stalledKey, waitKey, activeKey, failedKey, stall
                             local failedReason =
                                 "job stalled more than allowable limit"
                             rcall("HMSET", jobKey, "failedReason", failedReason,
-                                "finishedOn", timestamp)
-                            rcall("XADD", eventStreamKey, "*", "event", "failed", "jobId",
-                                jobId, 'prev', 'active', 'failedReason',
-                                failedReason)
+                                  "finishedOn", timestamp)
+                            rcall("XADD", eventStreamKey, "*", "event",
+                                  "failed", "jobId", jobId, 'prev', 'active',
+                                  'failedReason', failedReason)
                             if removeOnFailType == "number" then
-                                removeJobsByMaxCount(opts["removeOnFail"], failedKey,
-                                                    queueKeyPrefix)
+                                removeJobsByMaxCount(opts["removeOnFail"],
+                                                     failedKey, queueKeyPrefix)
                             elseif removeOnFailType == "boolean" then
                                 if opts["removeOnFail"] then
                                     removeJob(jobId, false, queueKeyPrefix)
@@ -243,24 +243,25 @@ local function checkStalledJobs(stalledKey, waitKey, activeKey, failedKey, stall
                                 local maxAge = opts["removeOnFail"]["age"]
                                 local maxCount = opts["removeOnFail"]["count"]
                                 if maxAge ~= nil then
-                                    removeJobsByMaxAge(timestamp, maxAge, failedKey,
-                                                    queueKeyPrefix)
+                                    removeJobsByMaxAge(timestamp, maxAge,
+                                                       failedKey, queueKeyPrefix)
                                 end
                                 if maxCount ~= nil and maxCount > 0 then
-                                    removeJobsByMaxCount(maxCount, failedKey, queueKeyPrefix)
+                                    removeJobsByMaxCount(maxCount, failedKey,
+                                                         queueKeyPrefix)
                                 end
                             end
                             table.insert(failed, jobId)
                         else
-                            local target = getTargetQueueList(metaKey, waitKey,
-                                                            pausedKey)
+                            local target =
+                                getTargetQueueList(metaKey, waitKey, pausedKey)
                             -- Move the job back to the wait queue, to immediately be picked up by a waiting worker.
                             rcall("RPUSH", target, jobId)
-                            rcall("XADD", eventStreamKey, "*", "event", "waiting", "jobId",
-                                jobId, 'prev', 'active')
+                            rcall("XADD", eventStreamKey, "*", "event",
+                                  "waiting", "jobId", jobId, 'prev', 'active')
                             -- Emit the stalled event
-                            rcall("XADD", eventStreamKey, "*", "event", "stalled", "jobId",
-                                jobId)
+                            rcall("XADD", eventStreamKey, "*", "event",
+                                  "stalled", "jobId", jobId)
                             table.insert(stalled, jobId)
                         end
                     end

package/dist/esm/scripts/moveStalledJobsToWait-8.js.map

@@ -1 +1 @@
-{"version":3,"file":"moveStalledJobsToWait-8.js","sourceRoot":"","sources":["../../../src/scripts/moveStalledJobsToWait-8.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyRf,CAAC;AACF,MAAM,CAAC,MAAM,qBAAqB,GAAG;IACnC,IAAI,EAAE,uBAAuB;IAC7B,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}
+{"version":3,"file":"moveStalledJobsToWait-8.js","sourceRoot":"","sources":["../../../src/scripts/moveStalledJobsToWait-8.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0Rf,CAAC;AACF,MAAM,CAAC,MAAM,qBAAqB,GAAG;IACnC,IAAI,EAAE,uBAAuB;IAC7B,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

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

@@ -126,8 +126,7 @@ local function getTargetQueueList(queueMetaKey, waitKey, pausedKey)
     return pausedKey
   end
 end
--- Try to get as much as 1000 jobs at once, and returns the nextTimestamp if
--- there are more delayed jobs to process.
+-- Try to get as much as 1000 jobs at once
 local function promoteDelayedJobs(delayedKey, waitKey, priorityKey, pausedKey,
                                   metaKey, eventStreamKey, prefix, timestamp)
     local jobs = rcall("ZRANGEBYSCORE", delayedKey, 0, (timestamp + 1) * 0x1000, "LIMIT", 0, 1000)
@@ -181,13 +180,18 @@ else
     -- no job ID, try non-blocking move from wait to active
     jobId = rcall("RPOPLPUSH", KEYS[1], KEYS[2])
 end
--- If jobId is special ID 0, then there is no job to process
-if jobId == "0" then
-    rcall("LREM", KEYS[2], 1, 0)
-elseif jobId then
-    opts = opts or cmsgpack.unpack(ARGV[4])
-    -- this script is not really moving, it is preparing the job for processing
-    return moveJobFromWaitToActive(KEYS, ARGV[1], jobId, ARGV[2], opts)
+-- If jobId is special ID 0:delay, then there is no job to process
+if jobId then 
+    if string.sub(jobId, 1, 2) == "0:" then
+        rcall("LREM", KEYS[2], 1, jobId)
+        -- Move again since we just got the marker job.
+        jobId = rcall("RPOPLPUSH", KEYS[1], KEYS[2])
+    end
+    if jobId then
+        opts = opts or cmsgpack.unpack(ARGV[4])
+        -- this script is not really moving, it is preparing the job for processing
+        return moveJobFromWaitToActive(KEYS, ARGV[1], jobId, ARGV[2], opts)
+    end
 end
 -- Return the timestamp for the next delayed job if any.
 local nextTimestamp = getNextDelayedTimestamp(KEYS[7])

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoMf,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwMf,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

@@ -56,8 +56,7 @@ local function getTargetQueueList(queueMetaKey, waitKey, pausedKey)
     return pausedKey
   end
 end
--- Try to get as much as 1000 jobs at once, and returns the nextTimestamp if
--- there are more delayed jobs to process.
+-- Try to get as much as 1000 jobs at once
 local function promoteDelayedJobs(delayedKey, waitKey, priorityKey, pausedKey,
                                   metaKey, eventStreamKey, prefix, timestamp)
     local jobs = rcall("ZRANGEBYSCORE", delayedKey, 0, (timestamp + 1) * 0x1000, "LIMIT", 0, 1000)
@@ -81,28 +80,50 @@ local function promoteDelayedJobs(delayedKey, waitKey, priorityKey, pausedKey,
         end
     end
 end
-promoteDelayedJobs(KEYS[4], KEYS[1], KEYS[3], KEYS[7], KEYS[8], KEYS[6], ARGV[1], ARGV[2])
-if rcall("EXISTS", KEYS[5]) == 1 then
-  if ARGV[5] ~= "0" then
-    local lockKey = KEYS[5] .. ':lock'
-    if rcall("GET", lockKey) == ARGV[5] then
-      rcall("DEL", lockKey)
-    else
-      return -2
+--[[
+  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
     end
-  end
-  local jobId = ARGV[4]
-  local score = tonumber(ARGV[3])
-  local delayedTimestamp = (score / 0x1000)
-  local numRemovedElements = rcall("LREM", KEYS[2], -1, jobId)
-  if(numRemovedElements < 1) then
-    return -3
-  end
-  rcall("ZADD", KEYS[4], score, jobId)
-  rcall("XADD", KEYS[6], "*", "event", "delayed", "jobId", jobId, "delay", delayedTimestamp);
-  return 0
+end
+local jobKey = KEYS[5]
+if rcall("EXISTS", jobKey) == 1 then
+    local delayedKey = KEYS[4]
+    if ARGV[5] ~= "0" then
+        local lockKey = jobKey .. ':lock'
+        if rcall("GET", lockKey) == ARGV[5] then
+            rcall("DEL", lockKey)
+        else
+            return -2
+        end
+    end
+    local jobId = ARGV[4]
+    local score = tonumber(ARGV[3])
+    local delayedTimestamp = (score / 0x1000)
+    local numRemovedElements = rcall("LREM", KEYS[2], -1, jobId)
+    if (numRemovedElements < 1) then 
+      return -3
+    end
+    -- Check if we need to push a marker job to wake up sleeping workers.
+    local target = getTargetQueueList(KEYS[8], KEYS[1], KEYS[7])
+    if rcall("LLEN", target) == 0 then
+        local nextTimestamp = getNextDelayedTimestamp(delayedKey)
+        if not nextTimestamp or (delayedTimestamp < nextTimestamp) then
+            rcall("LPUSH", target, "0:" .. delayedTimestamp - tonumber(ARGV[2]))
+        end
+    end
+    rcall("ZADD", delayedKey, score, jobId)
+    rcall("XADD", KEYS[6], "*", "event", "delayed", "jobId", jobId, "delay", delayedTimestamp)
+    return 0
 else
-  return -1
+    return -1
 end
 `;
 export const moveToDelayed = {

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

@@ -1 +1 @@
-{"version":3,"file":"moveToDelayed-8.js","sourceRoot":"","sources":["../../../src/scripts/moveToDelayed-8.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0Gf,CAAC;AACF,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,IAAI,EAAE,eAAe;IACrB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}
+{"version":3,"file":"moveToDelayed-8.js","sourceRoot":"","sources":["../../../src/scripts/moveToDelayed-8.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+Hf,CAAC;AACF,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,IAAI,EAAE,eAAe;IACrB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

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

@@ -224,8 +224,7 @@ local function getTargetQueueList(queueMetaKey, waitKey, pausedKey)
     return pausedKey
   end
 end
--- Try to get as much as 1000 jobs at once, and returns the nextTimestamp if
--- there are more delayed jobs to process.
+-- Try to get as much as 1000 jobs at once
 local function promoteDelayedJobs(delayedKey, waitKey, priorityKey, pausedKey,
                                   metaKey, eventStreamKey, prefix, timestamp)
     local jobs = rcall("ZRANGEBYSCORE", delayedKey, 0, (timestamp + 1) * 0x1000, "LIMIT", 0, 1000)
@@ -380,7 +379,7 @@ end
 ]]
 -- Includes
 local function updateParentDepsIfNeeded(parentKey, parentQueueKey, parentDependenciesKey,
-  parentId, jobIdKey, returnvalue )
+  parentId, jobIdKey, returnvalue, timestamp )
   local processedSet = parentKey .. ":processed"
   rcall("HSET", processedSet, jobIdKey, returnvalue)
   local activeParent = rcall("ZSCORE", parentQueueKey .. ":waiting-children", parentId)
@@ -388,9 +387,22 @@ local function updateParentDepsIfNeeded(parentKey, parentQueueKey, parentDepende
     rcall("ZREM", parentQueueKey .. ":waiting-children", parentId)
     local parentTarget = getTargetQueueList(parentQueueKey .. ":meta", parentQueueKey .. ":wait",
       parentQueueKey .. ":paused")
-    local priority = tonumber(rcall("HGET", parentKey, "priority"))
+    local jobAttributes = rcall("HMGET", parentKey, "priority", "delay")
+    local priority = tonumber(jobAttributes[1]) or 0
+    local delay = tonumber(jobAttributes[2]) or 0
+    if delay > 0 then
+      local delayedTimestamp = tonumber(timestamp) + delay 
+      local score = delayedTimestamp * 0x1000
+      local parentDelayedKey = parentQueueKey .. ":delayed" 
+      rcall("ZADD", parentDelayedKey, score, parentId)
+      if rcall("LLEN", parentTarget) == 0 then
+        local nextTimestamp = getNextDelayedTimestamp(parentDelayedKey)
+        if not nextTimestamp or (delayedTimestamp <= nextTimestamp) then
+          rcall("LPUSH", parentTarget, "0:" .. delayedTimestamp - tonumber(timestamp))
+        end
+      end
     -- Standard or priority add
-    if priority == 0 then
+    elseif priority == 0 then
       rcall("RPUSH", parentTarget, parentId)
     else
       addJobWithPriority(parentQueueKey .. ":priority", priority, parentTarget, parentId)
@@ -431,7 +443,6 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
             rcall("SREM", KEYS[5], ARGV[1])
         else
             if lockToken then
-                rcall("SET", "DEBUG", lockToken)
                 -- Lock exists but token does not match
                 return -6
             else 
@@ -465,7 +476,7 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
             if rcall("SREM", dependenciesSet, jobIdKey) == 1 then
                 updateParentDepsIfNeeded(parentKey, parentQueueKey,
                                          dependenciesSet, parentId, jobIdKey,
-                                         ARGV[4])
+                                         ARGV[4], timestamp)
             end
         elseif opts['fpof'] then
             moveParentFromWaitingChildrenToFailed(parentQueueKey, parentKey,
@@ -512,11 +523,15 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
         local pttl = getRateLimitTTL(opts, KEYS[6])
         if pttl > 0 then return {0, 0, pttl} end
         jobId = rcall("RPOPLPUSH", KEYS[1], KEYS[2])
-        if jobId == "0" then
-            rcall("LREM", KEYS[2], 1, 0)
-        elseif jobId then
-            return
-                moveJobFromWaitToActive(KEYS, ARGV[8], jobId, timestamp, opts)
+        -- If jobId is special ID 0:delay, then there is no job to process
+        if jobId then 
+            if string.sub(jobId, 1, 2) == "0:" then
+                rcall("LREM", KEYS[2], 1, jobId)
+            else
+                opts = opts or cmsgpack.unpack(ARGV[4])
+                -- this script is not really moving, it is preparing the job for processing
+                return moveJobFromWaitToActive(KEYS, ARGV[8], jobId, timestamp, opts)
+            end
         end
         -- Return the timestamp for the next delayed job if any.
         local nextTimestamp = getNextDelayedTimestamp(KEYS[7])

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2hBf,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0iBf,CAAC;AACF,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,IAAI,EAAE,gBAAgB;IACtB,OAAO;IACP,IAAI,EAAE,EAAE;CACT,CAAC"}

package/dist/esm/scripts/promote-6.js

@@ -45,7 +45,8 @@ if rcall("ZREM", KEYS[1], jobId) == 1 then
   local target = getTargetQueueList(KEYS[4], KEYS[2], KEYS[3])
   -- Remove delayed "marker" from the wait list if there is any.
   -- Since we are adding a job we do not need the marker anymore.
-  if rcall("LINDEX", target, 0) == "0" then
+  local marker = rcall("LINDEX", target, 0)
+  if marker and string.sub(marker, 1, 2) == "0:" then
     rcall("LPOP", target)
   end
   if priority == 0 then

package/dist/esm/scripts/promote-6.js.map

@@ -1 +1 @@
-{"version":3,"file":"promote-6.js","sourceRoot":"","sources":["../../../src/scripts/promote-6.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA+DZ,CAAC;AACL,MAAM,CAAC,MAAM,OAAO,GAAG;IACrB,IAAI,EAAE,SAAS;IACf,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}
+{"version":3,"file":"promote-6.js","sourceRoot":"","sources":["../../../src/scripts/promote-6.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAgEZ,CAAC;AACL,MAAM,CAAC,MAAM,OAAO,GAAG;IACrB,IAAI,EAAE,SAAS;IACf,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

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

@@ -56,8 +56,7 @@ local function addJobWithPriority(priorityKey, priority, targetKey, jobId)
     rcall("RPUSH", targetKey, jobId)
   end
 end
--- Try to get as much as 1000 jobs at once, and returns the nextTimestamp if
--- there are more delayed jobs to process.
+-- Try to get as much as 1000 jobs at once
 local function promoteDelayedJobs(delayedKey, waitKey, priorityKey, pausedKey,
                                   metaKey, eventStreamKey, prefix, timestamp)
     local jobs = rcall("ZRANGEBYSCORE", delayedKey, 0, (timestamp + 1) * 0x1000, "LIMIT", 0, 1000)

package/dist/esm/scripts/retryJob-8.js.map

@@ -1 +1 @@
-{"version":3,"file":"retryJob-8.js","sourceRoot":"","sources":["../../../src/scripts/retryJob-8.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsGf,CAAC;AACF,MAAM,CAAC,MAAM,QAAQ,GAAG;IACtB,IAAI,EAAE,UAAU;IAChB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}
+{"version":3,"file":"retryJob-8.js","sourceRoot":"","sources":["../../../src/scripts/retryJob-8.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqGf,CAAC;AACF,MAAM,CAAC,MAAM,QAAQ,GAAG;IACtB,IAAI,EAAE,UAAU;IAChB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

package/package.json

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