bullmq 5.49.0 → 5.49.2

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

@@ -78,12 +78,19 @@ end
   Function to recursively move from waitingChildren to failed.
 ]]
 -- Includes
+--[[
+  Validate and move parent to a wait status (waiting, delayed or prioritized)
+  if no pending dependencies.
+]]
+-- Includes
 --[[
   Validate and move parent to a wait status (waiting, delayed or prioritized) if needed.
 ]]
+-- Includes
 --[[
-  Validate and move parent to a wait status (wait, prioritized or delayed)
+  Move parent to a wait status (wait, prioritized or delayed)
 ]]
+-- Includes
 --[[
   Add delay marker if needed.
 ]]
@@ -142,46 +149,53 @@ local function isQueuePausedOrMaxed(queueMetaKey, activeKey)
   return false
 end
 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"
-        local parentMetaKey = parentQueueKey .. ":meta"
-        local parentMarkerKey = parentQueueKey .. ":marker"
-        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)
-            addDelayMarkerIfNeeded(parentMarkerKey, parentDelayedKey)
+    local parentWaitKey = parentQueueKey .. ":wait"
+    local parentPausedKey = parentQueueKey .. ":paused"
+    local parentActiveKey = parentQueueKey .. ":active"
+    local parentMetaKey = parentQueueKey .. ":meta"
+    local parentMarkerKey = parentQueueKey .. ":marker"
+    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)
+        addDelayMarkerIfNeeded(parentMarkerKey, parentDelayedKey)
+    else
+        if priority == 0 then
+            local parentTarget, isParentPausedOrMaxed = getTargetQueueList(parentMetaKey, parentActiveKey,
+                parentWaitKey, parentPausedKey)
+            addJobInTargetList(parentTarget, parentMarkerKey, "RPUSH", isParentPausedOrMaxed, parentId)
         else
-            if priority == 0 then
-                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)
-            end
-            rcall("XADD", parentQueueKey .. ":events", "*", "event", "waiting", "jobId", parentId, "prev",
-                "waiting-children")
+            local isPausedOrMaxed = isQueuePausedOrMaxed(parentMetaKey, parentActiveKey)
+            addJobWithPriority(parentMarkerKey, parentQueueKey .. ":prioritized", priority, parentId,
+                parentQueueKey .. ":pc", isPausedOrMaxed)
         end
+        rcall("XADD", parentQueueKey .. ":events", "*", "event", "waiting", "jobId", parentId, "prev",
+            "waiting-children")
     end
 end
-local function moveParentToWaitIfNeeded(parentQueueKey, parentDependenciesKey, parentKey, parentId, timestamp)
-    local doNotHavePendingDependencies = rcall("SCARD", parentDependenciesKey) == 0
-    if doNotHavePendingDependencies then
-        moveParentToWait(parentQueueKey, parentKey, parentId, timestamp)
+local function moveParentToWaitIfNeeded(parentQueueKey, parentKey, parentId, timestamp)
+  if rcall("EXISTS", parentKey) == 1 then
+    local parentWaitingChildrenKey = parentQueueKey .. ":waiting-children"
+    if rcall("ZSCORE", parentWaitingChildrenKey, parentId) then    
+      rcall("ZREM", parentWaitingChildrenKey, parentId)
+      moveParentToWait(parentQueueKey, parentKey, parentId, timestamp)
     end
