bullmq 5.46.1 → 5.47.1

package/dist/cjs/scripts/addPrioritizedJob-8.js

@@ -156,9 +156,11 @@ end
 ]]
 -- Includes
 --[[
-  Validate and move parent to active if needed.
+  Validate and move parent to a wait status (waiting, delayed or prioritized) if needed.
+]]
+--[[
+  Validate and move parent to a wait status (wait, prioritized or delayed)
 ]]
--- Includes
 --[[
   Add delay marker if needed.
 ]]
@@ -227,12 +229,9 @@ local function getTargetQueueList(queueMetaKey, activeKey, waitKey, pausedKey)
   end
   return waitKey, false
 end
-local function moveParentToWaitIfNeeded(parentQueueKey, parentDependenciesKey,
-                                        parentKey, parentId, timestamp)
-    local isParentActive = rcall("ZSCORE",
-                                 parentQueueKey .. ":waiting-children", parentId)
-    if isParentActive and rcall("SCARD", parentDependenciesKey) == 0 then
-        rcall("ZREM", parentQueueKey .. ":waiting-children", parentId)
+local function moveParentToWait(parentQueueKey, parentKey, parentId, timestamp)
+    local isParentWaitingChildren = rcall("ZREM", parentQueueKey .. ":waiting-children", parentId)
+    if isParentWaitingChildren > 0 then
         local parentWaitKey = parentQueueKey .. ":wait"
         local parentPausedKey = parentQueueKey .. ":paused"
         local parentActiveKey = parentQueueKey .. ":active"
@@ -241,32 +240,37 @@ local function moveParentToWaitIfNeeded(parentQueueKey, parentDependenciesKey,
         local jobAttributes = rcall("HMGET", parentKey, "priority", "delay")
         local priority = tonumber(jobAttributes[1]) or 0
         local delay = tonumber(jobAttributes[2]) or 0
+        -- ignore dependencies if any left
+        rcall("HSET", parentKey, "igdp", 1)
         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)
+            rcall("XADD", parentQueueKey .. ":events", "*", "event", "delayed", "jobId", parentId, "delay",
+                delayedTimestamp)
             addDelayMarkerIfNeeded(parentMarkerKey, parentDelayedKey)
         else
             if priority == 0 then
-                local parentTarget, isParentPausedOrMaxed =
-                    getTargetQueueList(parentMetaKey, parentActiveKey, parentWaitKey,
-                                       parentPausedKey)
-                addJobInTargetList(parentTarget, parentMarkerKey, "RPUSH", isParentPausedOrMaxed,
-                    parentId)
+                local parentTarget, isParentPausedOrMaxed = getTargetQueueList(parentMetaKey, parentActiveKey,
+                    parentWaitKey, parentPausedKey)
+                addJobInTargetList(parentTarget, parentMarkerKey, "RPUSH", isParentPausedOrMaxed, parentId)
             else
                 local isPausedOrMaxed = isQueuePausedOrMaxed(parentMetaKey, parentActiveKey)
-                addJobWithPriority(parentMarkerKey,
-                                   parentQueueKey .. ":prioritized", priority,
-                                   parentId, parentQueueKey .. ":pc", isPausedOrMaxed)
+                addJobWithPriority(parentMarkerKey, parentQueueKey .. ":prioritized", priority, parentId,
+                    parentQueueKey .. ":pc", isPausedOrMaxed)
             end
-            rcall("XADD", parentQueueKey .. ":events", "*", "event", "waiting",
-                  "jobId", parentId, "prev", "waiting-children")
+            rcall("XADD", parentQueueKey .. ":events", "*", "event", "waiting", "jobId", parentId, "prev",
+                "waiting-children")
         end
     end
 end
+local function moveParentToWaitIfNeeded(parentQueueKey, parentDependenciesKey, parentKey, parentId, timestamp)
+    local hasPendingDependencies = rcall("SCARD", parentDependenciesKey) == 0
+    if hasPendingDependencies then
+        moveParentToWait(parentQueueKey, parentKey, parentId, timestamp)
+    end
+end
 local function updateParentDepsIfNeeded(parentKey, parentQueueKey, parentDependenciesKey,
   parentId, jobIdKey, returnvalue, timestamp )
   local processedSet = parentKey .. ":processed"

