bullmq 5.1.2 → 5.1.4

package/dist/esm/scripts/index.js

@@ -14,8 +14,8 @@ export * from './getStateV2-8';
 export * from './isFinished-3';
 export * from './isJobInList-1';
 export * from './moveJobFromActiveToWait-9';
-export * from './moveJobsToWait-6';
-export * from './moveStalledJobsToWait-8';
+export * from './moveJobsToWait-7';
+export * from './moveStalledJobsToWait-9';
 export * from './moveToActive-11';
 export * from './moveToDelayed-7';
 export * from './moveToFinished-14';

package/dist/esm/scripts/{moveJobsToWait-6.js → moveJobsToWait-7.js}

@@ -8,6 +8,7 @@ const content = `--[[
     KEYS[4] 'wait'
     KEYS[5] 'paused'
     KEYS[6] 'meta'
+    KEYS[7] 'marker'
     ARGV[1] count
     ARGV[2] timestamp
     ARGV[3] prev state
@@ -19,6 +20,14 @@ local maxCount = tonumber(ARGV[1])
 local timestamp = tonumber(ARGV[2])
 local rcall = redis.call;
 -- Includes
+--[[
+  Add marker if needed when a job is available.
+]]
+local function addBaseMarkerIfNeeded(markerKey, isPaused)
+  if not isPaused then
+    rcall("ZADD", markerKey, 0, "0")
+  end  
+end
 --[[
   Function to loop in batches.
   Just a bit of warning, some commands as ZREM
@@ -58,7 +67,7 @@ local function getTargetQueueList(queueMetaKey, waitKey, pausedKey)
   end
 end
 local metaKey = KEYS[6]
-local target = getTargetQueueList(metaKey, KEYS[4], KEYS[5])
+local target, paused = getTargetQueueList(metaKey, KEYS[4], KEYS[5])
 local jobs = rcall('ZRANGEBYSCORE', KEYS[3], 0, timestamp, 'LIMIT', 0, maxCount)
 if (#jobs > 0) then
     if ARGV[3] == "failed" then
@@ -82,6 +91,7 @@ if (#jobs > 0) then
         rcall("ZREM", KEYS[3], unpack(jobs, from, to))
         rcall("LPUSH", target, unpack(jobs, from, to))
     end
+    addBaseMarkerIfNeeded(KEYS[7], paused)
 end
 maxCount = maxCount - #jobs
 if (maxCount <= 0) then return 1 end
@@ -90,6 +100,6 @@ return 0
 export const moveJobsToWait = {
     name: 'moveJobsToWait',
     content,
-    keys: 6,
+    keys: 7,
 };
-//# sourceMappingURL=moveJobsToWait-6.js.map
+//# sourceMappingURL=moveJobsToWait-7.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"moveJobsToWait-7.js","sourceRoot":"","sources":["../../../src/scripts/moveJobsToWait-7.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkGf,CAAC;AACF,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,IAAI,EAAE,gBAAgB;IACtB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

package/dist/esm/scripts/{moveStalledJobsToWait-8.js → moveStalledJobsToWait-9.js}

@@ -8,34 +8,33 @@ const content = `--[[
       KEYS[5] 'stalled-check', (KEY)
       KEYS[6] 'meta', (KEY)
       KEYS[7] 'paused', (LIST)
-      KEYS[8] 'event stream' (STREAM)
+      KEYS[8] 'marker'
+      KEYS[9] 'event stream' (STREAM)
       ARGV[1]  Max stalled job count
       ARGV[2]  queue.toKey('')
       ARGV[3]  timestamp
       ARGV[4]  max check time
     Events:
       'stalled' with stalled job id.
-]] -- Includes
---[[
-  Move stalled jobs to wait.
-    Input:
-      stalledKey 'stalled' (SET)
-      waitKey 'wait',   (LIST)
-      activeKey 'active', (LIST)
-      failedKey 'failed', (ZSET)
-      stalledCheckKey 'stalled-check', (KEY)
-      metaKey 'meta', (KEY)
-      pausedKey 'paused', (LIST)
-      eventStreamKey 'event stream' (STREAM)
-      maxStalledJobCount  Max stalled job count
-      queueKeyPrefix  queue.toKey('')
-      timestamp  timestamp
-      maxCheckTime  max check time
-    Events:
-      'stalled' with stalled job id.
 ]]
 local rcall = redis.call
 -- Includes