+  end
+end
+local function moveParentToWaitIfNoPendingDependencies(parentQueueKey, parentDependenciesKey, parentKey,
+  parentId, timestamp)
+  local doNotHavePendingDependencies = rcall("SCARD", parentDependenciesKey) == 0
+  if doNotHavePendingDependencies then
+    moveParentToWaitIfNeeded(parentQueueKey, parentKey, parentId, timestamp)
+  end
 end
 --[[
   Function to remove deduplication key if needed.
@@ -372,38 +386,27 @@ moveParentToFailedIfNeeded = function (parentQueueKey, parentKey, parentId, jobI
     local parentWaitingChildrenKey = parentQueueKey .. ":waiting-children"
     local parentDelayedKey = parentQueueKey .. ":delayed"
     local parentPrioritizedKey = parentQueueKey .. ":prioritized"
-    local parentWaitingChildrenOrDelayedOrPrioritizedKey
+    local parentWaitingChildrenOrDelayedKey
     local prevState
     if rcall("ZSCORE", parentWaitingChildrenKey, parentId) then
-      parentWaitingChildrenOrDelayedOrPrioritizedKey = parentWaitingChildrenKey
+      parentWaitingChildrenOrDelayedKey = parentWaitingChildrenKey
       prevState = "waiting-children"
     elseif rcall("ZSCORE", parentDelayedKey, parentId) then
-      parentWaitingChildrenOrDelayedOrPrioritizedKey = parentDelayedKey
+      parentWaitingChildrenOrDelayedKey = parentDelayedKey
       prevState = "delayed"
-    elseif rcall("ZSCORE", parentPrioritizedKey, parentId) then
-      parentWaitingChildrenOrDelayedOrPrioritizedKey = parentPrioritizedKey
-      prevState = "prioritized"
+      rcall("HSET", parentKey, "delay", 0)
     end
-    if parentWaitingChildrenOrDelayedOrPrioritizedKey then
-      rcall("ZREM", parentWaitingChildrenOrDelayedOrPrioritizedKey, parentId)
+    if parentWaitingChildrenOrDelayedKey then
+      rcall("ZREM", parentWaitingChildrenOrDelayedKey, parentId)
       local parentQueuePrefix = parentQueueKey .. ":"
       local parentFailedKey = parentQueueKey .. ":failed"
-      rcall("ZADD", parentFailedKey, timestamp, parentId)
-      local failedReason = "child " .. jobIdKey .. " failed"
-      rcall("HSET", parentKey, "failedReason", failedReason, "finishedOn", timestamp)
-      rcall("XADD", parentQueueKey .. ":events", "*", "event", "failed", "jobId", parentId, "failedReason",
-        failedReason, "prev", prevState)
-      local jobAttributes = rcall("HMGET", parentKey, "parent", "deid", "opts")
-      removeDeduplicationKeyIfNeeded(parentQueueKey .. ":", jobAttributes[2])
-      moveChildFromDependenciesIfNeeded(jobAttributes[1], parentKey, failedReason, timestamp)
-      local parentRawOpts = jobAttributes[3]
-      local parentOpts = cjson.decode(parentRawOpts)
-      removeJobsOnFail(parentQueuePrefix, parentFailedKey, parentId, parentOpts, timestamp)
+      local deferredFailure = "child " .. jobIdKey .. " failed"
+      rcall("HSET", parentKey, "defa", deferredFailure)
+      moveParentToWait(parentQueueKey, parentKey, parentId, timestamp)
     else
-      local grandParentKey = rcall("HGET", parentKey, "parentKey")
-      if grandParentKey then
-        local grandParentUnsuccesssfulSet = grandParentKey .. ":unsuccessful"
-        rcall("ZADD", grandParentUnsuccesssfulSet, timestamp, parentKey)
+      if not rcall("ZSCORE", parentQueueKey .. ":failed", parentId) then
+        local deferredFailure = "child " .. jobIdKey .. " failed"
+        rcall("HSET", parentKey, "defa", deferredFailure)
       end
     end
   end
@@ -429,11 +432,11 @@ moveChildFromDependenciesIfNeeded = function (rawParentData, childKey, failedRea
       if rcall("SREM", parentDependenciesChildrenKey, childKey) == 1 then
         local parentFailedChildrenKey = parentKey .. ":failed"
         rcall("HSET", parentFailedChildrenKey, childKey, failedReason)
-        moveParentToWait(parentData['queueKey'], parentKey, parentData['id'], timestamp)
+        moveParentToWaitIfNeeded(parentData['queueKey'], parentKey, parentData['id'], timestamp)
       end
     elseif parentData['idof'] or parentData['rdof'] then
       if rcall("SREM", parentDependenciesChildrenKey, childKey) == 1 then
-        moveParentToWaitIfNeeded(parentData['queueKey'], parentDependenciesChildrenKey,
+        moveParentToWaitIfNoPendingDependencies(parentData['queueKey'], parentDependenciesChildrenKey,
           parentKey, parentData['id'], timestamp)
         if parentData['idof'] then
           local parentFailedChildrenKey = parentKey .. ":failed"

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

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

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

@@ -170,12 +170,19 @@ end
   Function to recursively move from waitingChildren to failed.
 ]]
 -- Includes
+--[[
+  Validate and move parent to a wait status (waiting, delayed or prioritized)
+  if no pending dependencies.
+]]
+-- Includes
 --[[
   Validate and move parent to a wait status (waiting, delayed or prioritized) if needed.
 ]]
+-- Includes
 --[[
-  Validate and move parent to a wait status (wait, prioritized or delayed)
+  Move parent to a wait status (wait, prioritized or delayed)
 ]]
+-- Includes
 --[[
   Add delay marker if needed.
 ]]
@@ -238,46 +245,53 @@ local function isQueuePausedOrMaxed(queueMetaKey, activeKey)
   return false
 end
 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"
-        local parentMetaKey = parentQueueKey .. ":meta"
-        local parentMarkerKey = parentQueueKey .. ":marker"
-        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)
-            addDelayMarkerIfNeeded(parentMarkerKey, parentDelayedKey)
+    local parentWaitKey = parentQueueKey .. ":wait"
+    local parentPausedKey = parentQueueKey .. ":paused"
+    local parentActiveKey = parentQueueKey .. ":active"
+    local parentMetaKey = parentQueueKey .. ":meta"
+    local parentMarkerKey = parentQueueKey .. ":marker"
+    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)
+        addDelayMarkerIfNeeded(parentMarkerKey, parentDelayedKey)
+    else
+        if priority == 0 then
+            local parentTarget, isParentPausedOrMaxed = getTargetQueueList(parentMetaKey, parentActiveKey,
+                parentWaitKey, parentPausedKey)
+            addJobInTargetList(parentTarget, parentMarkerKey, "RPUSH", isParentPausedOrMaxed, parentId)
         else
-            if priority == 0 then
-                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)
-            end
-            rcall("XADD", parentQueueKey .. ":events", "*", "event", "waiting", "jobId", parentId, "prev",
-                "waiting-children")
+            local isPausedOrMaxed = isQueuePausedOrMaxed(parentMetaKey, parentActiveKey)
+            addJobWithPriority(parentMarkerKey, parentQueueKey .. ":prioritized", priority, parentId,
+                parentQueueKey .. ":pc", isPausedOrMaxed)
         end
