bullmq 5.46.1 → 5.47.0

package/dist/cjs/commands/includes/removeParentDependencyKey.lua

@@ -10,7 +10,7 @@
 --- @include "getTargetQueueList"
 --- @include "removeJobKeys"
 
-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)
@@ -42,10 +42,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
@@ -75,10 +75,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/commands/moveStalledJobsToWait-9.lua

@@ -20,7 +20,6 @@
     Events:
       'stalled' with stalled job id.
 ]]
-
 local rcall = redis.call
 
 -- Includes
@@ -29,6 +28,7 @@ local rcall = redis.call
 --- @include "includes/getTargetQueueList"
 --- @include "includes/moveParentToFailedIfNeeded"
 --- @include "includes/moveParentToWaitIfNeeded"
+--- @include "includes/moveParentToWait"
 --- @include "includes/removeDeduplicationKeyIfNeeded"
 --- @include "includes/removeJobsOnFail"
 --- @include "includes/trimEvents"
@@ -47,7 +47,9 @@ 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)
 
@@ -77,8 +79,7 @@ if (#stalling > 0) then
 
                 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]
@@ -87,39 +88,37 @@ if (#stalling > 0) then
                         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
@@ -129,18 +128,15 @@ if (#stalling > 0) then
 
                         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
@@ -158,4 +154,4 @@ if (#active > 0) then
     end
 end
 
-return {failed, stalled}
+return {failed, stalled}

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

@@ -40,6 +40,7 @@
       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
@@ -64,6 +65,7 @@ local rcall = redis.call
 --- @include "includes/getTargetQueueList"
 --- @include "includes/moveJobFromPriorityToActive"
 --- @include "includes/moveParentToFailedIfNeeded"
+--- @include "includes/moveParentToWait"
 --- @include "includes/moveParentToWaitIfNeeded"
 --- @include "includes/prepareJobForProcessing"
 --- @include "includes/promoteDelayedJobs"
@@ -81,7 +83,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
 
@@ -117,7 +121,9 @@ if rcall("EXISTS", jobIdKey) == 1 then -- Make sure job exists
     -- Remove from active list (if not active we shall return error)
     local numRemovedElements = rcall("LREM", KEYS[2], -1, jobId)
 
-    if (numRemovedElements < 1) then return -3 end
+    if (numRemovedElements < 1) then
+        return -3
+    end
 
     local eventStreamKey = KEYS[4]
     local metaKey = KEYS[9]
@@ -142,22 +148,25 @@ 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])
@@ -195,13 +204,12 @@ if rcall("EXISTS", jobIdKey) == 1 then -- Make sure job exists
         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
 
@@ -218,17 +226,21 @@ if rcall("EXISTS", jobIdKey) == 1 then -- Make sure job exists
 
         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])
 
@@ -240,23 +252,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
 

package/dist/cjs/commands/moveToWaitingChildren-8.lua

@@ -37,6 +37,7 @@ local jobId = ARGV[4]
 
 --- Includes
 --- @include "includes/moveParentToFailedIfNeeded"
+--- @include "includes/moveParentToWait"
 --- @include "includes/moveParentToWaitIfNeeded"
 --- @include "includes/removeDeduplicationKeyIfNeeded"
 --- @include "includes/removeJobsOnFail"
@@ -75,18 +76,22 @@ if rcall("EXISTS", jobKey) == 1 then
     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/addDelayedJob-6.js

@@ -162,9 +162,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
 --[[
   Function to add job in target list and add marker if needed.
 ]]
@@ -234,12 +236,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"
@@ -248,32 +247,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/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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyXf,CAAC;AACW,QAAA,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6Xf,CAAC;AACW,QAAA,aAAa,GAAG;IAC3B,IAAI,EAAE,eAAe;IACrB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

package/dist/cjs/scripts/addJobScheduler-11.js

@@ -273,7 +273,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)
@@ -301,10 +301,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
@@ -332,10 +332,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/addParentJob-4.js

@@ -94,9 +94,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.
 ]]
@@ -190,12 +192,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"
@@ -204,32 +203,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/addParentJob-4.js.map

@@ -1 +1 @@
-{"version":3,"file":"addParentJob-4.js","sourceRoot":"","sources":["../../../src/scripts/addParentJob-4.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgVf,CAAC;AACW,QAAA,YAAY,GAAG;IAC1B,IAAI,EAAE,cAAc;IACpB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}
+{"version":3,"file":"addParentJob-4.js","sourceRoot":"","sources":["../../../src/scripts/addParentJob-4.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoVf,CAAC;AACW,QAAA,YAAY,GAAG;IAC1B,IAAI,EAAE,cAAc;IACpB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

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"}