package/dist/cjs/scripts/addPrioritizedJob-8.js.map

@@ -1 +1 @@
-{"version":3,"file":"addPrioritizedJob-8.js","sourceRoot":"","sources":["../../../src/scripts/addPrioritizedJob-8.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0Vf,CAAC;AACW,QAAA,iBAAiB,GAAG;IAC/B,IAAI,EAAE,mBAAmB;IACzB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}
+{"version":3,"file":"addPrioritizedJob-8.js","sourceRoot":"","sources":["../../../src/scripts/addPrioritizedJob-8.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8Vf,CAAC;AACW,QAAA,iBAAiB,GAAG;IAC/B,IAAI,EAAE,mBAAmB;IACzB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

package/dist/cjs/scripts/addRepeatableJob-2.js

@@ -100,7 +100,7 @@ local function getTargetQueueList(queueMetaKey, activeKey, waitKey, pausedKey)
   end
   return waitKey, false
 end
-local function moveParentToWait(parentPrefix, parentId, emitEvent)
+local function _moveParentToWait(parentPrefix, parentId, emitEvent)
   local parentTarget, isPausedOrMaxed = getTargetQueueList(parentPrefix .. "meta", parentPrefix .. "active",
     parentPrefix .. "wait", parentPrefix .. "paused")
   addJobInTargetList(parentTarget, parentPrefix .. "marker", "RPUSH", isPausedOrMaxed, parentId)
@@ -128,10 +128,10 @@ local function removeParentDependencyKey(jobKey, hard, parentKey, baseKey, debou
                 rcall("DEL", parentPrefix .. "de:" .. debounceId)
               end
             else
-              moveParentToWait(parentPrefix, parentId)
+              _moveParentToWait(parentPrefix, parentId)
             end
           else
-            moveParentToWait(parentPrefix, parentId, true)
+            _moveParentToWait(parentPrefix, parentId, true)
           end
         end
       end
@@ -159,10 +159,10 @@ local function removeParentDependencyKey(jobKey, hard, parentKey, baseKey, debou
                   rcall("DEL", parentPrefix .. "de:" .. parentAttributes[2])
                 end
               else
-                moveParentToWait(parentPrefix, parentId)
+                _moveParentToWait(parentPrefix, parentId)
               end
             else
-              moveParentToWait(parentPrefix, parentId, true)
+              _moveParentToWait(parentPrefix, parentId, true)
             end
           end
         end

package/dist/cjs/scripts/addStandardJob-8.js

@@ -140,9 +140,11 @@ end
 ]]
 -- Includes
 --[[
-  Validate and move parent to active if needed.
+  Validate and move parent to a wait status (waiting, delayed or prioritized) if needed.
+]]
+--[[
+  Validate and move parent to a wait status (wait, prioritized or delayed)
 ]]
--- Includes
 --[[
   Add delay marker if needed.
 ]]
@@ -200,12 +202,9 @@ local function isQueuePausedOrMaxed(queueMetaKey, activeKey)
   end
   return false
 end
-local function moveParentToWaitIfNeeded(parentQueueKey, parentDependenciesKey,
-                                        parentKey, parentId, timestamp)
-    local isParentActive = rcall("ZSCORE",
-                                 parentQueueKey .. ":waiting-children", parentId)
-    if isParentActive and rcall("SCARD", parentDependenciesKey) == 0 then
-        rcall("ZREM", parentQueueKey .. ":waiting-children", parentId)
+local function moveParentToWait(parentQueueKey, parentKey, parentId, timestamp)
+    local isParentWaitingChildren = rcall("ZREM", parentQueueKey .. ":waiting-children", parentId)
+    if isParentWaitingChildren > 0 then
         local parentWaitKey = parentQueueKey .. ":wait"
         local parentPausedKey = parentQueueKey .. ":paused"
         local parentActiveKey = parentQueueKey .. ":active"
@@ -214,32 +213,37 @@ local function moveParentToWaitIfNeeded(parentQueueKey, parentDependenciesKey,
         local jobAttributes = rcall("HMGET", parentKey, "priority", "delay")
         local priority = tonumber(jobAttributes[1]) or 0
         local delay = tonumber(jobAttributes[2]) or 0
+        -- ignore dependencies if any left
+        rcall("HSET", parentKey, "igdp", 1)
         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)
+            rcall("XADD", parentQueueKey .. ":events", "*", "event", "delayed", "jobId", parentId, "delay",
+                delayedTimestamp)
             addDelayMarkerIfNeeded(parentMarkerKey, parentDelayedKey)
         else
             if priority == 0 then
-                local parentTarget, isParentPausedOrMaxed =
-                    getTargetQueueList(parentMetaKey, parentActiveKey, parentWaitKey,
-                                       parentPausedKey)
-                addJobInTargetList(parentTarget, parentMarkerKey, "RPUSH", isParentPausedOrMaxed,
-                    parentId)
+                local parentTarget, isParentPausedOrMaxed = getTargetQueueList(parentMetaKey, parentActiveKey,
+                    parentWaitKey, parentPausedKey)
+                addJobInTargetList(parentTarget, parentMarkerKey, "RPUSH", isParentPausedOrMaxed, parentId)
             else
                 local isPausedOrMaxed = isQueuePausedOrMaxed(parentMetaKey, parentActiveKey)
-                addJobWithPriority(parentMarkerKey,
-                                   parentQueueKey .. ":prioritized", priority,
-                                   parentId, parentQueueKey .. ":pc", isPausedOrMaxed)
+                addJobWithPriority(parentMarkerKey, parentQueueKey .. ":prioritized", priority, parentId,
+                    parentQueueKey .. ":pc", isPausedOrMaxed)
             end
-            rcall("XADD", parentQueueKey .. ":events", "*", "event", "waiting",
-                  "jobId", parentId, "prev", "waiting-children")
+            rcall("XADD", parentQueueKey .. ":events", "*", "event", "waiting", "jobId", parentId, "prev",
+                "waiting-children")
         end
     end
 end
+local function moveParentToWaitIfNeeded(parentQueueKey, parentDependenciesKey, parentKey, parentId, timestamp)
+    local hasPendingDependencies = rcall("SCARD", parentDependenciesKey) == 0
+    if hasPendingDependencies then
+        moveParentToWait(parentQueueKey, parentKey, parentId, timestamp)
+    end
+end
 local function updateParentDepsIfNeeded(parentKey, parentQueueKey, parentDependenciesKey,
   parentId, jobIdKey, returnvalue, timestamp )
   local processedSet = parentKey .. ":processed"

package/dist/cjs/scripts/addStandardJob-8.js.map

@@ -1 +1 @@
-{"version":3,"file":"addStandardJob-8.js","sourceRoot":"","sources":["../../../src/scripts/addStandardJob-8.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8Vf,CAAC;AACW,QAAA,cAAc,GAAG;IAC5B,IAAI,EAAE,gBAAgB;IACtB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}
+{"version":3,"file":"addStandardJob-8.js","sourceRoot":"","sources":["../../../src/scripts/addStandardJob-8.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkWf,CAAC;AACW,QAAA,cAAc,GAAG;IAC5B,IAAI,EAAE,gBAAgB;IACtB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

package/dist/cjs/scripts/cleanJobsInSet-3.js

@@ -136,7 +136,7 @@ local function getTargetQueueList(queueMetaKey, activeKey, waitKey, pausedKey)
   end
   return waitKey, false
 end
-local function moveParentToWait(parentPrefix, parentId, emitEvent)
+local function _moveParentToWait(parentPrefix, parentId, emitEvent)
   local parentTarget, isPausedOrMaxed = getTargetQueueList(parentPrefix .. "meta", parentPrefix .. "active",
     parentPrefix .. "wait", parentPrefix .. "paused")
   addJobInTargetList(parentTarget, parentPrefix .. "marker", "RPUSH", isPausedOrMaxed, parentId)
@@ -164,10 +164,10 @@ local function removeParentDependencyKey(jobKey, hard, parentKey, baseKey, debou
                 rcall("DEL", parentPrefix .. "de:" .. debounceId)
               end
             else
-              moveParentToWait(parentPrefix, parentId)
+              _moveParentToWait(parentPrefix, parentId)
             end
           else
-            moveParentToWait(parentPrefix, parentId, true)
+            _moveParentToWait(parentPrefix, parentId, true)
           end
         end
       end
@@ -195,10 +195,10 @@ local function removeParentDependencyKey(jobKey, hard, parentKey, baseKey, debou
                   rcall("DEL", parentPrefix .. "de:" .. parentAttributes[2])
                 end
               else
-                moveParentToWait(parentPrefix, parentId)
+                _moveParentToWait(parentPrefix, parentId)
               end
             else
-              moveParentToWait(parentPrefix, parentId, true)
+              _moveParentToWait(parentPrefix, parentId, true)
             end
           end
         end

package/dist/cjs/scripts/drain-5.js

@@ -108,7 +108,7 @@ local function getTargetQueueList(queueMetaKey, activeKey, waitKey, pausedKey)
   end
   return waitKey, false
 end
-local function moveParentToWait(parentPrefix, parentId, emitEvent)
+local function _moveParentToWait(parentPrefix, parentId, emitEvent)
   local parentTarget, isPausedOrMaxed = getTargetQueueList(parentPrefix .. "meta", parentPrefix .. "active",
     parentPrefix .. "wait", parentPrefix .. "paused")
   addJobInTargetList(parentTarget, parentPrefix .. "marker", "RPUSH", isPausedOrMaxed, parentId)
@@ -136,10 +136,10 @@ local function removeParentDependencyKey(jobKey, hard, parentKey, baseKey, debou
                 rcall("DEL", parentPrefix .. "de:" .. debounceId)
               end
             else
-              moveParentToWait(parentPrefix, parentId)
+              _moveParentToWait(parentPrefix, parentId)
             end
           else
-            moveParentToWait(parentPrefix, parentId, true)
+            _moveParentToWait(parentPrefix, parentId, true)
           end
         end
       end
@@ -167,10 +167,10 @@ local function removeParentDependencyKey(jobKey, hard, parentKey, baseKey, debou
                   rcall("DEL", parentPrefix .. "de:" .. parentAttributes[2])
                 end
               else
-                moveParentToWait(parentPrefix, parentId)
+                _moveParentToWait(parentPrefix, parentId)
               end
             else
-              moveParentToWait(parentPrefix, parentId, true)
+              _moveParentToWait(parentPrefix, parentId, true)
             end
           end
         end

package/dist/cjs/scripts/moveStalledJobsToWait-9.js

@@ -79,9 +79,11 @@ end
 ]]
 -- Includes
 --[[
-  Validate and move parent to active if needed.
+  Validate and move parent to a wait status (waiting, delayed or prioritized) if needed.
+]]
+--[[
+  Validate and move parent to a wait status (wait, prioritized or delayed)
 ]]
--- Includes
 --[[
   Add delay marker if needed.
 ]]
@@ -139,12 +141,9 @@ local function isQueuePausedOrMaxed(queueMetaKey, activeKey)
   end
   return false
 end
-local function moveParentToWaitIfNeeded(parentQueueKey, parentDependenciesKey,
-                                        parentKey, parentId, timestamp)
-    local isParentActive = rcall("ZSCORE",
-                                 parentQueueKey .. ":waiting-children", parentId)
-    if isParentActive and rcall("SCARD", parentDependenciesKey) == 0 then
-        rcall("ZREM", parentQueueKey .. ":waiting-children", parentId)
+local function moveParentToWait(parentQueueKey, parentKey, parentId, timestamp)
+    local isParentWaitingChildren = rcall("ZREM", parentQueueKey .. ":waiting-children", parentId)
+    if isParentWaitingChildren > 0 then
         local parentWaitKey = parentQueueKey .. ":wait"
         local parentPausedKey = parentQueueKey .. ":paused"
         local parentActiveKey = parentQueueKey .. ":active"
@@ -153,32 +152,37 @@ local function moveParentToWaitIfNeeded(parentQueueKey, parentDependenciesKey,
         local jobAttributes = rcall("HMGET", parentKey, "priority", "delay")
         local priority = tonumber(jobAttributes[1]) or 0
         local delay = tonumber(jobAttributes[2]) or 0
+        -- ignore dependencies if any left
+        rcall("HSET", parentKey, "igdp", 1)
         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)
+            rcall("XADD", parentQueueKey .. ":events", "*", "event", "delayed", "jobId", parentId, "delay",
+                delayedTimestamp)
             addDelayMarkerIfNeeded(parentMarkerKey, parentDelayedKey)
         else
             if priority == 0 then
-                local parentTarget, isParentPausedOrMaxed =
-                    getTargetQueueList(parentMetaKey, parentActiveKey, parentWaitKey,
-                                       parentPausedKey)
-                addJobInTargetList(parentTarget, parentMarkerKey, "RPUSH", isParentPausedOrMaxed,
-                    parentId)
+                local parentTarget, isParentPausedOrMaxed = getTargetQueueList(parentMetaKey, parentActiveKey,
+                    parentWaitKey, parentPausedKey)
+                addJobInTargetList(parentTarget, parentMarkerKey, "RPUSH", isParentPausedOrMaxed, parentId)
             else
                 local isPausedOrMaxed = isQueuePausedOrMaxed(parentMetaKey, parentActiveKey)
-                addJobWithPriority(parentMarkerKey,
-                                   parentQueueKey .. ":prioritized", priority,
-                                   parentId, parentQueueKey .. ":pc", isPausedOrMaxed)
+                addJobWithPriority(parentMarkerKey, parentQueueKey .. ":prioritized", priority, parentId,
+                    parentQueueKey .. ":pc", isPausedOrMaxed)
             end
-            rcall("XADD", parentQueueKey .. ":events", "*", "event", "waiting",
-                  "jobId", parentId, "prev", "waiting-children")
+            rcall("XADD", parentQueueKey .. ":events", "*", "event", "waiting", "jobId", parentId, "prev",
+                "waiting-children")
         end
     end
 end
+local function moveParentToWaitIfNeeded(parentQueueKey, parentDependenciesKey, parentKey, parentId, timestamp)
+    local hasPendingDependencies = rcall("SCARD", parentDependenciesKey) == 0
+    if hasPendingDependencies then
+        moveParentToWait(parentQueueKey, parentKey, parentId, timestamp)
+    end
+end
 --[[
   Function to remove deduplication key if needed.
 ]]
@@ -232,7 +236,7 @@ end
 local getJobKeyPrefix = function (jobKey, jobId)
   return string.sub(jobKey, 0, #jobKey - #jobId)
 end
-local function moveParentToWait(parentPrefix, parentId, emitEvent)
+local function _moveParentToWait(parentPrefix, parentId, emitEvent)
   local parentTarget, isPausedOrMaxed = getTargetQueueList(parentPrefix .. "meta", parentPrefix .. "active",
     parentPrefix .. "wait", parentPrefix .. "paused")
   addJobInTargetList(parentTarget, parentPrefix .. "marker", "RPUSH", isPausedOrMaxed, parentId)
@@ -260,10 +264,10 @@ local function removeParentDependencyKey(jobKey, hard, parentKey, baseKey, debou
                 rcall("DEL", parentPrefix .. "de:" .. debounceId)
               end
             else
-              moveParentToWait(parentPrefix, parentId)
+              _moveParentToWait(parentPrefix, parentId)
             end
           else
-            moveParentToWait(parentPrefix, parentId, true)
+            _moveParentToWait(parentPrefix, parentId, true)
           end
         end
       end
@@ -291,10 +295,10 @@ local function removeParentDependencyKey(jobKey, hard, parentKey, baseKey, debou
                   rcall("DEL", parentPrefix .. "de:" .. parentAttributes[2])
                 end
               else
-                moveParentToWait(parentPrefix, parentId)
+                _moveParentToWait(parentPrefix, parentId)
               end
             else
-              moveParentToWait(parentPrefix, parentId, true)
+              _moveParentToWait(parentPrefix, parentId, true)
             end
           end
         end
@@ -402,6 +406,8 @@ local function moveParentToFailedIfNeeded(parentQueueKey, parentKey, parentId, j
             parentKey,
             timestamp
           )
+        elseif parentData['cpof'] then
+          moveParentToWait(parentData['queueKey'], parentKey, parentData['id'], timestamp)
         elseif parentData['idof'] or parentData['rdof'] then
           local grandParentKey = parentData['queueKey'] .. ':' .. parentData['id']
           local grandParentDependenciesSet = grandParentKey .. ":dependencies"
@@ -463,7 +469,9 @@ local maxStalledJobCount = tonumber(ARGV[1])
 local queueKeyPrefix = ARGV[2]
 local timestamp = ARGV[3]
 local maxCheckTime = ARGV[4]
-if rcall("EXISTS", stalledCheckKey) == 1 then return {{}, {}} end
+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)
@@ -487,8 +495,7 @@ if (#stalling > 0) then
                 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)
+                    local stalledCount = rcall("HINCRBY", jobKey, "stalledCounter", 1)
                     if (stalledCount > maxStalledJobCount) then
                         local jobAttributes = rcall("HMGET", jobKey, "opts", "parent", "deid")
                         local rawOpts = jobAttributes[1]
@@ -496,38 +503,35 @@ if (#stalling > 0) then
                         local opts = cjson.decode(rawOpts)
                         rcall("ZADD", failedKey, timestamp, jobId)
                         removeDeduplicationKeyIfNeeded(queueKeyPrefix, jobAttributes[3])
-                        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)
+                        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 rawParentData then
-                            if opts['fpof'] then
+                            if opts['fpof'] or opts['cpof'] then
                                 local parentData = cjson.decode(rawParentData)
                                 -- TODO: need to remove this job from dependencies set in next breaking change
                                 -- no for now as it would imply a breaking change
                                 local parentKey = parentData['queueKey'] .. ':' .. parentData['id']
                                 local unsuccesssfulSet = parentKey .. ":unsuccessful"
                                 rcall("ZADD", unsuccesssfulSet, timestamp, jobKey)
-                                moveParentToFailedIfNeeded(
-                                    parentData['queueKey'],
-                                    parentData['queueKey'] .. ':' .. parentData['id'],
-                                    parentData['id'],
-                                    jobKey,
-                                    timestamp
-                                )
+                                if opts['fpof'] then
+                                    moveParentToFailedIfNeeded(parentData['queueKey'],
+                                        parentData['queueKey'] .. ':' .. parentData['id'], parentData['id'], jobKey,
+                                        timestamp)
+                                elseif opts['cpof'] then
+                                    moveParentToWait(parentData['queueKey'], parentKey, parentData['id'], timestamp)
+                                end
                             elseif opts['idof'] or opts['rdof'] then
                                 local parentData = cjson.decode(rawParentData)
                                 local parentKey = parentData['queueKey'] .. ':' .. parentData['id']
                                 local dependenciesSet = parentKey .. ":dependencies"
                                 if rcall("SREM", dependenciesSet, jobKey) == 1 then
-                                    moveParentToWaitIfNeeded(parentData['queueKey'], dependenciesSet,
-                                                             parentKey, parentData['id'], timestamp)
+                                    moveParentToWaitIfNeeded(parentData['queueKey'], dependenciesSet, parentKey,
+                                        parentData['id'], timestamp)
                                     if opts['idof'] then
-                                       local failedSet = parentKey .. ":failed"
-                                       rcall("HSET", failedSet, jobKey, failedReason)
+                                        local failedSet = parentKey .. ":failed"
+                                        rcall("HSET", failedSet, jobKey, failedReason)
                                     end
                                 end
                             end
@@ -535,15 +539,12 @@ if (#stalling > 0) then
                         removeJobsOnFail(queueKeyPrefix, failedKey, jobId, opts, timestamp)
                         table.insert(failed, jobId)
                     else
-                        local target, isPausedOrMaxed =
-                            getTargetQueueList(metaKey, activeKey, waitKey, pausedKey)
+                        local target, isPausedOrMaxed = getTargetQueueList(metaKey, activeKey, waitKey, pausedKey)
                         -- Move the job back to the wait queue, to immediately be picked up by a waiting worker.
                         addJobInTargetList(target, markerKey, "RPUSH", isPausedOrMaxed, 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
@@ -558,7 +559,8 @@ if (#active > 0) then
         rcall('SADD', stalledKey, unpack(active, from, to))
     end
 end
-return {failed, stalled}`;
+return {failed, stalled}
+`;
 exports.moveStalledJobsToWait = {
     name: 'moveStalledJobsToWait',
     content,

package/dist/cjs/scripts/moveStalledJobsToWait-9.js.map

@@ -1 +1 @@
-{"version":3,"file":"moveStalledJobsToWait-9.js","sourceRoot":"","sources":["../../../src/scripts/moveStalledJobsToWait-9.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBA6iBS,CAAC;AACb,QAAA,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+iBf,CAAC;AACW,QAAA,qBAAqB,GAAG;IACnC,IAAI,EAAE,uBAAuB;IAC7B,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}