bullmq 5.46.1 → 5.47.1

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

@@ -37,6 +37,7 @@ const content = `--[[
       opts - attempts max attempts
       opts - maxMetricsSize
       opts - fpof - fail parent on fail
+      opts - cpof - continue parent on fail
       opts - idof - ignore dependency on fail
       opts - rdof - remove dependency on fail
       opts - name - worker name
@@ -170,9 +171,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.
 ]]
@@ -234,12 +237,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"
@@ -248,32 +248,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.
 ]]
@@ -327,7 +332,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)
@@ -355,10 +360,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
@@ -386,10 +391,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
@@ -497,6 +502,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"
@@ -658,7 +665,9 @@ local jobIdKey = KEYS[12]
 if rcall("EXISTS", jobIdKey) == 1 then -- Make sure job exists
     -- Make sure it does not have pending dependencies
     -- It must happen before removing lock
-    if ARGV[5] == "completed" and rcall("SCARD", jobIdKey .. ":dependencies") ~= 0 then
+    if ARGV[5] == "completed" and
+        not rcall("HGET", jobIdKey, "igdp") and -- check if we should ignore this check
+        rcall("SCARD", jobIdKey .. ":dependencies") ~= 0 then
         return -4
     end
     local opts = cmsgpack.unpack(ARGV[8])
@@ -685,7 +694,9 @@ if rcall("EXISTS", jobIdKey) == 1 then -- Make sure job exists
     local timestamp = ARGV[2]
     -- 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
+    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
@@ -705,22 +716,24 @@ if rcall("EXISTS", jobIdKey) == 1 then -- Make sure job exists
         if ARGV[5] == "completed" then
             local dependenciesSet = parentKey .. ":dependencies"
             if rcall("SREM", dependenciesSet, jobIdKey) == 1 then
-                updateParentDepsIfNeeded(parentKey, parentQueueKey,
-                                         dependenciesSet, parentId, jobIdKey,
-                                         ARGV[4], timestamp)
+                updateParentDepsIfNeeded(parentKey, parentQueueKey, dependenciesSet, parentId, jobIdKey, ARGV[4],
+                    timestamp)
             end
         else
-            if opts['fpof'] then
+            if opts['fpof'] or opts['cpof'] then
                 local unsuccesssfulSet = parentKey .. ":unsuccessful"
                 rcall("ZADD", unsuccesssfulSet, timestamp, jobIdKey)
-                moveParentToFailedIfNeeded(parentQueueKey, parentKey,
-                                                      parentId, jobIdKey,
-                                                      timestamp)
+                if opts['fpof'] then
+                    moveParentToFailedIfNeeded(parentQueueKey, parentKey, parentId, jobIdKey, timestamp)
+                elseif opts['cpof'] then
+                    local failedSet = parentKey .. ":failed"
+                    rcall("HSET", failedSet, jobIdKey, ARGV[4])
+                    moveParentToWait(parentQueueKey, parentKey, parentId, timestamp)
+                end
             elseif opts['idof'] or opts['rdof'] then
                 local dependenciesSet = parentKey .. ":dependencies"
                 if rcall("SREM", dependenciesSet, jobIdKey) == 1 then
-                    moveParentToWaitIfNeeded(parentQueueKey, dependenciesSet,
-                                             parentKey, parentId, timestamp)
+                    moveParentToWaitIfNeeded(parentQueueKey, dependenciesSet, parentKey, parentId, timestamp)
                     if opts['idof'] then
                         local failedSet = parentKey .. ":failed"
                         rcall("HSET", failedSet, jobIdKey, ARGV[4])
@@ -753,12 +766,11 @@ if rcall("EXISTS", jobIdKey) == 1 then -- Make sure job exists
             removeParentDependencyKey(jobIdKey, false, parentKey, jobAttributes[3])
         end
     end
-    rcall("XADD", eventStreamKey, "*", "event", ARGV[5], "jobId", jobId, ARGV[3],
-          ARGV[4], "prev", "active")
+    rcall("XADD", eventStreamKey, "*", "event", ARGV[5], "jobId", jobId, ARGV[3], ARGV[4], "prev", "active")
     if ARGV[5] == "failed" then
         if tonumber(attemptsMade) >= tonumber(attempts) then
-            rcall("XADD", eventStreamKey, "*", "event", "retries-exhausted", "jobId",
-                  jobId, "attemptsMade", attemptsMade)
+            rcall("XADD", eventStreamKey, "*", "event", "retries-exhausted", "jobId", jobId, "attemptsMade",
+                attemptsMade)
         end
     end
     -- Collect metrics
@@ -771,14 +783,18 @@ if rcall("EXISTS", jobIdKey) == 1 then -- Make sure job exists
         local target, isPausedOrMaxed = getTargetQueueList(metaKey, KEYS[2], KEYS[1], KEYS[8])
         local markerKey = KEYS[14]
         -- Check if there are delayed jobs that can be promoted
-        promoteDelayedJobs(KEYS[7], markerKey, target, KEYS[3], eventStreamKey, prefix,
-                           timestamp, KEYS[10], isPausedOrMaxed)
+        promoteDelayedJobs(KEYS[7], markerKey, target, KEYS[3], eventStreamKey, prefix, timestamp, KEYS[10],
+            isPausedOrMaxed)
         local maxJobs = tonumber(opts['limiter'] and opts['limiter']['max'])
         -- Check if we are rate limited first.
         local expireTime = getRateLimitTTL(maxJobs, KEYS[6])
-        if expireTime > 0 then return {0, 0, expireTime, 0} end
+        if expireTime > 0 then
+            return {0, 0, expireTime, 0}
+        end
         -- paused or maxed queue
-        if isPausedOrMaxed then return {0, 0, 0, 0} end
+        if isPausedOrMaxed 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.
@@ -787,23 +803,19 @@ if rcall("EXISTS", jobIdKey) == 1 then -- Make sure job exists
                 -- 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(prefix, KEYS[6], eventStreamKey, jobId,
-                                                   timestamp, maxJobs, markerKey,
-                                                   opts)
+                    jobId = moveJobFromPriorityToActive(KEYS[3], KEYS[2], KEYS[10])
+                    return prepareJobForProcessing(prefix, KEYS[6], eventStreamKey, jobId, timestamp, maxJobs,
+                        markerKey, opts)
                 end
             else
-                return prepareJobForProcessing(prefix, KEYS[6], eventStreamKey, jobId,
-                                               timestamp, maxJobs, markerKey,
-                                               opts)
+                return prepareJobForProcessing(prefix, KEYS[6], eventStreamKey, jobId, timestamp, maxJobs, markerKey,
+                    opts)
             end
         else
             jobId = moveJobFromPriorityToActive(KEYS[3], KEYS[2], KEYS[10])
             if jobId then
-                return prepareJobForProcessing(prefix, KEYS[6], eventStreamKey, jobId,
-                                               timestamp, maxJobs, markerKey,
-                                               opts)
+                return prepareJobForProcessing(prefix, KEYS[6], eventStreamKey, jobId, timestamp, maxJobs, markerKey,
+                    opts)
             end
         end
         -- Return the timestamp for the next delayed job if any.

package/dist/cjs/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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2zBf,CAAC;AACW,QAAA,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAu0Bf,CAAC;AACW,QAAA,cAAc,GAAG;IAC5B,IAAI,EAAE,gBAAgB;IACtB,OAAO;IACP,IAAI,EAAE,EAAE;CACT,CAAC"}

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

@@ -40,9 +40,11 @@ local jobId = ARGV[4]
 ]]
 -- 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.
 ]]
@@ -136,12 +138,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"
@@ -150,32 +149,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.
 ]]
@@ -229,7 +233,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)
@@ -257,10 +261,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
@@ -288,10 +292,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
@@ -399,6 +403,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"
@@ -467,18 +473,22 @@ if rcall("EXISTS", jobKey) == 1 then
     local rawOpts = jobAttributes[3]
     local opts = cjson.decode(rawOpts)
     if rawParentData ~= false then
-      if opts['fpof'] then
+      if opts['fpof'] or opts['cpof'] then
         local parentData = cjson.decode(rawParentData)
         local parentKey = parentData['queueKey'] .. ':' .. parentData['id']
         local parentUnsuccesssful = parentKey .. ":unsuccessful"
         rcall("ZADD", parentUnsuccesssful, 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']

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

@@ -1 +1 @@
-{"version":3,"file":"moveToWaitingChildren-8.js","sourceRoot":"","sources":["../../../src/scripts/moveToWaitingChildren-8.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqgBf,CAAC;AACW,QAAA,qBAAqB,GAAG;IACnC,IAAI,EAAE,uBAAuB;IAC7B,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}
+{"version":3,"file":"moveToWaitingChildren-8.js","sourceRoot":"","sources":["../../../src/scripts/moveToWaitingChildren-8.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+gBf,CAAC;AACW,QAAA,qBAAqB,GAAG;IACnC,IAAI,EAAE,uBAAuB;IAC7B,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

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

@@ -96,7 +96,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)
@@ -124,10 +124,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
@@ -155,10 +155,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/removeChildDependency-1.js

@@ -77,7 +77,7 @@ local function removeJobKeys(jobKey)
   return rcall("DEL", jobKey, jobKey .. ':logs', jobKey .. ':dependencies',
     jobKey .. ':processed', jobKey .. ':failed', jobKey .. ':unsuccessful')
 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)
@@ -105,10 +105,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
@@ -136,10 +136,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/removeJob-3.js

@@ -172,7 +172,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)
@@ -200,10 +200,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
@@ -231,10 +231,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