+--[[
+  Function to add job in target list and add marker if needed.
+]]
+-- Includes
+--[[
+  Add marker if needed when a job is available.
+]]
+local function addBaseMarkerIfNeeded(markerKey, isPaused)
+  if not isPaused then
+    rcall("ZADD", markerKey, 0, "0")
+  end  
+end
+local function addJobInTargetList(targetKey, markerKey, pushCmd, isPaused, jobId)
+  rcall(pushCmd, targetKey, jobId)
+  addBaseMarkerIfNeeded(markerKey, isPaused)
+end
 --[[
   Function to loop in batches.
   Just a bit of warning, some commands as ZREM
@@ -197,103 +196,107 @@ local function trimEvents(metaKey, eventStreamKey)
     rcall("XTRIM", eventStreamKey, "MAXLEN", "~", 10000)
   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
-    rcall("SET", stalledCheckKey, timestamp, "PX", maxCheckTime)
-    -- Trim events before emiting them to avoid trimming events emitted in this script
-    trimEvents(metaKey, eventStreamKey)
-    -- Move all stalled jobs to wait
-    local stalling = rcall('SMEMBERS', stalledKey)
-    local stalled = {}
-    local failed = {}
-    if (#stalling > 0) then
-        rcall('DEL', stalledKey)
-        local MAX_STALLED_JOB_COUNT = tonumber(maxStalledJobCount)
-        -- Remove from active list
-        for i, jobId in ipairs(stalling) do
-            -- Markers in waitlist DEPRECATED in v5: Remove in v6.
-            if string.sub(jobId, 1, 2) == "0:" then
-                -- If the jobId is a delay marker ID we just remove it.
-                rcall("LREM", activeKey, 1, jobId)
-            else
-                local jobKey = queueKeyPrefix .. jobId
-                -- Check that the lock is also missing, then we can handle this job as really stalled.
-                if (rcall("EXISTS", jobKey .. ":lock") == 0) then
-                    --  Remove from the active queue.
-                    local removed = rcall("LREM", activeKey, 1, jobId)
-                    if (removed > 0) then
-                        -- If this job has been stalled too many times, such as if it crashes the worker, then fail it.
-                        local stalledCount =
-                            rcall("HINCRBY", jobKey, "stalledCounter", 1)
-                        if (stalledCount > MAX_STALLED_JOB_COUNT) then
-                            local rawOpts = rcall("HGET", jobKey, "opts")
-                            local opts = cjson.decode(rawOpts)
-                            local removeOnFailType = type(opts["removeOnFail"])
-                            rcall("ZADD", failedKey, timestamp, jobId)
-                            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)
-                            if removeOnFailType == "number" then
-                                removeJobsByMaxCount(opts["removeOnFail"],
-                                                     failedKey, queueKeyPrefix)
-                            elseif removeOnFailType == "boolean" then
-                                if opts["removeOnFail"] then
-                                    removeJob(jobId, false, queueKeyPrefix)
-                                    rcall("ZREM", failedKey, jobId)
-                                end
-                            elseif removeOnFailType ~= "nil" then
-                                local maxAge = opts["removeOnFail"]["age"]
-                                local maxCount = opts["removeOnFail"]["count"]
-                                if maxAge ~= nil then
-                                    removeJobsByMaxAge(timestamp, maxAge,
-                                                       failedKey, queueKeyPrefix)
-                                end
-                                if maxCount ~= nil and maxCount > 0 then
-                                    removeJobsByMaxCount(maxCount, failedKey,
-                                                         queueKeyPrefix)
-                                end
+local stalledKey = KEYS[1]
+local waitKey = KEYS[2]
+local activeKey = KEYS[3]
+local failedKey = KEYS[4]
+local stalledCheckKey = KEYS[5]
+local metaKey = KEYS[6]
+local pausedKey = KEYS[7]
+local markerKey = KEYS[8]
+local eventStreamKey = KEYS[9]
+local maxStalledJobCount = ARGV[1]
+local queueKeyPrefix = ARGV[2]
+local timestamp = ARGV[3]
+local maxCheckTime = ARGV[4]
+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)
+-- Move all stalled jobs to wait
+local stalling = rcall('SMEMBERS', stalledKey)
+local stalled = {}
+local failed = {}
+if (#stalling > 0) then
+    rcall('DEL', stalledKey)
+    local MAX_STALLED_JOB_COUNT = tonumber(maxStalledJobCount)
+    -- Remove from active list
+    for i, jobId in ipairs(stalling) do
+        -- Markers in waitlist DEPRECATED in v5: Remove in v6.
+        if string.sub(jobId, 1, 2) == "0:" then
+            -- If the jobId is a delay marker ID we just remove it.
+            rcall("LREM", activeKey, 1, jobId)
+        else
+            local jobKey = queueKeyPrefix .. jobId
+            -- Check that the lock is also missing, then we can handle this job as really stalled.
+            if (rcall("EXISTS", jobKey .. ":lock") == 0) then
+                --  Remove from the active queue.
+                local removed = rcall("LREM", activeKey, 1, jobId)
+                if (removed > 0) then
+                    -- If this job has been stalled too many times, such as if it crashes the worker, then fail it.
+                    local stalledCount =
+                        rcall("HINCRBY", jobKey, "stalledCounter", 1)
+                    if (stalledCount > MAX_STALLED_JOB_COUNT) then
+                        local rawOpts = rcall("HGET", jobKey, "opts")
+                        local opts = cjson.decode(rawOpts)
+                        local removeOnFailType = type(opts["removeOnFail"])
+                        rcall("ZADD", failedKey, timestamp, jobId)
+                        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)
+                        if removeOnFailType == "number" then
+                            removeJobsByMaxCount(opts["removeOnFail"],
+                                                  failedKey, queueKeyPrefix)
+                        elseif removeOnFailType == "boolean" then
+                            if opts["removeOnFail"] then
+                                removeJob(jobId, false, queueKeyPrefix)
+                                rcall("ZREM", failedKey, jobId)
+                            end
+                        elseif removeOnFailType ~= "nil" then
+                            local maxAge = opts["removeOnFail"]["age"]
+                            local maxCount = opts["removeOnFail"]["count"]
+                            if maxAge ~= nil then
+                                removeJobsByMaxAge(timestamp, maxAge,
+                                                    failedKey, queueKeyPrefix)
+                            end
+                            if maxCount ~= nil and maxCount > 0 then
+                                removeJobsByMaxCount(maxCount, failedKey,
+                                                      queueKeyPrefix)
                             end
-                            table.insert(failed, jobId)
-                        else
-                            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')
-                            -- Emit the stalled event
-                            rcall("XADD", eventStreamKey, "*", "event",
-                                  "stalled", "jobId", jobId)
-                            table.insert(stalled, jobId)
                         end
+                        table.insert(failed, jobId)
+                    else
+                        local target, isPaused=
+                            getTargetQueueList(metaKey, waitKey, pausedKey)
+                        -- Move the job back to the wait queue, to immediately be picked up by a waiting worker.
+                        addJobInTargetList(target, markerKey, "RPUSH", isPaused, jobId)
+                        rcall("XADD", eventStreamKey, "*", "event",
+                              "waiting", "jobId", jobId, 'prev', 'active')
+                        -- Emit the stalled event
+                        rcall("XADD", eventStreamKey, "*", "event",
+                              "stalled", "jobId", jobId)
+                        table.insert(stalled, jobId)
                     end
                 end
             end
         end
     end
-    -- Mark potentially stalled jobs
-    local active = rcall('LRANGE', activeKey, 0, -1)
-    if (#active > 0) then
-        for from, to in batches(#active, 7000) do
-            rcall('SADD', stalledKey, unpack(active, from, to))
-        end
+end
+-- Mark potentially stalled jobs
+local active = rcall('LRANGE', activeKey, 0, -1)
+if (#active > 0) then
+    for from, to in batches(#active, 7000) do
+        rcall('SADD', stalledKey, unpack(active, from, to))
     end
-    return {failed, stalled}
 end
-return checkStalledJobs(KEYS[1], KEYS[2], KEYS[3], KEYS[4], KEYS[5], KEYS[6],
-                        KEYS[7], KEYS[8], ARGV[1], ARGV[2], ARGV[3], ARGV[4])
-`;
+return {failed, stalled}`;
 export const moveStalledJobsToWait = {
     name: 'moveStalledJobsToWait',
     content,
-    keys: 8,
+    keys: 9,
 };
-//# sourceMappingURL=moveStalledJobsToWait-8.js.map
+//# sourceMappingURL=moveStalledJobsToWait-9.js.map

package/dist/esm/scripts/{moveStalledJobsToWait-8.js.map → moveStalledJobsToWait-9.js.map}

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

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

@@ -156,16 +156,31 @@ end
       'waiting'
 ]]
 -- Includes
+--[[
+  Function to add job in target list and add marker if needed.
+]]
+-- Includes
+--[[
+  Add marker if needed when a job is available.
+]]
+local function addBaseMarkerIfNeeded(markerKey, isPaused)
+  if not isPaused then
+    rcall("ZADD", markerKey, 0, "0")
+  end  
+end
+local function addJobInTargetList(targetKey, markerKey, pushCmd, isPaused, jobId)
+  rcall(pushCmd, targetKey, jobId)
+  addBaseMarkerIfNeeded(markerKey, isPaused)
+end
 --[[
   Function to add job considering priority.
 ]]
+-- Includes
 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 isPaused then
-    rcall("ZADD", markerKey, 0, "0")
-  end
+  addBaseMarkerIfNeeded(markerKey, isPaused)
 end
 -- Try to get as much as 1000 jobs at once
 local function promoteDelayedJobs(delayedKey, markerKey, targetKey, prioritizedKey,
@@ -179,10 +194,7 @@ local function promoteDelayedJobs(delayedKey, markerKey, targetKey, prioritizedK
                 tonumber(rcall("HGET", jobKey, "priority")) or 0
             if priority == 0 then
                 -- LIFO or FIFO
-                rcall("LPUSH", targetKey, jobId)
-                if not isPaused then
-                    rcall("ZADD", markerKey, 0, "0")
-                end
+                addJobInTargetList(targetKey, markerKey, "LPUSH", isPaused, jobId)
             else
                 addJobWithPriority(markerKey, prioritizedKey, priority,
                   jobId, priorityCounterKey, isPaused)

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

@@ -1 +1 @@
-{"version":3,"file":"moveToActive-11.js","sourceRoot":"","sources":["../../../src/scripts/moveToActive-11.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoOf,CAAC;AACF,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,IAAI,EAAE,cAAc;IACpB,OAAO;IACP,IAAI,EAAE,EAAE;CACT,CAAC"}
+{"version":3,"file":"moveToActive-11.js","sourceRoot":"","sources":["../../../src/scripts/moveToActive-11.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgPf,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

@@ -26,7 +26,7 @@ local rcall = redis.call
 -- Includes
 --[[
   Add delay marker if needed.
-]] 
+]]
 -- Includes
 --[[
   Function to return the next delayed job timestamp.

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

@@ -113,6 +113,17 @@ local function getNextDelayedTimestamp(delayedKey)
     return nextTimestamp
   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 getTargetQueueList(queueMetaKey, waitKey, pausedKey)
+  if rcall("HEXISTS", queueMetaKey, "paused") ~= 1 then
+    return waitKey, false
+  else
+    return pausedKey, true
+  end
+end
 --[[
   Function to move job from prioritized state to active.
 ]]
@@ -199,7 +210,7 @@ end
 -- Includes
 --[[
   Add delay marker if needed.
-]] 
+]]
 -- Includes
 local function addDelayMarkerIfNeeded(markerKey, delayedKey)
     local nextTimestamp = getNextDelayedTimestamp(delayedKey)
@@ -210,33 +221,37 @@ local function addDelayMarkerIfNeeded(markerKey, delayedKey)
     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).
+  Function to add job in target list and add marker if needed.
 ]]
-local function isQueuePaused(queueMetaKey)
-    return rcall("HEXISTS", queueMetaKey, "paused") == 1
+-- Includes
+--[[
+  Add marker if needed when a job is available.
+]]
+local function addBaseMarkerIfNeeded(markerKey, isPaused)
+  if not isPaused then
+    rcall("ZADD", markerKey, 0, "0")
+  end  
+end
+local function addJobInTargetList(targetKey, markerKey, pushCmd, isPaused, jobId)
+  rcall(pushCmd, targetKey, jobId)
+  addBaseMarkerIfNeeded(markerKey, isPaused)
 end
 --[[
   Function to add job considering priority.
 ]]
+-- Includes
 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 isPaused then
-    rcall("ZADD", markerKey, 0, "0")
-  end
+  addBaseMarkerIfNeeded(markerKey, isPaused)
 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 getTargetQueueList(queueMetaKey, waitKey, pausedKey)
-  if rcall("HEXISTS", queueMetaKey, "paused") ~= 1 then
-    return waitKey, false
-  else
-    return pausedKey, true
-  end
+local function isQueuePaused(queueMetaKey)
+    return rcall("HEXISTS", queueMetaKey, "paused") == 1
 end
 local function moveParentToWaitIfNeeded(parentQueueKey, parentDependenciesKey,
                                         parentKey, parentId, timestamp)
@@ -261,11 +276,10 @@ local function moveParentToWaitIfNeeded(parentQueueKey, parentDependenciesKey,
             addDelayMarkerIfNeeded(parentMarkerKey, parentDelayedKey)
         else
             if priority == 0 then
-                local parentTarget, _paused =
+                local parentTarget, isParentPaused =
                     getTargetQueueList(parentMetaKey, parentWaitKey,
                                        parentPausedKey)
-                rcall("RPUSH", parentTarget, parentId)
-                rcall("ZADD", parentMarkerKey, 0, "0")
+                addJobInTargetList(parentTarget, parentMarkerKey, "RPUSH", isParentPaused, parentId)
             else
                 local isPaused = isQueuePaused(parentMetaKey)
                 addJobWithPriority(parentMarkerKey,
@@ -325,10 +339,7 @@ local function promoteDelayedJobs(delayedKey, markerKey, targetKey, prioritizedK
                 tonumber(rcall("HGET", jobKey, "priority")) or 0
             if priority == 0 then
                 -- LIFO or FIFO
-                rcall("LPUSH", targetKey, jobId)
-                if not isPaused then
-                    rcall("ZADD", markerKey, 0, "0")
-                end
+                addJobInTargetList(targetKey, markerKey, "LPUSH", isPaused, jobId)
             else
                 addJobWithPriority(markerKey, prioritizedKey, priority,
                   jobId, priorityCounterKey, isPaused)

package/dist/esm/scripts/moveToFinished-14.js.map

@@ -1 +1 @@
-{"version":3,"file":"moveToFinished-14.js","sourceRoot":"","sources":["../../../src/scripts/moveToFinished-14.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgqBf,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2qBf,CAAC;AACF,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,IAAI,EAAE,gBAAgB;IACtB,OAAO;IACP,IAAI,EAAE,EAAE;CACT,CAAC"}

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

@@ -16,7 +16,7 @@ local rcall = redis.call
 -- Includes
 --[[
   Add delay marker if needed.
-]] 
+]]
 -- Includes
 --[[
   Function to return the next delayed job timestamp.
@@ -41,6 +41,7 @@ local function addDelayMarkerIfNeeded(markerKey, delayedKey)
 end
 local markerKey = KEYS[7]
 local hasJobs = rcall("EXISTS", KEYS[1]) == 1
+--TODO: check this logic to be reused when changing a delay
 if hasJobs then rcall("RENAME", KEYS[1], KEYS[2]) end
 if ARGV[1] == "paused" then
     rcall("HSET", KEYS[3], "paused", 1)

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

@@ -1 +1 @@
-{"version":3,"file":"pause-7.js","sourceRoot":"","sources":["../../../src/scripts/pause-7.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyDf,CAAC;AACF,MAAM,CAAC,MAAM,KAAK,GAAG;IACnB,IAAI,EAAE,OAAO;IACb,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}
+{"version":3,"file":"pause-7.js","sourceRoot":"","sources":["../../../src/scripts/pause-7.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0Df,CAAC;AACF,MAAM,CAAC,MAAM,KAAK,GAAG;IACnB,IAAI,EAAE,OAAO;IACb,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

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

@@ -20,16 +20,31 @@ const content = `--[[
 local rcall = redis.call
 local jobId = ARGV[2]
 -- Includes
+--[[
+  Function to add job in target list and add marker if needed.
+]]
+-- Includes
+--[[
+  Add marker if needed when a job is available.
+]]
+local function addBaseMarkerIfNeeded(markerKey, isPaused)
+  if not isPaused then
+    rcall("ZADD", markerKey, 0, "0")
+  end  
+end
+local function addJobInTargetList(targetKey, markerKey, pushCmd, isPaused, jobId)
+  rcall(pushCmd, targetKey, jobId)
+  addBaseMarkerIfNeeded(markerKey, isPaused)
+end
 --[[
   Function to add job considering priority.
 ]]
+-- Includes
 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 isPaused then
-    rcall("ZADD", markerKey, 0, "0")
-  end
+  addBaseMarkerIfNeeded(markerKey, isPaused)
 end
 --[[
   Function to check for the meta.paused key to decide if we are paused or not
@@ -54,8 +69,7 @@ if rcall("ZREM", KEYS[1], jobId) == 1 then
     if marker and string.sub(marker, 1, 2) == "0:" then rcall("LPOP", target) end
     if priority == 0 then
         -- LIFO or FIFO
-        rcall("LPUSH", target, jobId)
-        if not paused then rcall("ZADD", KEYS[8], 0, "0") end
+        addJobInTargetList(target, KEYS[8], "LPUSH", paused, jobId)
     else
         addJobWithPriority(KEYS[8], KEYS[5], priority, jobId, KEYS[6], paused)
     end

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

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

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

@@ -28,13 +28,20 @@ local rcall = redis.call
 --[[
   Function to add job considering priority.
 ]]
+-- Includes
+--[[
+  Add marker if needed when a job is available.
+]]
+local function addBaseMarkerIfNeeded(markerKey, isPaused)
+  if not isPaused then
+    rcall("ZADD", markerKey, 0, "0")
+  end  
+end
 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 isPaused then
-    rcall("ZADD", markerKey, 0, "0")
-  end
+  addBaseMarkerIfNeeded(markerKey, isPaused)
 end
 --[[
   Function to get max events value or set by default 10000.
@@ -65,6 +72,14 @@ end
       'waiting'
 ]]
 -- Includes
+--[[
+  Function to add job in target list and add marker if needed.
+]]
+-- Includes
+local function addJobInTargetList(targetKey, markerKey, pushCmd, isPaused, jobId)
+  rcall(pushCmd, targetKey, jobId)
+  addBaseMarkerIfNeeded(markerKey, isPaused)
+end
 -- Try to get as much as 1000 jobs at once
 local function promoteDelayedJobs(delayedKey, markerKey, targetKey, prioritizedKey,
                                   eventStreamKey, prefix, timestamp, priorityCounterKey, isPaused)
@@ -77,10 +92,7 @@ local function promoteDelayedJobs(delayedKey, markerKey, targetKey, prioritizedK
                 tonumber(rcall("HGET", jobKey, "priority")) or 0
             if priority == 0 then
                 -- LIFO or FIFO
-                rcall("LPUSH", targetKey, jobId)
-                if not isPaused then
-                    rcall("ZADD", markerKey, 0, "0")
-                end
+                addJobInTargetList(targetKey, markerKey, "LPUSH", isPaused, jobId)
             else
                 addJobWithPriority(markerKey, prioritizedKey, priority,
                   jobId, priorityCounterKey, isPaused)
@@ -111,6 +123,7 @@ if rcall("EXISTS", KEYS[4]) == 1 then
   -- Standard or priority add
   if priority == 0 then
     rcall(ARGV[3], target, ARGV[4])
+    -- TODO: check if we need to add marker in this case too
   else
     addJobWithPriority(markerKey, KEYS[8], priority, ARGV[4], KEYS[9], paused)
   end

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

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