bullmq 5.46.1 → 5.47.1

package/dist/esm/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/esm/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/esm/scripts/addDelayedJob-6.js

@@ -159,9 +159,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.
 ]]
@@ -231,12 +233,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"
@@ -245,32 +244,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/esm/scripts/addDelayedJob-6.js.map

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

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

@@ -270,7 +270,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)
@@ -298,10 +298,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
@@ -329,10 +329,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/esm/scripts/addParentJob-4.js

@@ -91,9 +91,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.
 ]]
@@ -187,12 +189,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"
@@ -201,32 +200,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/esm/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;AACF,MAAM,CAAC,MAAM,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;AACF,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,IAAI,EAAE,cAAc;IACpB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

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

@@ -153,9 +153,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.
 ]]
@@ -224,12 +226,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"
@@ -238,32 +237,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/esm/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;AACF,MAAM,CAAC,MAAM,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;AACF,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B,IAAI,EAAE,mBAAmB;IACzB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

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

@@ -97,7 +97,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)
@@ -125,10 +125,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
@@ -156,10 +156,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/esm/scripts/addStandardJob-8.js

@@ -137,9 +137,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.
 ]]
@@ -197,12 +199,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"
@@ -211,32 +210,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/esm/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;AACF,MAAM,CAAC,MAAM,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;AACF,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,IAAI,EAAE,gBAAgB;IACtB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

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

@@ -133,7 +133,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)
@@ -161,10 +161,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
@@ -192,10 +192,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