bullmq 5.1.3 → 5.1.5

package/dist/esm/commands/addStandardJob-7.lua

@@ -58,10 +58,11 @@ local parent = args[8]
 local parentData
 
 -- Includes
---- @include "includes/storeJob"
---- @include "includes/updateExistingJobsParent"
+--- @include "includes/addJobInTargetList"
 --- @include "includes/getOrSetMaxEvents"
 --- @include "includes/getTargetQueueList"
+--- @include "includes/storeJob"
+--- @include "includes/updateExistingJobsParent"
 
 if parentKey ~= nil then
     if rcall("EXISTS", parentKey) ~= 1 then return -5 end
@@ -100,14 +101,9 @@ storeJob(eventsKey, jobIdKey, jobId, args[3], ARGV[2], opts, timestamp,
 
 local target, paused = getTargetQueueList(metaKey, KEYS[1], KEYS[2])
 
-if not paused then
-    -- mark that a job is available
-    rcall("ZADD", KEYS[7], 0, "0")
-end
-
 -- LIFO or FIFO
 local pushCmd = opts['lifo'] and 'RPUSH' or 'LPUSH'
-rcall(pushCmd, target, jobId)
+addJobInTargetList(target, KEYS[7], pushCmd, paused, jobId)
 
 -- Emit waiting event
 rcall("XADD", eventsKey, "MAXLEN", "~", maxEvents, "*", "event", "waiting",

package/dist/esm/commands/changeDelay-3.lua

@@ -31,6 +31,7 @@ if rcall("EXISTS", KEYS[2]) == 1 then
 
   rcall("HSET", KEYS[2], "delay", tonumber(ARGV[1]))
   rcall("ZADD", KEYS[1], score, jobId)
+  -- TODO: check if we need to evaluate a new marker
 
   rcall("XADD", KEYS[3], "*", "event", "delayed", "jobId", jobId, "delay", delayedTimestamp)
 

package/dist/esm/commands/changePriority-6.lua

@@ -25,7 +25,6 @@ local rcall = redis.call
 -- Includes
 --- @include "includes/isQueuePaused"
 --- @include "includes/addJobWithPriority"
---- @include "includes/getTargetQueueList"
 
 if rcall("EXISTS", jobKey) == 1 then
     local metaKey = KEYS[3]

package/dist/esm/commands/includes/addBaseMarkerIfNeeded.lua

@@ -0,0 +1,9 @@
+--[[
+  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

package/dist/esm/commands/includes/addDelayMarkerIfNeeded.lua

@@ -1,8 +1,10 @@
 --[[
   Add delay marker if needed.
-]] 
+]]
+
 -- Includes
 --- @include "getNextDelayedTimestamp"
+
 local function addDelayMarkerIfNeeded(markerKey, delayedKey)
     local nextTimestamp = getNextDelayedTimestamp(delayedKey)
     if nextTimestamp ~= nil then

package/dist/esm/commands/includes/addJobInTargetList.lua

@@ -0,0 +1,11 @@
+--[[
+  Function to add job in target list and add marker if needed.
+]]
+
+-- Includes
+--- @include "addBaseMarkerIfNeeded"
+
+local function addJobInTargetList(targetKey, markerKey, pushCmd, isPaused, jobId)
+  rcall(pushCmd, targetKey, jobId)
+  addBaseMarkerIfNeeded(markerKey, isPaused)
+end

package/dist/esm/commands/includes/addJobWithPriority.lua

@@ -1,11 +1,13 @@
 --[[
   Function to add job considering priority.
 ]]
+
+-- Includes
+--- @include "addBaseMarkerIfNeeded"
+
 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

package/dist/esm/commands/includes/moveParentToWaitIfNeeded.lua

@@ -1,11 +1,14 @@
 --[[
   Validate and move parent to active if needed.
 ]]
+
 -- Includes
 --- @include "addDelayMarkerIfNeeded"
---- @include "isQueuePaused"
+--- @include "addJobInTargetList"
 --- @include "addJobWithPriority"
+--- @include "isQueuePaused"
 --- @include "getTargetQueueList"
+
 local function moveParentToWaitIfNeeded(parentQueueKey, parentDependenciesKey,
                                         parentKey, parentId, timestamp)
     local isParentActive = rcall("ZSCORE",
@@ -32,11 +35,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,

package/dist/esm/commands/includes/prepareJobForProcessing.lua

@@ -2,53 +2,17 @@
 --[[
   Function to move job from wait state to active.
   Input:
-    keys[1] wait key
-    keys[2] active key
-    keys[3] prioritized key
-    keys[4] stream events key
-    keys[5] stalled key
-
-    -- Rate limiting
-    keys[6] rate limiter key
-    keys[7] delayed key
-
-    keys[8] paused key
-    keys[9] meta key
-    keys[10] pc priority counter
-
     opts - token - lock token
     opts - lockDuration
     opts - limiter
 ]]
 
--- Includes
---- @include "pushBackJobWithPriority"
-
-local function prepareJobForProcessing(keys, keyPrefix, targetKey, jobId, processedOn,
-    maxJobs, expireTime, opts)
+local function prepareJobForProcessing(keyPrefix, rateLimiterKey, eventStreamKey,
+    jobId, processedOn, maxJobs, opts)
   local jobKey = keyPrefix .. jobId
 
   -- Check if we need to perform rate limiting.
   if maxJobs then
-    local rateLimiterKey = keys[6];
-
-    -- check if we exceeded rate limit, we need to remove the job and return expireTime
-    if expireTime > 0 then
-      -- remove from active queue and add back to the wait list
-      rcall("LREM", keys[2], 1, jobId)
-
-      local priority = tonumber(rcall("HGET", jobKey, "priority")) or 0
-
-      if priority == 0 then
-        rcall("RPUSH", targetKey, jobId)
-      else
-        pushBackJobWithPriority(keys[3], priority, jobId)
-      end
-
-      -- Return when we can process more jobs
-      return {0, 0, expireTime, 0}
-    end
-
     local jobCounter = tonumber(rcall("INCR", rateLimiterKey))
 
     if jobCounter == 1 then
@@ -65,7 +29,7 @@ local function prepareJobForProcessing(keys, keyPrefix, targetKey, jobId, proces
     rcall("SET", lockKey, opts['token'], "PX", opts['lockDuration'])
   end
 
-  rcall("XADD", keys[4], "*", "event", "active", "jobId", jobId, "prev", "waiting")
+  rcall("XADD", eventStreamKey, "*", "event", "active", "jobId", jobId, "prev", "waiting")
   rcall("HSET", jobKey, "processedOn", processedOn)
   rcall("HINCRBY", jobKey, "ats", 1)
 

package/dist/esm/commands/includes/promoteDelayedJobs.lua

@@ -7,6 +7,7 @@
 ]]
 
 -- Includes
+--- @include "addJobInTargetList"
 --- @include "addJobWithPriority"
 
 -- Try to get as much as 1000 jobs at once
@@ -24,10 +25,7 @@ local function promoteDelayedJobs(delayedKey, markerKey, targetKey, prioritizedK
 
             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/commands/moveJobsToWait-7.lua

@@ -26,6 +26,7 @@ local timestamp = tonumber(ARGV[2])
 local rcall = redis.call;
 
 -- Includes
+--- @include "includes/addBaseMarkerIfNeeded"
 --- @include "includes/batches"
 --- @include "includes/getOrSetMaxEvents"
 --- @include "includes/getTargetQueueList"
@@ -61,9 +62,7 @@ if (#jobs > 0) then
         rcall("LPUSH", target, unpack(jobs, from, to))
     end
 
-    if not paused then
-        rcall("ZADD", KEYS[7], 0, "0")
-    end    
+    addBaseMarkerIfNeeded(KEYS[7], paused)
 end
 
 maxCount = maxCount - #jobs

package/dist/esm/commands/moveStalledJobsToWait-9.lua

@@ -0,0 +1,150 @@
+--[[
+  Move stalled jobs to wait.
+
+    Input:
+      KEYS[1] 'stalled' (SET)
+      KEYS[2] 'wait',   (LIST)
+      KEYS[3] 'active', (LIST)
+      KEYS[4] 'failed', (ZSET)
+      KEYS[5] 'stalled-check', (KEY)
+      KEYS[6] 'meta', (KEY)
+      KEYS[7] 'paused', (LIST)
+      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.
+]]
+
+local rcall = redis.call
+
+-- Includes
+--- @include "includes/addJobInTargetList"
+--- @include "includes/batches"
+--- @include "includes/getTargetQueueList"
+--- @include "includes/removeJob"
+--- @include "includes/removeJobsByMaxAge"
+--- @include "includes/removeJobsByMaxCount"
+--- @include "includes/trimEvents"
+
+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
+                        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
+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
+
+return {failed, stalled}

package/dist/esm/commands/moveToActive-11.lua

@@ -37,6 +37,7 @@
 local rcall = redis.call
 local waitKey = KEYS[1]
 local activeKey = KEYS[2]
+local eventStreamKey = KEYS[4]
 local rateLimiterKey = KEYS[6]
 local delayedKey = KEYS[7]
 local opts = cmsgpack.unpack(ARGV[3])
@@ -53,7 +54,7 @@ local target, paused = getTargetQueueList(KEYS[9], waitKey, KEYS[8])
 
 -- Check if there are delayed jobs that we can move to wait.
 local markerKey = KEYS[11]
-promoteDelayedJobs(delayedKey, markerKey, target, KEYS[3], KEYS[4], ARGV[1],
+promoteDelayedJobs(delayedKey, markerKey, target, KEYS[3], eventStreamKey, ARGV[1],
                    ARGV[2], KEYS[10], paused)
 
 local maxJobs = tonumber(opts['limiter'] and opts['limiter']['max'])
@@ -75,13 +76,13 @@ if jobId and string.sub(jobId, 1, 2) == "0:" then
 end
 
 if jobId then
-    return prepareJobForProcessing(KEYS, ARGV[1], target, jobId, ARGV[2],
-                                   maxJobs, expireTime, opts)
+    return prepareJobForProcessing(ARGV[1], rateLimiterKey, eventStreamKey, jobId, ARGV[2],
+                                   maxJobs, opts)
 else
     jobId = moveJobFromPriorityToActive(KEYS[3], activeKey, KEYS[10])
     if jobId then
-        return prepareJobForProcessing(KEYS, ARGV[1], target, jobId, ARGV[2],
-                                       maxJobs, expireTime, opts)
+        return prepareJobForProcessing(ARGV[1], rateLimiterKey, eventStreamKey, jobId, ARGV[2],
+                                       maxJobs, opts)
     end
 end
 

package/dist/esm/commands/moveToFinished-14.lua

@@ -57,6 +57,7 @@ local rcall = redis.call
 --- Includes
 --- @include "includes/collectMetrics"
 --- @include "includes/getNextDelayedTimestamp"
+--- @include "includes/getTargetQueueList"
 --- @include "includes/moveJobFromPriorityToActive"
 --- @include "includes/prepareJobForProcessing"
 --- @include "includes/moveParentFromWaitingChildrenToFailed"
@@ -118,9 +119,10 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
 
     if (numRemovedElements < 1) then return -3 end
 
+    local eventStreamKey = KEYS[4]
     local metaKey = KEYS[9]
     -- Trim events before emiting them to avoid trimming events emitted in this script
-    trimEvents(metaKey, KEYS[4])
+    trimEvents(metaKey, eventStreamKey)
 
     -- If job has a parent we need to
     -- 1) remove this job id from parents dependencies
@@ -182,12 +184,12 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
         end
     end
 
-    rcall("XADD", KEYS[4], "*", "event", ARGV[5], "jobId", jobId, ARGV[3],
+    rcall("XADD", eventStreamKey, "*", "event", ARGV[5], "jobId", jobId, ARGV[3],
           ARGV[4])
 
     if ARGV[5] == "failed" then
         if tonumber(attemptsMade) >= tonumber(attempts) then
-            rcall("XADD", KEYS[4], "*", "event", "retries-exhausted", "jobId",
+            rcall("XADD", eventStreamKey, "*", "event", "retries-exhausted", "jobId",
                   jobId, "attemptsMade", attemptsMade)
         end
     end
@@ -204,7 +206,7 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
         local target, paused = getTargetQueueList(metaKey, KEYS[1], KEYS[8])
 
         -- Check if there are delayed jobs that can be promoted
-        promoteDelayedJobs(KEYS[7], KEYS[14], target, KEYS[3], KEYS[4], ARGV[7],
+        promoteDelayedJobs(KEYS[7], KEYS[14], target, KEYS[3], eventStreamKey, ARGV[7],
                            timestamp, KEYS[10], paused)
 
         local maxJobs = tonumber(opts['limiter'] and opts['limiter']['max'])
@@ -228,20 +230,20 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
                 if jobId == "0:0" then
                     jobId = moveJobFromPriorityToActive(KEYS[3], KEYS[2],
                                                         KEYS[10])
-                    return prepareJobForProcessing(KEYS, ARGV[7], target, jobId,
+                    return prepareJobForProcessing(ARGV[7], KEYS[6], eventStreamKey, jobId,
                                                    timestamp, maxJobs,
-                                                   expireTime, opts)
+                                                   opts)
                 end
             else
-                return prepareJobForProcessing(KEYS, ARGV[7], target, jobId,
-                                               timestamp, maxJobs, expireTime,
+                return prepareJobForProcessing(ARGV[7], KEYS[6], eventStreamKey, jobId,
+                                               timestamp, maxJobs,
                                                opts)
             end
         else
             jobId = moveJobFromPriorityToActive(KEYS[3], KEYS[2], KEYS[10])
             if jobId then
-                return prepareJobForProcessing(KEYS, ARGV[7], target, jobId,
-                                               timestamp, maxJobs, expireTime,
+                return prepareJobForProcessing(ARGV[7], KEYS[6], eventStreamKey, jobId,
+                                               timestamp, maxJobs,
                                                opts)
             end
         end
@@ -263,7 +265,7 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
             local prioritizedLen = rcall("ZCARD", KEYS[3])
 
             if prioritizedLen == 0 then
-                rcall("XADD", KEYS[4], "*", "event", "drained")
+                rcall("XADD", eventStreamKey, "*", "event", "drained")
             end
         end
     end

package/dist/esm/commands/pause-7.lua

@@ -22,6 +22,7 @@ local rcall = redis.call
 
 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

package/dist/esm/commands/promote-8.lua

@@ -25,6 +25,7 @@ local rcall = redis.call
 local jobId = ARGV[2]
 
 -- Includes
+--- @include "includes/addJobInTargetList"
 --- @include "includes/addJobWithPriority"
 --- @include "includes/getTargetQueueList"
 
@@ -42,8 +43,7 @@ if rcall("ZREM", KEYS[1], jobId) == 1 then
 
     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/commands/retryJob-10.lua

@@ -60,6 +60,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/addDelayedJob-6.js

@@ -46,7 +46,7 @@ local parentData
 -- Includes
 --[[
   Add delay marker if needed.
-]] 
+]]
 -- Includes
 --[[
   Function to return the next delayed job timestamp.
@@ -127,16 +127,31 @@ end
   Validate and move parent to active if needed.
 ]]
 -- 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
@@ -172,11 +187,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,

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

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