+        rcall("XADD", parentQueueKey .. ":events", "*", "event", "waiting", "jobId", parentId, "prev",
+            "waiting-children")
     end
 end
-local function moveParentToWaitIfNeeded(parentQueueKey, parentDependenciesKey, parentKey, parentId, timestamp)
-    local doNotHavePendingDependencies = rcall("SCARD", parentDependenciesKey) == 0
-    if doNotHavePendingDependencies then
-        moveParentToWait(parentQueueKey, parentKey, parentId, timestamp)
+local function moveParentToWaitIfNeeded(parentQueueKey, parentKey, parentId, timestamp)
+  if rcall("EXISTS", parentKey) == 1 then
+    local parentWaitingChildrenKey = parentQueueKey .. ":waiting-children"
+    if rcall("ZSCORE", parentWaitingChildrenKey, parentId) then    
+      rcall("ZREM", parentWaitingChildrenKey, parentId)
+      moveParentToWait(parentQueueKey, parentKey, parentId, timestamp)
     end
+  end
+end
+local function moveParentToWaitIfNoPendingDependencies(parentQueueKey, parentDependenciesKey, parentKey,
+  parentId, timestamp)
+  local doNotHavePendingDependencies = rcall("SCARD", parentDependenciesKey) == 0
+  if doNotHavePendingDependencies then
+    moveParentToWaitIfNeeded(parentQueueKey, parentKey, parentId, timestamp)
+  end
 end
 --[[
   Function to remove deduplication key if needed.
@@ -468,38 +482,27 @@ moveParentToFailedIfNeeded = function (parentQueueKey, parentKey, parentId, jobI
     local parentWaitingChildrenKey = parentQueueKey .. ":waiting-children"
     local parentDelayedKey = parentQueueKey .. ":delayed"
     local parentPrioritizedKey = parentQueueKey .. ":prioritized"
-    local parentWaitingChildrenOrDelayedOrPrioritizedKey
+    local parentWaitingChildrenOrDelayedKey
     local prevState
     if rcall("ZSCORE", parentWaitingChildrenKey, parentId) then
-      parentWaitingChildrenOrDelayedOrPrioritizedKey = parentWaitingChildrenKey
+      parentWaitingChildrenOrDelayedKey = parentWaitingChildrenKey
       prevState = "waiting-children"
     elseif rcall("ZSCORE", parentDelayedKey, parentId) then
-      parentWaitingChildrenOrDelayedOrPrioritizedKey = parentDelayedKey
+      parentWaitingChildrenOrDelayedKey = parentDelayedKey
       prevState = "delayed"
-    elseif rcall("ZSCORE", parentPrioritizedKey, parentId) then
-      parentWaitingChildrenOrDelayedOrPrioritizedKey = parentPrioritizedKey
-      prevState = "prioritized"
+      rcall("HSET", parentKey, "delay", 0)
     end
-    if parentWaitingChildrenOrDelayedOrPrioritizedKey then
-      rcall("ZREM", parentWaitingChildrenOrDelayedOrPrioritizedKey, parentId)
+    if parentWaitingChildrenOrDelayedKey then
+      rcall("ZREM", parentWaitingChildrenOrDelayedKey, parentId)
       local parentQueuePrefix = parentQueueKey .. ":"
       local parentFailedKey = parentQueueKey .. ":failed"
-      rcall("ZADD", parentFailedKey, timestamp, parentId)
-      local failedReason = "child " .. jobIdKey .. " failed"
-      rcall("HSET", parentKey, "failedReason", failedReason, "finishedOn", timestamp)
-      rcall("XADD", parentQueueKey .. ":events", "*", "event", "failed", "jobId", parentId, "failedReason",
-        failedReason, "prev", prevState)
-      local jobAttributes = rcall("HMGET", parentKey, "parent", "deid", "opts")
-      removeDeduplicationKeyIfNeeded(parentQueueKey .. ":", jobAttributes[2])
-      moveChildFromDependenciesIfNeeded(jobAttributes[1], parentKey, failedReason, timestamp)
-      local parentRawOpts = jobAttributes[3]
-      local parentOpts = cjson.decode(parentRawOpts)
-      removeJobsOnFail(parentQueuePrefix, parentFailedKey, parentId, parentOpts, timestamp)
+      local deferredFailure = "child " .. jobIdKey .. " failed"
+      rcall("HSET", parentKey, "defa", deferredFailure)
+      moveParentToWait(parentQueueKey, parentKey, parentId, timestamp)
     else
-      local grandParentKey = rcall("HGET", parentKey, "parentKey")
-      if grandParentKey then
-        local grandParentUnsuccesssfulSet = grandParentKey .. ":unsuccessful"
-        rcall("ZADD", grandParentUnsuccesssfulSet, timestamp, parentKey)
+      if not rcall("ZSCORE", parentQueueKey .. ":failed", parentId) then
+        local deferredFailure = "child " .. jobIdKey .. " failed"
+        rcall("HSET", parentKey, "defa", deferredFailure)
       end
     end
   end
@@ -525,11 +528,11 @@ moveChildFromDependenciesIfNeeded = function (rawParentData, childKey, failedRea
       if rcall("SREM", parentDependenciesChildrenKey, childKey) == 1 then
         local parentFailedChildrenKey = parentKey .. ":failed"
         rcall("HSET", parentFailedChildrenKey, childKey, failedReason)
-        moveParentToWait(parentData['queueKey'], parentKey, parentData['id'], timestamp)
+        moveParentToWaitIfNeeded(parentData['queueKey'], parentKey, parentData['id'], timestamp)
       end
     elseif parentData['idof'] or parentData['rdof'] then
       if rcall("SREM", parentDependenciesChildrenKey, childKey) == 1 then
-        moveParentToWaitIfNeeded(parentData['queueKey'], parentDependenciesChildrenKey,
+        moveParentToWaitIfNoPendingDependencies(parentData['queueKey'], parentDependenciesChildrenKey,
           parentKey, parentData['id'], timestamp)
         if parentData['idof'] then
           local parentFailedChildrenKey = parentKey .. ":failed"
@@ -658,7 +661,7 @@ local function updateParentDepsIfNeeded(parentKey, parentQueueKey, parentDepende
   parentId, jobIdKey, returnvalue, timestamp )
   local processedSet = parentKey .. ":processed"
   rcall("HSET", processedSet, jobIdKey, returnvalue)
-  moveParentToWaitIfNeeded(parentQueueKey, parentDependenciesKey, parentKey, parentId, timestamp)
+  moveParentToWaitIfNoPendingDependencies(parentQueueKey, parentDependenciesKey, parentKey, parentId, timestamp)
 end
 --[[
   Function to update a bunch of fields in a job.
@@ -739,8 +742,11 @@ if rcall("EXISTS", jobIdKey) == 1 then -- Make sure job exists
         local targetSet = KEYS[11]
         -- Add to complete/failed set
         rcall("ZADD", targetSet, timestamp, jobId)
-        rcall("HMSET", jobIdKey, ARGV[3], ARGV[4], "finishedOn", timestamp)
+        rcall("HSET", jobIdKey, ARGV[3], ARGV[4], "finishedOn", timestamp)
         -- "returnvalue" / "failedReason" and "finishedOn"
+        if ARGV[5] == "failed" then
+            rcall("HDEL", jobIdKey, "defa")
+        end
         -- Remove old jobs?
         if maxAge ~= nil then
             removeJobsByMaxAge(timestamp, maxAge, targetSet, prefix)

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8zBf,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAo0Bf,CAAC;AACW,QAAA,cAAc,GAAG;IAC5B,IAAI,EAAE,gBAAgB;IACtB,OAAO;IACP,IAAI,EAAE,EAAE;CACT,CAAC"}

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

@@ -39,12 +39,19 @@ local jobId = ARGV[4]
   Function to recursively move from waitingChildren to failed.
 ]]
 -- Includes
+--[[
+  Validate and move parent to a wait status (waiting, delayed or prioritized)
+  if no pending dependencies.
+]]
+-- Includes
 --[[
   Validate and move parent to a wait status (waiting, delayed or prioritized) if needed.
 ]]
+-- Includes
 --[[
-  Validate and move parent to a wait status (wait, prioritized or delayed)
+  Move parent to a wait status (wait, prioritized or delayed)
 ]]
+-- Includes
 --[[
   Add delay marker if needed.
 ]]
@@ -139,46 +146,53 @@ local function getTargetQueueList(queueMetaKey, activeKey, waitKey, pausedKey)
   return waitKey, false
 end
 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"
-        local parentMetaKey = parentQueueKey .. ":meta"
-        local parentMarkerKey = parentQueueKey .. ":marker"
-        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)
-            addDelayMarkerIfNeeded(parentMarkerKey, parentDelayedKey)
+    local parentWaitKey = parentQueueKey .. ":wait"
+    local parentPausedKey = parentQueueKey .. ":paused"
+    local parentActiveKey = parentQueueKey .. ":active"
+    local parentMetaKey = parentQueueKey .. ":meta"
+    local parentMarkerKey = parentQueueKey .. ":marker"
+    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)
+        addDelayMarkerIfNeeded(parentMarkerKey, parentDelayedKey)
+    else
+        if priority == 0 then
+            local parentTarget, isParentPausedOrMaxed = getTargetQueueList(parentMetaKey, parentActiveKey,
+                parentWaitKey, parentPausedKey)
+            addJobInTargetList(parentTarget, parentMarkerKey, "RPUSH", isParentPausedOrMaxed, parentId)
         else
-            if priority == 0 then
-                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)
-            end
-            rcall("XADD", parentQueueKey .. ":events", "*", "event", "waiting", "jobId", parentId, "prev",
-                "waiting-children")
+            local isPausedOrMaxed = isQueuePausedOrMaxed(parentMetaKey, parentActiveKey)
+            addJobWithPriority(parentMarkerKey, parentQueueKey .. ":prioritized", priority, parentId,
+                parentQueueKey .. ":pc", isPausedOrMaxed)
         end
+        rcall("XADD", parentQueueKey .. ":events", "*", "event", "waiting", "jobId", parentId, "prev",
+            "waiting-children")
     end
 end
-local function moveParentToWaitIfNeeded(parentQueueKey, parentDependenciesKey, parentKey, parentId, timestamp)
-    local doNotHavePendingDependencies = rcall("SCARD", parentDependenciesKey) == 0
-    if doNotHavePendingDependencies then
-        moveParentToWait(parentQueueKey, parentKey, parentId, timestamp)
+local function moveParentToWaitIfNeeded(parentQueueKey, parentKey, parentId, timestamp)
+  if rcall("EXISTS", parentKey) == 1 then
+    local parentWaitingChildrenKey = parentQueueKey .. ":waiting-children"
+    if rcall("ZSCORE", parentWaitingChildrenKey, parentId) then    
+      rcall("ZREM", parentWaitingChildrenKey, parentId)
+      moveParentToWait(parentQueueKey, parentKey, parentId, timestamp)
     end
+  end
+end
+local function moveParentToWaitIfNoPendingDependencies(parentQueueKey, parentDependenciesKey, parentKey,
+  parentId, timestamp)
+  local doNotHavePendingDependencies = rcall("SCARD", parentDependenciesKey) == 0
+  if doNotHavePendingDependencies then
+    moveParentToWaitIfNeeded(parentQueueKey, parentKey, parentId, timestamp)
+  end
 end
 --[[
   Function to remove deduplication key if needed.
@@ -369,38 +383,27 @@ moveParentToFailedIfNeeded = function (parentQueueKey, parentKey, parentId, jobI
     local parentWaitingChildrenKey = parentQueueKey .. ":waiting-children"
     local parentDelayedKey = parentQueueKey .. ":delayed"
     local parentPrioritizedKey = parentQueueKey .. ":prioritized"
-    local parentWaitingChildrenOrDelayedOrPrioritizedKey
+    local parentWaitingChildrenOrDelayedKey
     local prevState
     if rcall("ZSCORE", parentWaitingChildrenKey, parentId) then
-      parentWaitingChildrenOrDelayedOrPrioritizedKey = parentWaitingChildrenKey
+      parentWaitingChildrenOrDelayedKey = parentWaitingChildrenKey
       prevState = "waiting-children"
     elseif rcall("ZSCORE", parentDelayedKey, parentId) then
-      parentWaitingChildrenOrDelayedOrPrioritizedKey = parentDelayedKey
+      parentWaitingChildrenOrDelayedKey = parentDelayedKey
       prevState = "delayed"
-    elseif rcall("ZSCORE", parentPrioritizedKey, parentId) then
-      parentWaitingChildrenOrDelayedOrPrioritizedKey = parentPrioritizedKey
-      prevState = "prioritized"
+      rcall("HSET", parentKey, "delay", 0)
     end
-    if parentWaitingChildrenOrDelayedOrPrioritizedKey then
-      rcall("ZREM", parentWaitingChildrenOrDelayedOrPrioritizedKey, parentId)
+    if parentWaitingChildrenOrDelayedKey then
+      rcall("ZREM", parentWaitingChildrenOrDelayedKey, parentId)
       local parentQueuePrefix = parentQueueKey .. ":"
       local parentFailedKey = parentQueueKey .. ":failed"
-      rcall("ZADD", parentFailedKey, timestamp, parentId)
-      local failedReason = "child " .. jobIdKey .. " failed"
-      rcall("HSET", parentKey, "failedReason", failedReason, "finishedOn", timestamp)
-      rcall("XADD", parentQueueKey .. ":events", "*", "event", "failed", "jobId", parentId, "failedReason",
-        failedReason, "prev", prevState)
-      local jobAttributes = rcall("HMGET", parentKey, "parent", "deid", "opts")
-      removeDeduplicationKeyIfNeeded(parentQueueKey .. ":", jobAttributes[2])
-      moveChildFromDependenciesIfNeeded(jobAttributes[1], parentKey, failedReason, timestamp)
-      local parentRawOpts = jobAttributes[3]
-      local parentOpts = cjson.decode(parentRawOpts)
-      removeJobsOnFail(parentQueuePrefix, parentFailedKey, parentId, parentOpts, timestamp)
+      local deferredFailure = "child " .. jobIdKey .. " failed"
+      rcall("HSET", parentKey, "defa", deferredFailure)
+      moveParentToWait(parentQueueKey, parentKey, parentId, timestamp)
     else
-      local grandParentKey = rcall("HGET", parentKey, "parentKey")
-      if grandParentKey then
-        local grandParentUnsuccesssfulSet = grandParentKey .. ":unsuccessful"
-        rcall("ZADD", grandParentUnsuccesssfulSet, timestamp, parentKey)
+      if not rcall("ZSCORE", parentQueueKey .. ":failed", parentId) then
+        local deferredFailure = "child " .. jobIdKey .. " failed"
+        rcall("HSET", parentKey, "defa", deferredFailure)
       end
     end
   end
@@ -426,11 +429,11 @@ moveChildFromDependenciesIfNeeded = function (rawParentData, childKey, failedRea
       if rcall("SREM", parentDependenciesChildrenKey, childKey) == 1 then
         local parentFailedChildrenKey = parentKey .. ":failed"
         rcall("HSET", parentFailedChildrenKey, childKey, failedReason)
-        moveParentToWait(parentData['queueKey'], parentKey, parentData['id'], timestamp)
+        moveParentToWaitIfNeeded(parentData['queueKey'], parentKey, parentData['id'], timestamp)
       end
     elseif parentData['idof'] or parentData['rdof'] then
       if rcall("SREM", parentDependenciesChildrenKey, childKey) == 1 then
-        moveParentToWaitIfNeeded(parentData['queueKey'], parentDependenciesChildrenKey,
+        moveParentToWaitIfNoPendingDependencies(parentData['queueKey'], parentDependenciesChildrenKey,
           parentKey, parentData['id'], timestamp)
         if parentData['idof'] then
           local parentFailedChildrenKey = parentKey .. ":failed"

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2ff,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8ff,CAAC;AACW,QAAA,qBAAqB,GAAG;IACnC,IAAI,EAAE,uBAAuB;IAC7B,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}