bullmq 5.10.3 → 5.11.0

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

@@ -34,6 +34,7 @@ const content = `--[[
             [7]  parent dependencies key.
             [8]  parent? {id, queueKey}
             [9]  repeat job key
+            [10] debounce key
       ARGV[2] Json stringified job data
       ARGV[3] msgpacked options
       Output:
@@ -48,8 +49,9 @@ local args = cmsgpack.unpack(ARGV[1])
 local data = ARGV[2]
 local opts = cmsgpack.unpack(ARGV[3])
 local parentKey = args[5]
-local repeatJobKey = args[9]
 local parent = args[8]
+local repeatJobKey = args[9]
+local debounceKey = args[10]
 local parentData
 -- Includes
 --[[
@@ -68,6 +70,27 @@ local function addJobInTargetList(targetKey, markerKey, pushCmd, isPausedOrMaxed
   rcall(pushCmd, targetKey, jobId)
   addBaseMarkerIfNeeded(markerKey, isPausedOrMaxed)
 end
+--[[
+  Function to debounce a job.
+]]
+local function debounceJob(prefixKey, debounceOpts, jobId, debounceKey, eventsKey, maxEvents)
+  local debounceId = debounceOpts and debounceOpts['id']
+  if debounceId then
+    local ttl = debounceOpts['ttl']
+    local debounceKeyExists
+    if ttl then
+      debounceKeyExists = not rcall('SET', debounceKey, jobId, 'PX', ttl, 'NX')
+    else
+      debounceKeyExists = not rcall('SET', debounceKey, jobId, 'NX')
+    end
+    if debounceKeyExists then
+      local currentDebounceJobId = rcall('GET', debounceKey)
+      rcall("XADD", eventsKey, "MAXLEN", "~", maxEvents, "*", "event",
+        "debounced", "jobId", currentDebounceJobId)
+      return currentDebounceJobId
+    end
+  end
+end
 --[[
   Function to get max events value or set by default 10000.
 ]]
@@ -257,6 +280,7 @@ local function storeJob(eventsKey, jobIdKey, jobId, name, data, opts, timestamp,
     local jsonOpts = cjson.encode(opts)
     local delay = opts['delay'] or 0
     local priority = opts['priority'] or 0
+    local debounceId = opts['de'] and opts['de']['id']
     local optionalValues = {}
     if parentKey ~= nil then
         table.insert(optionalValues, "parentKey")
@@ -268,6 +292,10 @@ local function storeJob(eventsKey, jobIdKey, jobId, name, data, opts, timestamp,
         table.insert(optionalValues, "rjk")
         table.insert(optionalValues, repeatJobKey)
     end
+    if debounceId then
+        table.insert(optionalValues, "deid")
+        table.insert(optionalValues, debounceId)
+    end
     rcall("HMSET", jobIdKey, "name", name, "data", data, "opts", jsonOpts,
           "timestamp", timestamp, "delay", delay, "priority", priority,
           unpack(optionalValues))
@@ -295,6 +323,11 @@ else
             maxEvents, timestamp)
     end
 end
+local debouncedJobId = debounceJob(args[1], opts['de'],
+  jobId, debounceKey, eventsKey, maxEvents)
+if debouncedJobId then
+  return debouncedJobId
+end
 -- Store the job.
 storeJob(eventsKey, jobIdKey, jobId, args[3], ARGV[2], opts, timestamp,
          parentKey, parentData, repeatJobKey)

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

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

@@ -50,6 +50,16 @@ end
   Function to remove job.
 ]]
 -- Includes
+--[[
+  Function to remove debounce key.
+]]
+local function removeDebounceKey(prefixKey, jobKey)
+  local debounceId = rcall("HGET", jobKey, "deid")
+  if debounceId then
+    local debounceKey = prefixKey .. "de:" .. debounceId
+    rcall("DEL", debounceKey)
+  end
+end
 --[[
   Function to remove job keys.
 ]]
@@ -118,7 +128,7 @@ local function moveParentToWait(parentPrefix, parentId, emitEvent)
     rcall("XADD", parentEventStream, "*", "event", "waiting", "jobId", parentId, "prev", "waiting-children")
   end
 end
-local function removeParentDependencyKey(jobKey, hard, parentKey, baseKey)
+local function removeParentDependencyKey(jobKey, hard, parentKey, baseKey, debounceId)
   if parentKey then
     local parentDependenciesKey = parentKey .. ":dependencies"
     local result = rcall("SREM", parentDependenciesKey, jobKey)
@@ -131,8 +141,11 @@ local function removeParentDependencyKey(jobKey, hard, parentKey, baseKey)
         if numRemovedElements == 1 then
           if hard then -- remove parent in same queue
             if parentPrefix == baseKey then
-              removeParentDependencyKey(parentKey, hard, nil, baseKey)
+              removeParentDependencyKey(parentKey, hard, nil, baseKey, nil)
               removeJobKeys(parentKey)
+              if debounceId then
+                rcall("DEL", parentPrefix .. "de:" .. debounceId)
+              end
             else
               moveParentToWait(parentPrefix, parentId)
             end
@@ -144,7 +157,8 @@ local function removeParentDependencyKey(jobKey, hard, parentKey, baseKey)
       return true
     end
   else
-    local missedParentKey = rcall("HGET", jobKey, "parentKey")
+    local parentAttributes = rcall("HMGET", jobKey, "parentKey", "deid")
+    local missedParentKey = parentAttributes[1]
     if( (type(missedParentKey) == "string") and missedParentKey ~= ""
       and (rcall("EXISTS", missedParentKey) == 1)) then
       local parentDependenciesKey = missedParentKey .. ":dependencies"
@@ -158,8 +172,11 @@ local function removeParentDependencyKey(jobKey, hard, parentKey, baseKey)
           if numRemovedElements == 1 then
             if hard then
               if parentPrefix == baseKey then
-                removeParentDependencyKey(missedParentKey, hard, nil, baseKey)
+                removeParentDependencyKey(missedParentKey, hard, nil, baseKey, nil)
                 removeJobKeys(missedParentKey)
+                if parentAttributes[2] then
+                  rcall("DEL", parentPrefix .. "de:" .. parentAttributes[2])
+                end
               else
                 moveParentToWait(parentPrefix, parentId)
               end
@@ -174,9 +191,12 @@ local function removeParentDependencyKey(jobKey, hard, parentKey, baseKey)
   end
   return false
 end
-local function removeJob(jobId, hard, baseKey)
+local function removeJob(jobId, hard, baseKey, shouldRemoveDebounceKey)
   local jobKey = baseKey .. jobId
   removeParentDependencyKey(jobKey, hard, nil, baseKey)
+  if shouldRemoveDebounceKey then
+    removeDebounceKey(baseKey, jobKey)
+  end
   removeJobKeys(jobKey)
 end
 local function cleanList(listKey, jobKeyPrefix, rangeStart, rangeEnd,
@@ -205,7 +225,7 @@ local function cleanList(listKey, jobKeyPrefix, rangeStart, rangeEnd,
         -- replace the entry with a deletion marker; the actual deletion will
         -- occur at the end of the script
         rcall("LSET", listKey, rangeEnd - jobIdsLen + i, deletionMarker)
-        removeJob(job, true, jobKeyPrefix)
+        removeJob(job, true, jobKeyPrefix, true --[[remove debounce key]])
         deletedCount = deletedCount + 1
         table.insert(deleted, job)
       end
@@ -259,14 +279,14 @@ local function cleanSet(setKey, jobKeyPrefix, rangeEnd, timestamp, limit, attrib
     end
     local jobKey = jobKeyPrefix .. job
     if isFinished then
-      removeJob(job, true, jobKeyPrefix)
+      removeJob(job, true, jobKeyPrefix, true --[[remove debounce key]])
       deletedCount = deletedCount + 1
       table.insert(deleted, job)
     else
       -- * finishedOn says when the job was completed, but it isn't set unless the job has actually completed
       jobTS = getTimestamp(jobKey, attributes)
       if (not jobTS or jobTS <= timestamp) then
-        removeJob(job, true, jobKeyPrefix)
+        removeJob(job, true, jobKeyPrefix, true --[[remove debounce key]])
         deletedCount = deletedCount + 1
         table.insert(deleted, job)
       end

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

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

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

@@ -25,6 +25,16 @@ local queueBaseKey = ARGV[1]
   Function to remove job.
 ]]
 -- Includes
+--[[
+  Function to remove debounce key.
+]]
+local function removeDebounceKey(prefixKey, jobKey)
+  local debounceId = rcall("HGET", jobKey, "deid")
+  if debounceId then
+    local debounceKey = prefixKey .. "de:" .. debounceId
+    rcall("DEL", debounceKey)
+  end
+end
 --[[
   Function to remove job keys.
 ]]
@@ -93,7 +103,7 @@ local function moveParentToWait(parentPrefix, parentId, emitEvent)
     rcall("XADD", parentEventStream, "*", "event", "waiting", "jobId", parentId, "prev", "waiting-children")
   end
 end
-local function removeParentDependencyKey(jobKey, hard, parentKey, baseKey)
+local function removeParentDependencyKey(jobKey, hard, parentKey, baseKey, debounceId)
   if parentKey then
     local parentDependenciesKey = parentKey .. ":dependencies"
     local result = rcall("SREM", parentDependenciesKey, jobKey)
@@ -106,8 +116,11 @@ local function removeParentDependencyKey(jobKey, hard, parentKey, baseKey)
         if numRemovedElements == 1 then
           if hard then -- remove parent in same queue
             if parentPrefix == baseKey then
-              removeParentDependencyKey(parentKey, hard, nil, baseKey)
+              removeParentDependencyKey(parentKey, hard, nil, baseKey, nil)
               removeJobKeys(parentKey)
+              if debounceId then
+                rcall("DEL", parentPrefix .. "de:" .. debounceId)
+              end
             else
               moveParentToWait(parentPrefix, parentId)
             end
@@ -119,7 +132,8 @@ local function removeParentDependencyKey(jobKey, hard, parentKey, baseKey)
       return true
     end
   else
-    local missedParentKey = rcall("HGET", jobKey, "parentKey")
+    local parentAttributes = rcall("HMGET", jobKey, "parentKey", "deid")
+    local missedParentKey = parentAttributes[1]
     if( (type(missedParentKey) == "string") and missedParentKey ~= ""
       and (rcall("EXISTS", missedParentKey) == 1)) then
       local parentDependenciesKey = missedParentKey .. ":dependencies"
@@ -133,8 +147,11 @@ local function removeParentDependencyKey(jobKey, hard, parentKey, baseKey)
           if numRemovedElements == 1 then
             if hard then
               if parentPrefix == baseKey then
-                removeParentDependencyKey(missedParentKey, hard, nil, baseKey)
+                removeParentDependencyKey(missedParentKey, hard, nil, baseKey, nil)
                 removeJobKeys(missedParentKey)
+                if parentAttributes[2] then
+                  rcall("DEL", parentPrefix .. "de:" .. parentAttributes[2])
+                end
               else
                 moveParentToWait(parentPrefix, parentId)
               end
@@ -149,14 +166,17 @@ local function removeParentDependencyKey(jobKey, hard, parentKey, baseKey)
   end
   return false
 end
-local function removeJob(jobId, hard, baseKey)
+local function removeJob(jobId, hard, baseKey, shouldRemoveDebounceKey)
   local jobKey = baseKey .. jobId
   removeParentDependencyKey(jobKey, hard, nil, baseKey)
+  if shouldRemoveDebounceKey then
+    removeDebounceKey(baseKey, jobKey)
+  end
   removeJobKeys(jobKey)
 end
 local function removeJobs(keys, hard, baseKey, max)
   for i, key in ipairs(keys) do
-    removeJob(key, hard, baseKey)
+    removeJob(key, hard, baseKey, true --[[remove debounce key]])
   end
   return max - #keys
 end

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

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

package/dist/cjs/scripts/index.js

@@ -35,7 +35,7 @@ tslib_1.__exportStar(require("./promote-9"), exports);
 tslib_1.__exportStar(require("./releaseLock-1"), exports);
 tslib_1.__exportStar(require("./removeChildDependency-1"), exports);
 tslib_1.__exportStar(require("./removeJob-2"), exports);
-tslib_1.__exportStar(require("./removeRepeatable-2"), exports);
+tslib_1.__exportStar(require("./removeRepeatable-3"), exports);
 tslib_1.__exportStar(require("./reprocessJob-8"), exports);
 tslib_1.__exportStar(require("./retryJob-11"), exports);
 tslib_1.__exportStar(require("./saveStacktrace-1"), exports);

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

@@ -173,6 +173,18 @@ local function moveParentToWaitIfNeeded(parentQueueKey, parentDependenciesKey,
         end
     end
 end
+--[[
+  Function to remove debounce key if needed.
+]]
+local function removeDebounceKeyIfNeeded(prefixKey, debounceId)
+  if debounceId then
+    local debounceKey = prefixKey .. "de:" .. debounceId
+    local pttl = rcall("PTTL", debounceKey)
+    if pttl == 0 or pttl == -1 then
+      rcall("DEL", debounceKey)
+    end
+  end
+end
 local function moveParentFromWaitingChildrenToFailed( parentQueueKey, parentKey, parentId, jobIdKey, timestamp)
   if rcall("ZREM", parentQueueKey .. ":waiting-children", parentId) == 1 then
     rcall("ZADD", parentQueueKey .. ":failed", timestamp, parentId)
@@ -180,9 +192,10 @@ local function moveParentFromWaitingChildrenToFailed( parentQueueKey, parentKey,
     rcall("HMSET", parentKey, "failedReason", failedReason, "finishedOn", timestamp)
     rcall("XADD", parentQueueKey .. ":events", "*", "event", "failed", "jobId", parentId, "failedReason",
       failedReason, "prev", "waiting-children")
-    local rawParentData = rcall("HGET", parentKey, "parent")
-    if rawParentData ~= false then
-      local parentData = cjson.decode(rawParentData)
+    local jobAttributes = rcall("HMGET", parentKey, "parent", "deid")
+    removeDebounceKeyIfNeeded(parentQueueKey, jobAttributes[2])
+    if jobAttributes[1] then
+      local parentData = cjson.decode(jobAttributes[1])
       if parentData['fpof'] then
         moveParentFromWaitingChildrenToFailed(
           parentData['queueKey'],
@@ -206,6 +219,16 @@ end
   Function to remove job.
 ]]
 -- Includes
+--[[
+  Function to remove debounce key.
+]]
+local function removeDebounceKey(prefixKey, jobKey)
+  local debounceId = rcall("HGET", jobKey, "deid")
+  if debounceId then
+    local debounceKey = prefixKey .. "de:" .. debounceId
+    rcall("DEL", debounceKey)
+  end
+end
 --[[
   Function to remove job keys.
 ]]
@@ -238,7 +261,7 @@ local function moveParentToWait(parentPrefix, parentId, emitEvent)
     rcall("XADD", parentEventStream, "*", "event", "waiting", "jobId", parentId, "prev", "waiting-children")
   end
 end
-local function removeParentDependencyKey(jobKey, hard, parentKey, baseKey)
+local function removeParentDependencyKey(jobKey, hard, parentKey, baseKey, debounceId)
   if parentKey then
     local parentDependenciesKey = parentKey .. ":dependencies"
     local result = rcall("SREM", parentDependenciesKey, jobKey)
@@ -251,8 +274,11 @@ local function removeParentDependencyKey(jobKey, hard, parentKey, baseKey)
         if numRemovedElements == 1 then
           if hard then -- remove parent in same queue
             if parentPrefix == baseKey then
-              removeParentDependencyKey(parentKey, hard, nil, baseKey)
+              removeParentDependencyKey(parentKey, hard, nil, baseKey, nil)
               removeJobKeys(parentKey)
+              if debounceId then
+                rcall("DEL", parentPrefix .. "de:" .. debounceId)
+              end
             else
               moveParentToWait(parentPrefix, parentId)
             end
@@ -264,7 +290,8 @@ local function removeParentDependencyKey(jobKey, hard, parentKey, baseKey)
       return true
     end
   else
-    local missedParentKey = rcall("HGET", jobKey, "parentKey")
+    local parentAttributes = rcall("HMGET", jobKey, "parentKey", "deid")
+    local missedParentKey = parentAttributes[1]
     if( (type(missedParentKey) == "string") and missedParentKey ~= ""
       and (rcall("EXISTS", missedParentKey) == 1)) then
       local parentDependenciesKey = missedParentKey .. ":dependencies"
@@ -278,8 +305,11 @@ local function removeParentDependencyKey(jobKey, hard, parentKey, baseKey)
           if numRemovedElements == 1 then
             if hard then
               if parentPrefix == baseKey then
-                removeParentDependencyKey(missedParentKey, hard, nil, baseKey)
+                removeParentDependencyKey(missedParentKey, hard, nil, baseKey, nil)
                 removeJobKeys(missedParentKey)
+                if parentAttributes[2] then
+                  rcall("DEL", parentPrefix .. "de:" .. parentAttributes[2])
+                end
               else
                 moveParentToWait(parentPrefix, parentId)
               end
@@ -294,20 +324,24 @@ local function removeParentDependencyKey(jobKey, hard, parentKey, baseKey)
   end
   return false
 end
-local function removeJob(jobId, hard, baseKey)
+local function removeJob(jobId, hard, baseKey, shouldRemoveDebounceKey)
   local jobKey = baseKey .. jobId
   removeParentDependencyKey(jobKey, hard, nil, baseKey)
+  if shouldRemoveDebounceKey then
+    removeDebounceKey(baseKey, jobKey)
+  end
   removeJobKeys(jobKey)
 end
 --[[
   Functions to remove jobs by max age.
 ]]
 -- Includes
-local function removeJobsByMaxAge(timestamp, maxAge, targetSet, prefix)
+local function removeJobsByMaxAge(timestamp, maxAge, targetSet, prefix,
+  shouldRemoveDebounceKey)
   local start = timestamp - maxAge * 1000
   local jobIds = rcall("ZREVRANGEBYSCORE", targetSet, start, "-inf")
   for i, jobId in ipairs(jobIds) do
-    removeJob(jobId, false, prefix)
+    removeJob(jobId, false, prefix, false --[[remove debounce key]])
   end
   rcall("ZREMRANGEBYSCORE", targetSet, "-inf", start)
 end
@@ -319,7 +353,7 @@ local function removeJobsByMaxCount(maxCount, targetSet, prefix)
   local start = maxCount
   local jobIds = rcall("ZREVRANGE", targetSet, start, -1)
   for i, jobId in ipairs(jobIds) do
-    removeJob(jobId, false, prefix)
+    removeJob(jobId, false, prefix, false --[[remove debounce key]])
   end
   rcall("ZREMRANGEBYRANK", targetSet, 0, -(maxCount + 1))
 end
@@ -387,12 +421,13 @@ if (#stalling > 0) then
                     local stalledCount =
                         rcall("HINCRBY", jobKey, "stalledCounter", 1)
                     if (stalledCount > MAX_STALLED_JOB_COUNT) then
-                        local jobAttributes = rcall("HMGET", jobKey, "opts", "parent")
+                        local jobAttributes = rcall("HMGET", jobKey, "opts", "parent", "deid")
                         local rawOpts = jobAttributes[1]
                         local rawParentData = jobAttributes[2]
                         local opts = cjson.decode(rawOpts)
                         local removeOnFailType = type(opts["removeOnFail"])
                         rcall("ZADD", failedKey, timestamp, jobId)
+                        removeDebounceKeyIfNeeded(queueKeyPrefix, jobAttributes[3])
                         local failedReason =
                             "job stalled more than allowable limit"
                         rcall("HMSET", jobKey, "failedReason", failedReason,
@@ -425,7 +460,8 @@ if (#stalling > 0) then
                                                   failedKey, queueKeyPrefix)
                         elseif removeOnFailType == "boolean" then
                             if opts["removeOnFail"] then
-                                removeJob(jobId, false, queueKeyPrefix)
+                                removeJob(jobId, false, queueKeyPrefix,
+                                  false --[[remove debounce key]])
                                 rcall("ZREM", failedKey, jobId)
                             end
                         elseif removeOnFailType ~= "nil" then

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

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

@@ -266,6 +266,18 @@ local function moveParentToWaitIfNeeded(parentQueueKey, parentDependenciesKey,
         end
     end
 end
+--[[
+  Function to remove debounce key if needed.
+]]
+local function removeDebounceKeyIfNeeded(prefixKey, debounceId)
+  if debounceId then
+    local debounceKey = prefixKey .. "de:" .. debounceId
+    local pttl = rcall("PTTL", debounceKey)
+    if pttl == 0 or pttl == -1 then
+      rcall("DEL", debounceKey)
+    end
+  end
+end
 local function moveParentFromWaitingChildrenToFailed( parentQueueKey, parentKey, parentId, jobIdKey, timestamp)
   if rcall("ZREM", parentQueueKey .. ":waiting-children", parentId) == 1 then
     rcall("ZADD", parentQueueKey .. ":failed", timestamp, parentId)
@@ -273,9 +285,10 @@ local function moveParentFromWaitingChildrenToFailed( parentQueueKey, parentKey,
     rcall("HMSET", parentKey, "failedReason", failedReason, "finishedOn", timestamp)
     rcall("XADD", parentQueueKey .. ":events", "*", "event", "failed", "jobId", parentId, "failedReason",
       failedReason, "prev", "waiting-children")
-    local rawParentData = rcall("HGET", parentKey, "parent")
-    if rawParentData ~= false then
-      local parentData = cjson.decode(rawParentData)
+    local jobAttributes = rcall("HMGET", parentKey, "parent", "deid")
+    removeDebounceKeyIfNeeded(parentQueueKey, jobAttributes[2])
+    if jobAttributes[1] then
+      local parentData = cjson.decode(jobAttributes[1])
       if parentData['fpof'] then
         moveParentFromWaitingChildrenToFailed(
           parentData['queueKey'],
@@ -376,6 +389,16 @@ end
   Function to remove job.
 ]]
 -- Includes
+--[[
+  Function to remove debounce key.
+]]
+local function removeDebounceKey(prefixKey, jobKey)
+  local debounceId = rcall("HGET", jobKey, "deid")
+  if debounceId then
+    local debounceKey = prefixKey .. "de:" .. debounceId
+    rcall("DEL", debounceKey)
+  end
+end
 --[[
   Check if this job has a parent. If so we will just remove it from
   the parent child list, but if it is the last child we should move the parent to "wait/paused"
@@ -401,7 +424,7 @@ local function moveParentToWait(parentPrefix, parentId, emitEvent)
     rcall("XADD", parentEventStream, "*", "event", "waiting", "jobId", parentId, "prev", "waiting-children")
   end
 end
-local function removeParentDependencyKey(jobKey, hard, parentKey, baseKey)
+local function removeParentDependencyKey(jobKey, hard, parentKey, baseKey, debounceId)
   if parentKey then
     local parentDependenciesKey = parentKey .. ":dependencies"
     local result = rcall("SREM", parentDependenciesKey, jobKey)
@@ -414,8 +437,11 @@ local function removeParentDependencyKey(jobKey, hard, parentKey, baseKey)
         if numRemovedElements == 1 then
           if hard then -- remove parent in same queue
             if parentPrefix == baseKey then
-              removeParentDependencyKey(parentKey, hard, nil, baseKey)
+              removeParentDependencyKey(parentKey, hard, nil, baseKey, nil)
               removeJobKeys(parentKey)
+              if debounceId then
+                rcall("DEL", parentPrefix .. "de:" .. debounceId)
+              end
             else
               moveParentToWait(parentPrefix, parentId)
             end
@@ -427,7 +453,8 @@ local function removeParentDependencyKey(jobKey, hard, parentKey, baseKey)
       return true
     end
   else
-    local missedParentKey = rcall("HGET", jobKey, "parentKey")
+    local parentAttributes = rcall("HMGET", jobKey, "parentKey", "deid")
+    local missedParentKey = parentAttributes[1]
     if( (type(missedParentKey) == "string") and missedParentKey ~= ""
       and (rcall("EXISTS", missedParentKey) == 1)) then
       local parentDependenciesKey = missedParentKey .. ":dependencies"
@@ -441,8 +468,11 @@ local function removeParentDependencyKey(jobKey, hard, parentKey, baseKey)
           if numRemovedElements == 1 then
             if hard then
               if parentPrefix == baseKey then
-                removeParentDependencyKey(missedParentKey, hard, nil, baseKey)
+                removeParentDependencyKey(missedParentKey, hard, nil, baseKey, nil)
                 removeJobKeys(missedParentKey)
+                if parentAttributes[2] then
+                  rcall("DEL", parentPrefix .. "de:" .. parentAttributes[2])
+                end
               else
                 moveParentToWait(parentPrefix, parentId)
               end
@@ -457,16 +487,20 @@ local function removeParentDependencyKey(jobKey, hard, parentKey, baseKey)
   end
   return false
 end
-local function removeJob(jobId, hard, baseKey)
+local function removeJob(jobId, hard, baseKey, shouldRemoveDebounceKey)
   local jobKey = baseKey .. jobId
   removeParentDependencyKey(jobKey, hard, nil, baseKey)
+  if shouldRemoveDebounceKey then
+    removeDebounceKey(baseKey, jobKey)
+  end
   removeJobKeys(jobKey)
 end
-local function removeJobsByMaxAge(timestamp, maxAge, targetSet, prefix)
+local function removeJobsByMaxAge(timestamp, maxAge, targetSet, prefix,
+  shouldRemoveDebounceKey)
   local start = timestamp - maxAge * 1000
   local jobIds = rcall("ZREVRANGEBYSCORE", targetSet, start, "-inf")
   for i, jobId in ipairs(jobIds) do
-    removeJob(jobId, false, prefix)
+    removeJob(jobId, false, prefix, false --[[remove debounce key]])
   end
   rcall("ZREMRANGEBYSCORE", targetSet, "-inf", start)
 end
@@ -478,7 +512,7 @@ local function removeJobsByMaxCount(maxCount, targetSet, prefix)
   local start = maxCount
   local jobIds = rcall("ZREVRANGE", targetSet, start, -1)
   for i, jobId in ipairs(jobIds) do
-    removeJob(jobId, false, prefix)
+    removeJob(jobId, false, prefix, false --[[remove debounce key]])
   end
   rcall("ZREMRANGEBYRANK", targetSet, 0, -(maxCount + 1))
 end
@@ -549,12 +583,12 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
     if rcall("SCARD", jobIdKey .. ":dependencies") ~= 0 then -- // Make sure it does not have pending dependencies
         return -4
     end
-    local parentReferences = rcall("HMGET", jobIdKey, "parentKey", "parent")
-    local parentKey = parentReferences[1] or ""
+    local jobAttributes = rcall("HMGET", jobIdKey, "parentKey", "parent", "deid")
+    local parentKey = jobAttributes[1] or ""
     local parentId = ""
     local parentQueueKey = ""
-    if parentReferences[2] ~= false then
-        local jsonDecodedParent = cjson.decode(parentReferences[2])
+    if jobAttributes[2] ~= false then
+        local jsonDecodedParent = cjson.decode(jobAttributes[2])
         parentId = jsonDecodedParent['id']
         parentQueueKey = jsonDecodedParent['queueKey']
     end
@@ -567,6 +601,8 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
     local metaKey = KEYS[9]
     -- Trim events before emiting them to avoid trimming events emitted in this script
     trimEvents(metaKey, eventStreamKey)
+    local prefix = ARGV[7]
+    removeDebounceKeyIfNeeded(prefix, jobAttributes[3])
     -- If job has a parent we need to
     -- 1) remove this job id from parents dependencies
     -- 2) move the job Id to parent "processed" set
@@ -611,7 +647,6 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
         rcall("HMSET", jobIdKey, ARGV[3], ARGV[4], "finishedOn", timestamp)
         -- "returnvalue" / "failedReason" and "finishedOn"
         -- Remove old jobs?
-        local prefix = ARGV[7]
         if maxAge ~= nil then
             removeJobsByMaxAge(timestamp, maxAge, targetSet, prefix)
         end
@@ -624,7 +659,7 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
             -- TODO: when a child is removed when finished, result or failure in parent
             -- must not be deleted, those value references should be deleted when the parent
             -- is deleted
-            removeParentDependencyKey(jobIdKey, false, parentKey)
+            removeParentDependencyKey(jobIdKey, false, parentKey, jobAttributes[3])
         end
     end
     rcall("XADD", eventStreamKey, "*", "event", ARGV[5], "jobId", jobId, ARGV[3],
@@ -644,7 +679,7 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
     if (ARGV[6] == "1") then
         local target, isPausedOrMaxed = getTargetQueueList(metaKey, KEYS[2], KEYS[1], KEYS[8])
         -- Check if there are delayed jobs that can be promoted
-        promoteDelayedJobs(KEYS[7], KEYS[14], target, KEYS[3], eventStreamKey, ARGV[7],
+        promoteDelayedJobs(KEYS[7], KEYS[14], target, KEYS[3], eventStreamKey, prefix,
                            timestamp, KEYS[10], isPausedOrMaxed)
         local maxJobs = tonumber(opts['limiter'] and opts['limiter']['max'])
         -- Check if we are rate limited first.
@@ -662,19 +697,19 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
                 if jobId == "0:0" then
                     jobId = moveJobFromPriorityToActive(KEYS[3], KEYS[2],
                                                         KEYS[10])
-                    return prepareJobForProcessing(ARGV[7], KEYS[6], eventStreamKey, jobId,
+                    return prepareJobForProcessing(prefix, KEYS[6], eventStreamKey, jobId,
                                                    timestamp, maxJobs,
                                                    opts)
                 end
             else
-                return prepareJobForProcessing(ARGV[7], KEYS[6], eventStreamKey, jobId,
+                return prepareJobForProcessing(prefix, KEYS[6], eventStreamKey, jobId,
                                                timestamp, maxJobs,
                                                opts)
             end
         else
             jobId = moveJobFromPriorityToActive(KEYS[3], KEYS[2], KEYS[10])
             if jobId then
-                return prepareJobForProcessing(ARGV[7], KEYS[6], eventStreamKey, jobId,
+                return prepareJobForProcessing(prefix, KEYS[6], eventStreamKey, jobId,
                                                timestamp, maxJobs,
                                                opts)
             end

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