bullmq 5.44.1 → 5.52.0

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

@@ -36,13 +36,12 @@ local timestamp = ARGV[3]
 local jobId = ARGV[4]
 
 --- Includes
---- @include "includes/moveParentFromWaitingChildrenToFailed"
---- @include "includes/moveParentToWaitIfNeeded"
---- @include "includes/removeDeduplicationKeyIfNeeded"
+--- @include "includes/moveChildFromDependenciesIfNeeded"
+--- @include "includes/removeDeduplicationKeyIfNeededOnFinalization"
 --- @include "includes/removeJobsOnFail"
 --- @include "includes/removeLock"
 
-local function moveToWaitingChildren (activeKey, waitingChildrenKey, jobId,
+local function moveToWaitingChildren(activeKey, waitingChildrenKey, jobId,
     timestamp)
   local score = tonumber(timestamp)
 
@@ -62,7 +61,7 @@ if rcall("EXISTS", jobKey) == 1 then
     -- TODO: refactor this logic in an include later
     local jobAttributes = rcall("HMGET", jobKey, "parent", "deid", "opts")
 
-    removeDeduplicationKeyIfNeeded(ARGV[5], jobAttributes[2])
+    removeDeduplicationKeyIfNeededOnFinalization(ARGV[5], jobAttributes[2], jobId)
   
     local failedReason = "children are failed"
     rcall("ZADD", failedKey, timestamp, jobId)
@@ -74,33 +73,7 @@ if rcall("EXISTS", jobKey) == 1 then
     local rawOpts = jobAttributes[3]
     local opts = cjson.decode(rawOpts)
 
-    if rawParentData ~= false then
-      if opts['fpof'] then
-        local parentData = cjson.decode(rawParentData)
-        local parentKey = parentData['queueKey'] .. ':' .. parentData['id']
-        local parentUnsuccesssful = parentKey .. ":unsuccessful"
-        rcall("ZADD", parentUnsuccesssful, timestamp, jobKey)                        
-        moveParentFromWaitingChildrenToFailed(
-            parentData['queueKey'],
-            parentData['queueKey'] .. ':' .. parentData['id'],
-            parentData['id'],
-            jobKey,
-            timestamp
-        )
-      elseif opts['idof'] or opts['rdof'] then
-        local parentData = cjson.decode(rawParentData)
-        local parentKey = parentData['queueKey'] .. ':' .. parentData['id']
-        local dependenciesSet = parentKey .. ":dependencies"
-        if rcall("SREM", dependenciesSet, jobKey) == 1 then
-          moveParentToWaitIfNeeded(parentData['queueKey'], dependenciesSet,
-                                    parentKey, parentData['id'], timestamp)
-          if opts['idof'] then
-            local failedSet = parentKey .. ":failed"
-            rcall("HSET", failedSet, jobKey, failedReason)
-          end
-        end
-      end
-    end
+    moveChildFromDependenciesIfNeeded(rawParentData, jobKey, failedReason, timestamp)
 
     removeJobsOnFail(ARGV[5], failedKey, jobId, opts, timestamp)
 

package/dist/cjs/commands/removeJob-3.lua

@@ -1,14 +1,15 @@
 --[[
-    Remove a job from all the queues it may be in as well as all its data.
+    Remove a job from all the statuses it may be in as well as all its data.
     In order to be able to remove a job, it cannot be active.
 
     Input:
-      KEYS[1] queue prefix
+      KEYS[1] jobKey
       KEYS[2] meta key
       KEYS[3] repeat key
 
       ARGV[1] jobId
       ARGV[2] remove children
+      ARGV[3] queue prefix
 
     Events:
       'removed'
@@ -17,80 +18,15 @@
 local rcall = redis.call
 
 -- Includes
---- @include "includes/destructureJobKey"
---- @include "includes/getOrSetMaxEvents"
 --- @include "includes/isJobSchedulerJob"
 --- @include "includes/isLocked"
---- @include "includes/removeDeduplicationKey"
---- @include "includes/removeJobFromAnyState"
---- @include "includes/removeJobKeys"
---- @include "includes/removeParentDependencyKey"
+--- @include "includes/removeJobWithChildren"
 
-local function removeJob(prefix, jobId, parentKey, removeChildren)
-    local jobKey = prefix .. jobId;
-
-    removeParentDependencyKey(jobKey, false, parentKey, nil)
-
-    if removeChildren == "1" then
-        -- Check if this job has children
-        -- If so, we are going to try to remove the children recursively in deep first way because
-        -- if some job is locked we must exit with and error.
-        -- local countProcessed = rcall("HLEN", jobKey .. ":processed")
-        local processed = rcall("HGETALL", jobKey .. ":processed")
-
-        if (#processed > 0) then
-            for i = 1, #processed, 2 do
-                local childJobId = getJobIdFromKey(processed[i])
-                local childJobPrefix = getJobKeyPrefix(processed[i], childJobId)
-                removeJob(childJobPrefix, childJobId, jobKey, removeChildren)
-            end
-        end
-
-        local dependencies = rcall("SMEMBERS", jobKey .. ":dependencies")
-        if (#dependencies > 0) then
-            for i, childJobKey in ipairs(dependencies) do
-                -- We need to get the jobId for this job.
-                local childJobId = getJobIdFromKey(childJobKey)
-                local childJobPrefix = getJobKeyPrefix(childJobKey, childJobId)
-                removeJob(childJobPrefix, childJobId, jobKey, removeChildren)
-            end
-        end
-
-        local failed = rcall("HGETALL", jobKey .. ":failed")
-
-        if (#failed > 0) then
-            for i = 1, #failed, 2 do
-                local childJobId = getJobIdFromKey(failed[i])
-                local childJobPrefix = getJobKeyPrefix(failed[i], childJobId)
-                removeJob(childJobPrefix, childJobId, jobKey, removeChildren)
-            end
-        end
-
-        local unsuccessful = rcall("ZRANGE", jobKey .. ":unsuccessful", 0, -1)
-
-        if (#unsuccessful > 0) then
-            for i = 1, #unsuccessful, 1 do
-                local childJobId = getJobIdFromKey(unsuccessful[i])
-                local childJobPrefix = getJobKeyPrefix(unsuccessful[i], childJobId)
-                removeJob(childJobPrefix, childJobId, jobKey, removeChildren)
-            end
-        end
-    end
-
-    local prev = removeJobFromAnyState(prefix, jobId)
-
-    removeDeduplicationKey(prefix, jobKey)
-    if removeJobKeys(jobKey) > 0 then
-        local maxEvents = getOrSetMaxEvents(KEYS[2])
-        rcall("XADD", prefix .. "events", "MAXLEN", "~", maxEvents, "*", "event", "removed", "jobId", jobId, "prev",
-            prev)
-    end
-end
-
-local prefix = KEYS[1]
 local jobId = ARGV[1]
 local shouldRemoveChildren = ARGV[2]
-local jobKey = prefix .. jobId
+local prefix = ARGV[3]
+local jobKey = KEYS[1]
+local meta = KEYS[2]
 local repeatKey = KEYS[3]
 
 if isJobSchedulerJob(jobId, jobKey, repeatKey) then
@@ -98,7 +34,13 @@ if isJobSchedulerJob(jobId, jobKey, repeatKey) then
 end
 
 if not isLocked(prefix, jobId, shouldRemoveChildren) then
-    removeJob(prefix, jobId, nil, shouldRemoveChildren)
+    local options = {
+        removeChildren = shouldRemoveChildren == "1",
+        ignoreProcessed = false,
+        ignoreLocked = false
+    }
+
+    removeJobWithChildren(prefix, meta, jobId, nil, options)
     return 1
 end
 return 0

package/dist/cjs/commands/removeUnprocessedChildren-2.lua

@@ -0,0 +1,31 @@
+--[[
+    Remove a job from all the statuses it may be in as well as all its data.
+    In order to be able to remove a job, it cannot be active.
+
+    Input:
+      KEYS[1] jobKey
+      KEYS[2] meta key
+      
+      ARGV[1] prefix
+      ARGV[2] jobId
+
+    Events:
+      'removed' for every children removed
+]]
+
+-- Includes
+--- @include "includes/removeJobWithChildren"
+
+local prefix = ARGV[1]
+local jobId = ARGV[2]
+
+local jobKey = KEYS[1]
+local metaKey = KEYS[2]
+
+local options = {
+  removeChildren = "1",
+  ignoreProcessed = true,
+  ignoreLocked = true
+}
+
+removeJobChildren(prefix, metaKey, jobKey, options) 

package/dist/cjs/commands/updateJobScheduler-12.lua

@@ -25,7 +25,8 @@
 
     Output:
       next delayed job id  - OK
-]] local rcall = redis.call
+]]
+local rcall = redis.call
 local repeatKey = KEYS[1]
 local delayedKey = KEYS[2]
 local waitKey = KEYS[3]
@@ -48,37 +49,42 @@ local nextDelayedJobKey = schedulerKey .. ":" .. nextMillis
 
 -- Validate that scheduler exists.
 local prevMillis = rcall("ZSCORE", repeatKey, jobSchedulerId)
-if prevMillis ~= false then
+if prevMillis then
     local currentDelayedJobId = "repeat:" .. jobSchedulerId .. ":" .. prevMillis
 
-    if producerId == currentDelayedJobId and rcall("EXISTS", nextDelayedJobKey) ~= 1 then
-        local schedulerAttributes = rcall("HMGET", schedulerKey, "name", "data")
-
-        rcall("ZADD", repeatKey, nextMillis, jobSchedulerId)
-        rcall("HINCRBY", schedulerKey, "ic", 1)
-
+    if producerId == currentDelayedJobId then
         local eventsKey = KEYS[9]
         local maxEvents = getOrSetMaxEvents(metaKey)
 
-        rcall("INCR", KEYS[8])
+        if rcall("EXISTS", nextDelayedJobKey) ~= 1 then
+            local schedulerAttributes = rcall("HMGET", schedulerKey, "name", "data")
 
-        -- TODO: remove this workaround in next breaking change,
-        -- all job-schedulers must save job data
-        local templateData = schedulerAttributes[2] or ARGV[3]
+            rcall("ZADD", repeatKey, nextMillis, jobSchedulerId)
+            rcall("HINCRBY", schedulerKey, "ic", 1)
 
-        if templateData and templateData ~= '{}' then
-            rcall("HSET", schedulerKey, "data", templateData)
-        end
+            rcall("INCR", KEYS[8])
 
-        addJobFromScheduler(nextDelayedJobKey, nextDelayedJobId, ARGV[4], waitKey, pausedKey, 
-            KEYS[12], metaKey, prioritizedKey, KEYS[10], delayedKey, KEYS[7], eventsKey, 
-            schedulerAttributes[1], maxEvents, ARGV[5], templateData or '{}', jobSchedulerId)
+            -- TODO: remove this workaround in next breaking change,
+            -- all job-schedulers must save job data
+            local templateData = schedulerAttributes[2] or ARGV[3]
 
-        -- TODO: remove this workaround in next breaking change
-        if KEYS[11] ~= "" then
-            rcall("HSET", KEYS[11], "nrjid", nextDelayedJobId)
-        end
+            if templateData and templateData ~= '{}' then
+                rcall("HSET", schedulerKey, "data", templateData)
+            end
 
-        return nextDelayedJobId .. "" -- convert to string
+            addJobFromScheduler(nextDelayedJobKey, nextDelayedJobId, ARGV[4], waitKey, pausedKey, 
+                KEYS[12], metaKey, prioritizedKey, KEYS[10], delayedKey, KEYS[7], eventsKey, 
+                schedulerAttributes[1], maxEvents, ARGV[5], templateData or '{}', jobSchedulerId)
+
+            -- TODO: remove this workaround in next breaking change
+            if KEYS[11] ~= "" then
+                rcall("HSET", KEYS[11], "nrjid", nextDelayedJobId)
+            end
+
+            return nextDelayedJobId .. "" -- convert to string
+        else
+            rcall("XADD", eventsKey, "MAXLEN", "~", maxEvents, "*", "event",
+                "duplicated", "jobId", nextDelayedJobId)
+        end
     end
 end

package/dist/cjs/scripts/addDelayedJob-6.js

@@ -114,25 +114,25 @@ local function addDelayedJob(jobId, delayedKey, eventsKey, timestamp,
 end
 --[[
   Function to debounce a job.
-]]
+]] 
 local function deduplicateJob(deduplicationOpts, jobId, deduplicationKey, eventsKey, maxEvents)
   local deduplicationId = deduplicationOpts and deduplicationOpts['id']
   if deduplicationId then
-    local ttl = deduplicationOpts['ttl']
-    local deduplicationKeyExists
-    if ttl then
-      deduplicationKeyExists = not rcall('SET', deduplicationKey, jobId, 'PX', ttl, 'NX')
-    else
-      deduplicationKeyExists = not rcall('SET', deduplicationKey, jobId, 'NX')
-    end
-    if deduplicationKeyExists then
-      local currentDebounceJobId = rcall('GET', deduplicationKey)
-      rcall("XADD", eventsKey, "MAXLEN", "~", maxEvents, "*", "event",
-        "debounced", "jobId", currentDebounceJobId, "debounceId", deduplicationId)
-      rcall("XADD", eventsKey, "MAXLEN", "~", maxEvents, "*", "event",
-        "deduplicated", "jobId", currentDebounceJobId, "deduplicationId", deduplicationId)
-      return currentDebounceJobId
-    end
+      local ttl = deduplicationOpts['ttl']
+      local deduplicationKeyExists
+      if ttl then
+          deduplicationKeyExists = not rcall('SET', deduplicationKey, jobId, 'PX', ttl, 'NX')
+      else
+          deduplicationKeyExists = not rcall('SET', deduplicationKey, jobId, 'NX')
+      end
+      if deduplicationKeyExists then
+          local currentDebounceJobId = rcall('GET', deduplicationKey)
+          rcall("XADD", eventsKey, "MAXLEN", "~", maxEvents, "*", "event", "debounced", "jobId", currentDebounceJobId,
+              "debounceId", deduplicationId)
+          rcall("XADD", eventsKey, "MAXLEN", "~", maxEvents, "*", "event", "deduplicated", "jobId",
+              currentDebounceJobId, "deduplicationId", deduplicationId, "deduplicatedJobId", jobId)
+          return currentDebounceJobId
+      end
   end
 end
 --[[
@@ -162,7 +162,16 @@ end
 ]]
 -- Includes
 --[[
-  Validate and move parent to active if needed.
+  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
+--[[
+  Move parent to a wait status (wait, prioritized or delayed)
 ]]
 -- Includes
 --[[
@@ -234,51 +243,60 @@ 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 rcall("SCARD", parentDependenciesKey) == 0 and isParentActive then
-        rcall("ZREM", parentQueueKey .. ":waiting-children", parentId)
-        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
-        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 function moveParentToWait(parentQueueKey, parentKey, parentId, timestamp)
+    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, 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,
@@ -330,7 +348,7 @@ local function storeJob(eventsKey, jobIdKey, jobId, name, data, opts, timestamp,
         table.insert(optionalValues, "parent")
         table.insert(optionalValues, parentData)
     end
-    if repeatJobKey ~= nil then
+    if repeatJobKey then
         table.insert(optionalValues, "rjk")
         table.insert(optionalValues, repeatJobKey)
     end

package/dist/cjs/scripts/addDelayedJob-6.js.map

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

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

@@ -39,6 +39,7 @@ local waitKey = KEYS[3]
 local pausedKey = KEYS[4]
 local metaKey = KEYS[5]
 local prioritizedKey = KEYS[6]
+local eventsKey = KEYS[9]
 local nextMillis = ARGV[1]
 local jobSchedulerId = ARGV[3]
 local templateOpts = cmsgpack.unpack(ARGV[5])
@@ -160,7 +161,7 @@ local function storeJob(eventsKey, jobIdKey, jobId, name, data, opts, timestamp,
         table.insert(optionalValues, "parent")
         table.insert(optionalValues, parentData)
     end
-    if repeatJobKey ~= nil then
+    if repeatJobKey then
         table.insert(optionalValues, "rjk")
         table.insert(optionalValues, repeatJobKey)
     end
@@ -240,13 +241,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
 --[[
@@ -272,7 +278,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)
@@ -300,10 +306,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
@@ -331,10 +337,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
@@ -348,7 +354,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
@@ -395,43 +401,56 @@ end
 local schedulerKey = repeatKey .. ":" .. jobSchedulerId
 local nextDelayedJobKey = schedulerKey .. ":" .. nextMillis
 local nextDelayedJobId = "repeat:" .. jobSchedulerId .. ":" .. nextMillis
+local maxEvents = getOrSetMaxEvents(metaKey)
+local function removeJobFromScheduler(prefixKey, delayedKey, prioritizedKey, waitKey, pausedKey, jobId,
+    metaKey, eventsKey)
+    if rcall("ZSCORE", delayedKey, jobId) then
+        removeJob(nextDelayedJobId, true, prefixKey, true --[[remove debounce key]] )
+        rcall("ZREM", delayedKey, jobId)
+        return true
+    elseif rcall("ZSCORE", prioritizedKey, jobId) then
+        removeJob(jobId, true, prefixKey, true --[[remove debounce key]] )
+        rcall("ZREM", prioritizedKey, jobId)
+        return true
+    else
+        local pausedOrWaitKey = waitKey
+        if isQueuePaused(metaKey) then
+            pausedOrWaitKey = pausedKey
+        end
+        if rcall("LREM", pausedOrWaitKey, 1, jobId) > 0 then
+            removeJob(jobId, true, prefixKey, true --[[remove debounce key]] )
+            return true
+        end
+    end
+    return false
+end
+if rcall("EXISTS", nextDelayedJobKey) == 1 then
+    if not removeJobFromScheduler(prefixKey, delayedKey, prioritizedKey, waitKey, pausedKey,
+        nextDelayedJobId, metaKey, eventsKey) then
+        rcall("XADD", eventsKey, "MAXLEN", "~", maxEvents, "*", "event",
+            "duplicated", "jobId", nextDelayedJobId)
+        return nextDelayedJobId .. "" -- convert to string
+    end
+end
 local prevMillis = rcall("ZSCORE", repeatKey, jobSchedulerId)
-if prevMillis ~= false then
+if prevMillis then    
     local currentJobId = "repeat:" .. jobSchedulerId .. ":" .. prevMillis
-    if rcall("EXISTS", nextDelayedJobKey) ~= 1 or currentJobId == nextDelayedJobId then
-        if rcall("ZSCORE", delayedKey, currentJobId) ~= false then
-            removeJob(currentJobId, true, prefixKey, true --[[remove debounce key]] )
-            rcall("ZREM", delayedKey, currentJobId)
-        elseif rcall("ZSCORE", prioritizedKey, currentJobId) ~= false then
-            removeJob(currentJobId, true, prefixKey, true --[[remove debounce key]] )
-            rcall("ZREM", prioritizedKey, currentJobId)
-        else
-            if isQueuePaused(metaKey) then
-                if rcall("LREM", pausedKey, 1, currentJobId) > 0 then
-                    removeJob(currentJobId, true, prefixKey, true --[[remove debounce key]] )
-                end
-            else
-                if rcall("LREM", waitKey, 1, currentJobId) > 0 then
-                    removeJob(currentJobId, true, prefixKey, true --[[remove debounce key]] )
-                end
-            end
-        end
+    local currentDelayedJobKey = schedulerKey .. ":" .. prevMillis
+    if currentJobId ~= nextDelayedJobId and rcall("EXISTS", currentDelayedJobKey) == 1 then
+        removeJobFromScheduler(prefixKey, delayedKey, prioritizedKey, waitKey, pausedKey,
+            currentJobId, metaKey, eventsKey)
     end
 end
 local schedulerOpts = cmsgpack.unpack(ARGV[2])
 storeJobScheduler(jobSchedulerId, schedulerKey, repeatKey, nextMillis, schedulerOpts, ARGV[4], templateOpts)
-if rcall("EXISTS", nextDelayedJobKey) ~= 1 then
-    local eventsKey = KEYS[9]
-    local maxEvents = getOrSetMaxEvents(metaKey)
-    rcall("INCR", KEYS[8])
-    addJobFromScheduler(nextDelayedJobKey, nextDelayedJobId, ARGV[6], waitKey, pausedKey,
-        KEYS[11], metaKey, prioritizedKey, KEYS[10], delayedKey, KEYS[7], eventsKey,
-        schedulerOpts['name'], maxEvents, ARGV[7], ARGV[4], jobSchedulerId)
-    if ARGV[9] ~= "" then
-        rcall("HSET", ARGV[9], "nrjid", nextDelayedJobId)
-    end
-    return nextDelayedJobId .. "" -- convert to string
+rcall("INCR", KEYS[8])
+addJobFromScheduler(nextDelayedJobKey, nextDelayedJobId, ARGV[6], waitKey, pausedKey,
+    KEYS[11], metaKey, prioritizedKey, KEYS[10], delayedKey, KEYS[7], eventsKey,
+    schedulerOpts['name'], maxEvents, ARGV[7], ARGV[4], jobSchedulerId)
+if ARGV[9] ~= "" then
+    rcall("HSET", ARGV[9], "nrjid", nextDelayedJobId)
 end
+return nextDelayedJobId .. "" -- convert to string
 `;
 exports.addJobScheduler = {
     name: 'addJobScheduler',

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

@@ -1 +1 @@
-{"version":3,"file":"addJobScheduler-11.js","sourceRoot":"","sources":["../../../src/scripts/addJobScheduler-11.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+af,CAAC;AACW,QAAA,eAAe,GAAG;IAC7B,IAAI,EAAE,iBAAiB;IACvB,OAAO;IACP,IAAI,EAAE,EAAE;CACT,CAAC"}
+{"version":3,"file":"addJobScheduler-11.js","sourceRoot":"","sources":["../../../src/scripts/addJobScheduler-11.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkcf,CAAC;AACW,QAAA,eAAe,GAAG;IAC7B,IAAI,EAAE,iBAAiB;IACvB,OAAO;IACP,IAAI,EAAE,EAAE;CACT,CAAC"}