bullmq 5.49.1 → 5.50.0

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

@@ -32,13 +32,18 @@ local prefixKey = ARGV[5]
 ]]
 -- Includes
 --[[
-  Function to remove deduplication key.
+  Function to remove deduplication key if needed
+  when a job is being removed.
 ]]
-local function removeDeduplicationKey(prefixKey, jobKey)
+local function removeDeduplicationKeyIfNeededOnRemoval(prefixKey,
+  jobKey, jobId)
   local deduplicationId = rcall("HGET", jobKey, "deid")
   if deduplicationId then
     local deduplicationKey = prefixKey .. "de:" .. deduplicationId
-    rcall("DEL", deduplicationKey)
+    local currentJobId = rcall('GET', deduplicationKey)
+    if currentJobId and currentJobId == jobId then
+      return rcall("DEL", deduplicationKey)
+    end
   end
 end
 --[[
@@ -176,7 +181,7 @@ local function removeJob(jobId, hard, baseKey, shouldRemoveDeduplicationKey)
   local jobKey = baseKey .. jobId
   removeParentDependencyKey(jobKey, hard, nil, baseKey)
   if shouldRemoveDeduplicationKey then
-    removeDeduplicationKey(baseKey, jobKey)
+    removeDeduplicationKeyIfNeededOnRemoval(baseKey, jobKey, jobId)
   end
   removeJobKeys(jobKey)
 end

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

@@ -1 +1 @@
-{"version":3,"file":"addRepeatableJob-2.js","sourceRoot":"","sources":["../../../src/scripts/addRepeatableJob-2.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4Nf,CAAC;AACW,QAAA,gBAAgB,GAAG;IAC9B,IAAI,EAAE,kBAAkB;IACxB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}
+{"version":3,"file":"addRepeatableJob-2.js","sourceRoot":"","sources":["../../../src/scripts/addRepeatableJob-2.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiOf,CAAC;AACW,QAAA,gBAAgB,GAAG;IAC9B,IAAI,EAAE,kBAAkB;IACxB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

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

@@ -139,12 +139,19 @@ end
   Validate and move or add dependencies to parent.
 ]]
 -- 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.
 ]]
@@ -203,52 +210,59 @@ 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
 local function updateParentDepsIfNeeded(parentKey, parentQueueKey, parentDependenciesKey,
   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
 local function updateExistingJobsParent(parentKey, parent, parentData,
                                         parentDependenciesKey, completedKey,

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

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

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

@@ -68,13 +68,18 @@ end
 ]]
 -- Includes
 --[[
-  Function to remove deduplication key.
+  Function to remove deduplication key if needed
+  when a job is being removed.
 ]]
-local function removeDeduplicationKey(prefixKey, jobKey)
+local function removeDeduplicationKeyIfNeededOnRemoval(prefixKey,
+  jobKey, jobId)
   local deduplicationId = rcall("HGET", jobKey, "deid")
   if deduplicationId then
     local deduplicationKey = prefixKey .. "de:" .. deduplicationId
-    rcall("DEL", deduplicationKey)
+    local currentJobId = rcall('GET', deduplicationKey)
+    if currentJobId and currentJobId == jobId then
+      return rcall("DEL", deduplicationKey)
+    end
   end
 end
 --[[
@@ -212,7 +217,7 @@ local function removeJob(jobId, hard, baseKey, shouldRemoveDeduplicationKey)
   local jobKey = baseKey .. jobId
   removeParentDependencyKey(jobKey, hard, nil, baseKey)
   if shouldRemoveDeduplicationKey then
-    removeDeduplicationKey(baseKey, jobKey)
+    removeDeduplicationKeyIfNeededOnRemoval(baseKey, jobKey, jobId)
   end
   removeJobKeys(jobKey)
 end

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

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

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

@@ -40,13 +40,18 @@ end
 ]]
 -- Includes
 --[[
-  Function to remove deduplication key.
+  Function to remove deduplication key if needed
+  when a job is being removed.
 ]]
-local function removeDeduplicationKey(prefixKey, jobKey)
+local function removeDeduplicationKeyIfNeededOnRemoval(prefixKey,
+  jobKey, jobId)
   local deduplicationId = rcall("HGET", jobKey, "deid")
   if deduplicationId then
     local deduplicationKey = prefixKey .. "de:" .. deduplicationId
-    rcall("DEL", deduplicationKey)
+    local currentJobId = rcall('GET', deduplicationKey)
+    if currentJobId and currentJobId == jobId then
+      return rcall("DEL", deduplicationKey)
+    end
   end
 end
 --[[
@@ -184,7 +189,7 @@ local function removeJob(jobId, hard, baseKey, shouldRemoveDeduplicationKey)
   local jobKey = baseKey .. jobId
   removeParentDependencyKey(jobKey, hard, nil, baseKey)
   if shouldRemoveDeduplicationKey then
-    removeDeduplicationKey(baseKey, jobKey)
+    removeDeduplicationKeyIfNeededOnRemoval(baseKey, jobKey, jobId)
   end
   removeJobKeys(jobKey)
 end

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

@@ -1 +1 @@
-{"version":3,"file":"drain-5.js","sourceRoot":"","sources":["../../../src/scripts/drain-5.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiQf,CAAC;AACW,QAAA,KAAK,GAAG;IACnB,IAAI,EAAE,OAAO;IACb,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}
+{"version":3,"file":"drain-5.js","sourceRoot":"","sources":["../../../src/scripts/drain-5.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsQf,CAAC;AACW,QAAA,KAAK,GAAG;IACnB,IAAI,EAAE,OAAO;IACb,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

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,57 +149,52 @@ 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
---[[
-  Function to remove deduplication key if needed.
-]]
-local function removeDeduplicationKeyIfNeeded(prefixKey, deduplicationId)
-  if deduplicationId then
-    local deduplicationKey = prefixKey .. "de:" .. deduplicationId
-    local pttl = rcall("PTTL", deduplicationKey)
-    if pttl == 0 or pttl == -1 then
-      rcall("DEL", deduplicationKey)
-    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
 --[[
@@ -204,13 +206,18 @@ end
 ]]
 -- Includes
 --[[
-  Function to remove deduplication key.
+  Function to remove deduplication key if needed
+  when a job is being removed.
 ]]
-local function removeDeduplicationKey(prefixKey, jobKey)
+local function removeDeduplicationKeyIfNeededOnRemoval(prefixKey,
+  jobKey, jobId)
   local deduplicationId = rcall("HGET", jobKey, "deid")
   if deduplicationId then
     local deduplicationKey = prefixKey .. "de:" .. deduplicationId
-    rcall("DEL", deduplicationKey)
+    local currentJobId = rcall('GET', deduplicationKey)
+    if currentJobId and currentJobId == jobId then
+      return rcall("DEL", deduplicationKey)
+    end
   end
 end
 --[[
@@ -312,7 +319,7 @@ local function removeJob(jobId, hard, baseKey, shouldRemoveDeduplicationKey)
   local jobKey = baseKey .. jobId
   removeParentDependencyKey(jobKey, hard, nil, baseKey)
   if shouldRemoveDeduplicationKey then
-    removeDeduplicationKey(baseKey, jobKey)
+    removeDeduplicationKeyIfNeededOnRemoval(baseKey, jobKey, jobId)
   end
   removeJobKeys(jobKey)
 end
@@ -372,38 +379,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 +425,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"
@@ -443,6 +439,26 @@ moveChildFromDependenciesIfNeeded = function (rawParentData, childKey, failedRea
     end
   end
 end
+--[[
+  Function to remove deduplication key if needed
+  when a job is moved to completed or failed states.
+]]
+local function removeDeduplicationKeyIfNeededOnFinalization(prefixKey,
+  deduplicationId, jobId)
+  if deduplicationId then
+    local deduplicationKey = prefixKey .. "de:" .. deduplicationId
+    local pttl = rcall("PTTL", deduplicationKey)
+    if pttl == 0 then
+      return rcall("DEL", deduplicationKey)
+    end
+    if pttl == -1 then
+      local currentJobId = rcall('GET', deduplicationKey)
+      if currentJobId and currentJobId == jobId then
+        return rcall("DEL", deduplicationKey)
+      end
+    end
+  end
+end
 --[[
   Function to trim events, default 10000.
 ]]
@@ -512,7 +528,7 @@ if (#stalling > 0) then
                         local rawParentData = jobAttributes[2]
                         local opts = cjson.decode(rawOpts)
                         rcall("ZADD", failedKey, timestamp, jobId)
-                        removeDeduplicationKeyIfNeeded(queueKeyPrefix, jobAttributes[3])
+                        removeDeduplicationKeyIfNeededOnFinalization(queueKeyPrefix, jobAttributes[3], jobId)
                         local failedReason = "job stalled more than allowable limit"
                         rcall("HMSET", jobKey, "failedReason", failedReason, "finishedOn", timestamp)
                         rcall("XADD", eventStreamKey, "*", "event", "failed", "jobId", jobId, 'prev', 'active',

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