bullmq 4.17.0 → 5.1.0

package/dist/esm/scripts/{moveToActive-10.js → moveToActive-11.js}

@@ -13,15 +13,16 @@ const content = `--[[
     -- Rate limiting
     KEYS[6] rate limiter key
     KEYS[7] delayed key
-    -- Promote delayed jobs
+    -- Delayed jobs
     KEYS[8] paused key
     KEYS[9] meta key
     KEYS[10] pc priority counter
+    -- Marker
+    KEYS[11] marker key
     -- Arguments
     ARGV[1] key prefix
     ARGV[2] timestamp
-    ARGV[3] optional job ID
-    ARGV[4] opts
+    ARGV[3] opts
     opts - token - lock token
     opts - lockDuration
     opts - limiter
@@ -31,7 +32,7 @@ local waitKey = KEYS[1]
 local activeKey = KEYS[2]
 local rateLimiterKey = KEYS[6]
 local delayedKey = KEYS[7]
-local opts = cmsgpack.unpack(ARGV[4])
+local opts = cmsgpack.unpack(ARGV[3])
 -- Includes
 --[[
   Function to return the next delayed job timestamp.
@@ -142,7 +143,7 @@ local function prepareJobForProcessing(keys, keyPrefix, targetKey, jobId, proces
   end
   rcall("XADD", keys[4], "*", "event", "active", "jobId", jobId, "prev", "waiting")
   rcall("HSET", jobKey, "processedOn", processedOn)
-  rcall("HINCRBY", jobKey, "attemptsMade", 1)
+  rcall("HINCRBY", jobKey, "ats", 1)
   return {rcall("HGETALL", jobKey), jobId, 0, 0} -- get job data
 end
 --[[
@@ -155,29 +156,17 @@ end
 --[[
   Function to add job considering priority.
 ]]
--- Includes
---[[
-  Function priority marker to wait if needed
-  in order to wake up our workers and to respect priority
-  order as much as possible
-]]
-local function addPriorityMarkerIfNeeded(waitKey)
-  local waitLen = rcall("LLEN", waitKey)
-  if waitLen == 0 then
-    rcall("LPUSH", waitKey, "0:0")
-  end
-end
-local function addJobWithPriority(waitKey, prioritizedKey, priority, paused, jobId, priorityCounterKey)
+local function addJobWithPriority(markerKey, prioritizedKey, priority, jobId, priorityCounterKey, isPaused)
   local prioCounter = rcall("INCR", priorityCounterKey)
   local score = priority * 0x100000000 + bit.band(prioCounter, 0xffffffffffff)
   rcall("ZADD", prioritizedKey, score, jobId)
-  if not paused then
-    addPriorityMarkerIfNeeded(waitKey)
+  if not isPaused then
+    rcall("ZADD", markerKey, 0, "0")
   end
 end
 -- Try to get as much as 1000 jobs at once
-local function promoteDelayedJobs(delayedKey, waitKey, targetKey, prioritizedKey,
-                                  eventStreamKey, prefix, timestamp, paused, priorityCounterKey)
+local function promoteDelayedJobs(delayedKey, markerKey, targetKey, prioritizedKey,
+                                  eventStreamKey, prefix, timestamp, priorityCounterKey, isPaused)
     local jobs = rcall("ZRANGEBYSCORE", delayedKey, 0, (timestamp + 1) * 0x1000, "LIMIT", 0, 1000)
     if (#jobs > 0) then
         rcall("ZREM", delayedKey, unpack(jobs))
@@ -188,9 +177,12 @@ local function promoteDelayedJobs(delayedKey, waitKey, targetKey, prioritizedKey
             if priority == 0 then
                 -- LIFO or FIFO
                 rcall("LPUSH", targetKey, jobId)
+                if not isPaused then
+                    rcall("ZADD", markerKey, 0, "0")
+                end
             else
-                addJobWithPriority(waitKey, prioritizedKey, priority, paused,
-                  jobId, priorityCounterKey)
+                addJobWithPriority(markerKey, prioritizedKey, priority,
+                  jobId, priorityCounterKey, isPaused)
             end
             -- Emit waiting event
             rcall("XADD", eventStreamKey, "*", "event", "waiting", "jobId",
@@ -201,31 +193,21 @@ local function promoteDelayedJobs(delayedKey, waitKey, targetKey, prioritizedKey
 end
 local target, paused = getTargetQueueList(KEYS[9], waitKey, KEYS[8])
 -- Check if there are delayed jobs that we can move to wait.
-promoteDelayedJobs(delayedKey, waitKey, target, KEYS[3], KEYS[4], ARGV[1],
-                   ARGV[2], paused, KEYS[10])
+local markerKey = KEYS[11]
+promoteDelayedJobs(delayedKey, markerKey, target, KEYS[3], KEYS[4], ARGV[1],
+                   ARGV[2], KEYS[10], paused)
 local maxJobs = tonumber(opts['limiter'] and opts['limiter']['max'])
 local expireTime = getRateLimitTTL(maxJobs, rateLimiterKey)
-local jobId = nil
-if ARGV[3] ~= "" then
-    jobId = ARGV[3]
-    -- clean stalled key
-    rcall("SREM", KEYS[5], jobId)
-end
-if not jobId or (jobId and string.sub(jobId, 1, 2) == "0:") then
-    -- If jobId is special ID 0:delay, then there is no job to process
-    if jobId then rcall("LREM", activeKey, 1, jobId) end
-    -- Check if we are rate limited first.
-    if expireTime > 0 then return {0, 0, expireTime, 0} end
-    -- paused queue
-    if paused then return {0, 0, 0, 0} end
-    -- no job ID, try non-blocking move from wait to active
+-- Check if we are rate limited first.
+if expireTime > 0 then return {0, 0, expireTime, 0} end
+-- paused queue
+if paused then return {0, 0, 0, 0} end
+-- no job ID, try non-blocking move from wait to active
+local jobId = rcall("RPOPLPUSH", waitKey, activeKey)
+-- Markers in waitlist DEPRECATED in v5: Will be completely removed in v6.
+if jobId and string.sub(jobId, 1, 2) == "0:" then
+    rcall("LREM", activeKey, 1, jobId)
     jobId = rcall("RPOPLPUSH", waitKey, activeKey)
-    -- Since it is possible that between a call to BRPOPLPUSH and moveToActive
-    -- another script puts a new maker in wait, we need to check again.
-    if jobId and string.sub(jobId, 1, 2) == "0:" then
-        rcall("LREM", activeKey, 1, jobId)
-        jobId = rcall("RPOPLPUSH", waitKey, activeKey)
-    end
 end
 if jobId then
     return prepareJobForProcessing(KEYS, ARGV[1], target, jobId, ARGV[2],
@@ -245,6 +227,6 @@ return {0, 0, 0, 0}
 export const moveToActive = {
     name: 'moveToActive',
     content,
-    keys: 10,
+    keys: 11,
 };
-//# sourceMappingURL=moveToActive-10.js.map
+//# sourceMappingURL=moveToActive-11.js.map

package/dist/esm/scripts/moveToActive-11.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"moveToActive-11.js","sourceRoot":"","sources":["../../../src/scripts/moveToActive-11.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiOf,CAAC;AACF,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,IAAI,EAAE,cAAc;IACpB,OAAO;IACP,IAAI,EAAE,EAAE;CACT,CAAC"}

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

@@ -0,0 +1,100 @@
+const content = `--[[
+  Moves job from active to delayed set.
+  Input:
+    KEYS[1] marker key
+    KEYS[2] active key
+    KEYS[3] prioritized key
+    KEYS[4] delayed key
+    KEYS[5] job key
+    KEYS[6] events stream
+    KEYS[7] meta key
+    ARGV[1] key prefix
+    ARGV[2] timestamp
+    ARGV[3] delayedTimestamp
+    ARGV[4] the id of the job
+    ARGV[5] queue token
+    ARGV[6] delay value
+    ARGV[7] skip attempt
+  Output:
+    0 - OK
+   -1 - Missing job.
+   -3 - Job not in active set.
+  Events:
+    - delayed key.
+]]
+local rcall = redis.call
+-- Includes
+--[[
+  Add delay marker if needed.
+]] 
+-- Includes
+--[[
+  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 function addDelayMarkerIfNeeded(markerKey, delayedKey)
+    local nextTimestamp = getNextDelayedTimestamp(delayedKey)
+    if nextTimestamp ~= nil then
+        -- Replace the score of the marker with the newest known
+        -- next timestamp.
+        rcall("ZADD", markerKey, nextTimestamp, "0")
+    end
+end
+--[[
+  Function to check for the meta.paused key to decide if we are paused or not
+  (since an empty list and !EXISTS are not really the same).
+]]
+local function isQueuePaused(queueMetaKey)
+    return rcall("HEXISTS", queueMetaKey, "paused") == 1
+end
+local jobKey = KEYS[5]
+local metaKey = KEYS[7]
+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
+    if ARGV[7] == "0" then
+        rcall("HINCRBY", jobKey, "atm", 1)
+    end
+    rcall("HSET", jobKey, "delay", ARGV[6])
+    local maxEvents = rcall("HGET", metaKey, "opts.maxLenEvents") or 10000
+    rcall("ZADD", delayedKey, score, jobId)
+    rcall("XADD", KEYS[6], "MAXLEN", "~", maxEvents, "*", "event", "delayed",
+          "jobId", jobId, "delay", delayedTimestamp)
+    -- Check if we need to push a marker job to wake up sleeping workers.
+    local isPaused = isQueuePaused(metaKey)
+    if not isPaused then
+        local markerKey = KEYS[1]
+        addDelayMarkerIfNeeded(markerKey, delayedKey)
+    end
+    return 0
+else
+    return -1
+end
+`;
+export const moveToDelayed = {
+    name: 'moveToDelayed',
+    content,
+    keys: 7,
+};
+//# sourceMappingURL=moveToDelayed-7.js.map

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

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

package/dist/esm/scripts/{moveToFinished-13.js → moveToFinished-14.js}

@@ -18,20 +18,19 @@ const content = `--[[
       KEYS[11] completed/failed key
       KEYS[12] jobId key
       KEYS[13] metrics key
+      KEYS[14] marker key
       ARGV[1]  jobId
       ARGV[2]  timestamp
       ARGV[3]  msg property returnvalue / failedReason
       ARGV[4]  return value / failed reason
       ARGV[5]  target (completed/failed)
-      ARGV[6]  event data (? maybe just send jobid).
-      ARGV[7]  fetch next?
-      ARGV[8]  keys prefix
-      ARGV[9]  opts
+      ARGV[6]  fetch next?
+      ARGV[7]  keys prefix
+      ARGV[8]  opts
       opts - token - lock token
       opts - keepJobs
       opts - lockDuration - lock duration in milliseconds
       opts - attempts max attempts
-      opts - attemptsMade
       opts - maxMetricsSize
       opts - fpof - fail parent on fail
       opts - rdof - remove dependency on fail
@@ -187,7 +186,7 @@ local function prepareJobForProcessing(keys, keyPrefix, targetKey, jobId, proces
   end
   rcall("XADD", keys[4], "*", "event", "active", "jobId", jobId, "prev", "waiting")
   rcall("HSET", jobKey, "processedOn", processedOn)
-  rcall("HINCRBY", jobKey, "attemptsMade", 1)
+  rcall("HINCRBY", jobKey, "ats", 1)
   return {rcall("HGETALL", jobKey), jobId, 0, 0} -- get job data
 end
 --[[
@@ -200,49 +199,32 @@ end
 -- Includes
 --[[
   Add delay marker if needed.
-]]
+]] 
 -- Includes
-local function addDelayMarkerIfNeeded(targetKey, delayedKey)
-  local waitLen = rcall("LLEN", targetKey)
-  if waitLen <= 1 then
+local function addDelayMarkerIfNeeded(markerKey, delayedKey)
     local nextTimestamp = getNextDelayedTimestamp(delayedKey)
     if nextTimestamp ~= nil then
-      -- Check if there is already a marker with older timestamp
-      -- if there is, we need to replace it.
-      if waitLen == 1 then
-        local marker = rcall("LINDEX", targetKey, 0)
-        local oldTimestamp = tonumber(marker:sub(3))
-        if oldTimestamp and oldTimestamp > nextTimestamp then
-          rcall("LSET", targetKey, 0, "0:" .. nextTimestamp)
-        end
-      else
-        -- if there is no marker, then we need to add one
-        rcall("LPUSH", targetKey, "0:" .. nextTimestamp)
-      end
+        -- Replace the score of the marker with the newest known
+        -- next timestamp.
+        rcall("ZADD", markerKey, nextTimestamp, "0")
     end
-  end
 end
 --[[
-  Function to add job considering priority.
+  Function to check for the meta.paused key to decide if we are paused or not
+  (since an empty list and !EXISTS are not really the same).
 ]]
--- Includes
+local function isQueuePaused(queueMetaKey)
+    return rcall("HEXISTS", queueMetaKey, "paused") == 1
+end
 --[[
-  Function priority marker to wait if needed
-  in order to wake up our workers and to respect priority
-  order as much as possible
+  Function to add job considering priority.
 ]]
-local function addPriorityMarkerIfNeeded(waitKey)
-  local waitLen = rcall("LLEN", waitKey)
-  if waitLen == 0 then
-    rcall("LPUSH", waitKey, "0:0")
-  end
-end
-local function addJobWithPriority(waitKey, prioritizedKey, priority, paused, jobId, priorityCounterKey)
+local function addJobWithPriority(markerKey, prioritizedKey, priority, jobId, priorityCounterKey, isPaused)
   local prioCounter = rcall("INCR", priorityCounterKey)
   local score = priority * 0x100000000 + bit.band(prioCounter, 0xffffffffffff)
   rcall("ZADD", prioritizedKey, score, jobId)
-  if not paused then
-    addPriorityMarkerIfNeeded(waitKey)
+  if not isPaused then
+    rcall("ZADD", markerKey, 0, "0")
   end
 end
 --[[
@@ -256,35 +238,44 @@ local function getTargetQueueList(queueMetaKey, waitKey, pausedKey)
     return pausedKey, true
   end
 end
-local function moveParentToWaitIfNeeded(parentQueueKey, parentDependenciesKey, parentKey, parentId, timestamp)
-  local isParentActive = rcall("ZSCORE", parentQueueKey .. ":waiting-children", parentId)
-  if rcall("SCARD", parentDependenciesKey) == 0 and isParentActive then 
-    rcall("ZREM", parentQueueKey .. ":waiting-children", parentId)
-    local parentWaitKey = parentQueueKey .. ":wait"
-    local parentTarget, paused = getTargetQueueList(parentQueueKey .. ":meta", parentWaitKey,
-      parentQueueKey .. ":paused")
-    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)
-      rcall("XADD", parentQueueKey .. ":events", "*", "event", "delayed", "jobId", parentId,
-        "delay", delayedTimestamp)
-      addDelayMarkerIfNeeded(parentTarget, parentDelayedKey)
-    else
-      if priority == 0 then
-        rcall("RPUSH", parentTarget, parentId)
-      else
-        addJobWithPriority(parentWaitKey, parentQueueKey .. ":prioritized", priority, paused,
-          parentId, parentQueueKey .. ":pc")
-      end
-      rcall("XADD", parentQueueKey .. ":events", "*", "event", "waiting", "jobId", parentId,
-        "prev", "waiting-children")
+local function moveParentToWaitIfNeeded(parentQueueKey, parentDependenciesKey,
+                                        parentKey, parentId, timestamp)
+    local isParentActive = rcall("ZSCORE",
+                                 parentQueueKey .. ":waiting-children", parentId)
+    if rcall("SCARD", parentDependenciesKey) == 0 and isParentActive then
+        rcall("ZREM", parentQueueKey .. ":waiting-children", parentId)
+        local parentWaitKey = parentQueueKey .. ":wait"
+        local parentPausedKey = parentQueueKey .. ":paused"
+        local parentMetaKey = parentQueueKey .. ":meta"
+        local parentMarkerKey = parentQueueKey .. ":marker"
+        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)
+            rcall("XADD", parentQueueKey .. ":events", "*", "event", "delayed",
+                  "jobId", parentId, "delay", delayedTimestamp)
+            addDelayMarkerIfNeeded(parentMarkerKey, parentDelayedKey)
+        else
+            if priority == 0 then
+                local parentTarget, _paused =
+                    getTargetQueueList(parentMetaKey, parentWaitKey,
+                                       parentPausedKey)
+                rcall("RPUSH", parentTarget, parentId)
+                rcall("ZADD", parentMarkerKey, 0, "0")
+            else
+                local isPaused = isQueuePaused(parentMetaKey)
+                addJobWithPriority(parentMarkerKey,
+                                   parentQueueKey .. ":prioritized", priority,
+                                   parentId, parentQueueKey .. ":pc", isPaused)
+            end
+            rcall("XADD", parentQueueKey .. ":events", "*", "event", "waiting",
+                  "jobId", parentId, "prev", "waiting-children")
+        end
     end
-  end
 end
 local function moveParentFromWaitingChildrenToFailed( parentQueueKey, parentKey, parentId, jobIdKey, timestamp)
   if rcall("ZREM", parentQueueKey .. ":waiting-children", parentId) == 1 then
@@ -323,8 +314,8 @@ end
 ]]
 -- Includes
 -- Try to get as much as 1000 jobs at once
-local function promoteDelayedJobs(delayedKey, waitKey, targetKey, prioritizedKey,
-                                  eventStreamKey, prefix, timestamp, paused, priorityCounterKey)
+local function promoteDelayedJobs(delayedKey, markerKey, targetKey, prioritizedKey,
+                                  eventStreamKey, prefix, timestamp, priorityCounterKey, isPaused)
     local jobs = rcall("ZRANGEBYSCORE", delayedKey, 0, (timestamp + 1) * 0x1000, "LIMIT", 0, 1000)
     if (#jobs > 0) then
         rcall("ZREM", delayedKey, unpack(jobs))
@@ -335,9 +326,12 @@ local function promoteDelayedJobs(delayedKey, waitKey, targetKey, prioritizedKey
             if priority == 0 then
                 -- LIFO or FIFO
                 rcall("LPUSH", targetKey, jobId)
+                if not isPaused then
+                    rcall("ZADD", markerKey, 0, "0")
+                end
             else
-                addJobWithPriority(waitKey, prioritizedKey, priority, paused,
-                  jobId, priorityCounterKey)
+                addJobWithPriority(markerKey, prioritizedKey, priority,
+                  jobId, priorityCounterKey, isPaused)
             end
             -- Emit waiting event
             rcall("XADD", eventStreamKey, "*", "event", "waiting", "jobId",
@@ -492,10 +486,9 @@ local function getRateLimitTTL(maxJobs, rateLimiterKey)
 end
 local jobIdKey = KEYS[12]
 if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
-    local opts = cmsgpack.unpack(ARGV[9])
+    local opts = cmsgpack.unpack(ARGV[8])
     local token = opts['token']
     local attempts = opts['attempts']
-    local attemptsMade = opts['attemptsMade']
     local maxMetricsSize = opts['maxMetricsSize']
     local maxCount = opts['keepJobs']['count']
     local maxAge = opts['keepJobs']['age']
@@ -532,8 +525,9 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
     -- Remove from active list (if not active we shall return error)
     local numRemovedElements = rcall("LREM", KEYS[2], -1, jobId)
     if (numRemovedElements < 1) then return -3 end
+    local metaKey = KEYS[9]
     -- Trim events before emiting them to avoid trimming events emitted in this script
-    trimEvents(KEYS[9], KEYS[4])
+    trimEvents(metaKey, KEYS[4])
     -- If job has a parent we need to
     -- 1) remove this job id from parents dependencies
     -- 2) move the job Id to parent "processed" set
@@ -554,16 +548,18 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
         else
             if opts['fpof'] then
                 moveParentFromWaitingChildrenToFailed(parentQueueKey, parentKey,
-                                            parentId, jobIdKey, timestamp)
+                                                      parentId, jobIdKey,
+                                                      timestamp)
             elseif opts['rdof'] then
                 local dependenciesSet = parentKey .. ":dependencies"
                 if rcall("SREM", dependenciesSet, jobIdKey) == 1 then
                     moveParentToWaitIfNeeded(parentQueueKey, dependenciesSet,
-                        parentKey, parentId, timestamp)
+                                             parentKey, parentId, timestamp)
                 end
             end
         end
     end
+    local attemptsMade = rcall("HINCRBY", jobIdKey, "atm", 1)
     -- Remove job?
     if maxCount ~= 0 then
         local targetSet = KEYS[11]
@@ -572,7 +568,7 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
         rcall("HMSET", jobIdKey, ARGV[3], ARGV[4], "finishedOn", timestamp)
         -- "returnvalue" / "failedReason" and "finishedOn"
         -- Remove old jobs?
-        local prefix = ARGV[8]
+        local prefix = ARGV[7]
         if maxAge ~= nil then
             removeJobsByMaxAge(timestamp, maxAge, targetSet, prefix)
         end
@@ -599,11 +595,11 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
     end
     -- Try to get next job to avoid an extra roundtrip if the queue is not closing,
     -- and not rate limited.
-    if (ARGV[7] == "1") then
-        local target, paused = getTargetQueueList(KEYS[9], KEYS[1], KEYS[8])
+    if (ARGV[6] == "1") then
+        local target, paused = getTargetQueueList(metaKey, KEYS[1], KEYS[8])
         -- Check if there are delayed jobs that can be promoted
-        promoteDelayedJobs(KEYS[7], KEYS[1], target, KEYS[3],
-                           KEYS[4], ARGV[8], timestamp, paused, KEYS[10])
+        promoteDelayedJobs(KEYS[7], KEYS[14], target, KEYS[3], KEYS[4], ARGV[7],
+                           timestamp, KEYS[10], paused)
         local maxJobs = tonumber(opts['limiter'] and opts['limiter']['max'])
         -- Check if we are rate limited first.
         local expireTime = getRateLimitTTL(maxJobs, KEYS[6])
@@ -612,24 +608,29 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
         if paused then return {0, 0, 0, 0} end
         jobId = rcall("RPOPLPUSH", KEYS[1], KEYS[2])
         if jobId then
+            -- Markers in waitlist DEPRECATED in v5: Remove in v6.
             if string.sub(jobId, 1, 2) == "0:" then
                 rcall("LREM", KEYS[2], 1, jobId)
                 -- If jobId is special ID 0:delay (delay greater than 0), then there is no job to process
                 -- but if ID is 0:0, then there is at least 1 prioritized job to process
                 if jobId == "0:0" then
-                    jobId = moveJobFromPriorityToActive(KEYS[3], KEYS[2], KEYS[10])
-                    return prepareJobForProcessing(KEYS, ARGV[8], target, jobId, timestamp,
-                        maxJobs, expireTime, opts)
+                    jobId = moveJobFromPriorityToActive(KEYS[3], KEYS[2],
+                                                        KEYS[10])
+                    return prepareJobForProcessing(KEYS, ARGV[7], target, jobId,
+                                                   timestamp, maxJobs,
+                                                   expireTime, opts)
                 end
             else
-                return prepareJobForProcessing(KEYS, ARGV[8], target, jobId, timestamp, maxJobs,
-                    expireTime, opts)
+                return prepareJobForProcessing(KEYS, ARGV[7], target, jobId,
+                                               timestamp, maxJobs, expireTime,
+                                               opts)
             end
         else
             jobId = moveJobFromPriorityToActive(KEYS[3], KEYS[2], KEYS[10])
             if jobId then
-                return prepareJobForProcessing(KEYS, ARGV[8], target, jobId, timestamp, maxJobs,
-                    expireTime, opts)
+                return prepareJobForProcessing(KEYS, ARGV[7], target, jobId,
+                                               timestamp, maxJobs, expireTime,
+                                               opts)
             end
         end
         -- Return the timestamp for the next delayed job if any.
@@ -658,6 +659,6 @@ end
 export const moveToFinished = {
     name: 'moveToFinished',
     content,
-    keys: 13,
+    keys: 14,
 };
-//# sourceMappingURL=moveToFinished-13.js.map
+//# sourceMappingURL=moveToFinished-14.js.map

package/dist/esm/scripts/{moveToFinished-13.js.map → moveToFinished-14.js.map}

@@ -1 +1 @@
-{"version":3,"file":"moveToFinished-13.js","sourceRoot":"","sources":["../../../src/scripts/moveToFinished-13.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgpBf,CAAC;AACF,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,IAAI,EAAE,gBAAgB;IACtB,OAAO;IACP,IAAI,EAAE,EAAE;CACT,CAAC"}
+{"version":3,"file":"moveToFinished-14.js","sourceRoot":"","sources":["../../../src/scripts/moveToFinished-14.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAipBf,CAAC;AACF,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,IAAI,EAAE,gBAAgB;IACtB,OAAO;IACP,IAAI,EAAE,EAAE;CACT,CAAC"}

package/dist/esm/scripts/moveToWaitingChildren-4.js

@@ -17,7 +17,8 @@ const content = `--[[
    -3 - Job not in active set
 ]]
 local rcall = redis.call
-local function moveToWaitingChildren (activeKey, waitingChildrenKey, jobId, timestamp, lockKey, token)
+local function moveToWaitingChildren (activeKey, waitingChildrenKey, jobId, timestamp,
+    lockKey, jobKey, token)
   if token ~= "0" then
     if rcall("GET", lockKey) == token then
       rcall("DEL", lockKey)
@@ -36,12 +37,14 @@ end
 if rcall("EXISTS", KEYS[4]) == 1 then
   if ARGV[2] ~= "" then
     if rcall("SISMEMBER", KEYS[4] .. ":dependencies", ARGV[2]) ~= 0 then
-      return moveToWaitingChildren(KEYS[2], KEYS[3], ARGV[4], ARGV[3], KEYS[1], ARGV[1])
+      return moveToWaitingChildren(KEYS[2], KEYS[3], ARGV[4], ARGV[3], KEYS[1], KEYS[4],
+        ARGV[1])
     end
     return 1
   else
     if rcall("SCARD", KEYS[4] .. ":dependencies") ~= 0 then 
-      return moveToWaitingChildren(KEYS[2], KEYS[3], ARGV[4], ARGV[3], KEYS[1], ARGV[1])
+      return moveToWaitingChildren(KEYS[2], KEYS[3], ARGV[4], ARGV[3], KEYS[1], KEYS[4],
+        ARGV[1])
     end
     return 1
   end

package/dist/esm/scripts/moveToWaitingChildren-4.js.map

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