bullmq 5.10.3 → 5.11.0

package/dist/esm/commands/includes/debounceJob.lua

@@ -0,0 +1,23 @@
+--[[
+  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
+  

package/dist/esm/commands/includes/moveParentFromWaitingChildrenToFailed.lua

@@ -4,6 +4,7 @@
 
 -- Includes
 --- @include "moveParentToWaitIfNeeded"
+--- @include "removeDebounceKeyIfNeeded"
 
 local function moveParentFromWaitingChildrenToFailed( parentQueueKey, parentKey, parentId, jobIdKey, timestamp)
   if rcall("ZREM", parentQueueKey .. ":waiting-children", parentId) == 1 then
@@ -13,10 +14,12 @@ local function moveParentFromWaitingChildrenToFailed( parentQueueKey, parentKey,
     rcall("XADD", parentQueueKey .. ":events", "*", "event", "failed", "jobId", parentId, "failedReason",
       failedReason, "prev", "waiting-children")
 
-    local rawParentData = rcall("HGET", parentKey, "parent")
+    local jobAttributes = rcall("HMGET", parentKey, "parent", "deid")
 
-    if rawParentData ~= false then
-      local parentData = cjson.decode(rawParentData)
+    removeDebounceKeyIfNeeded(parentQueueKey, jobAttributes[2])
+
+    if jobAttributes[1] then
+      local parentData = cjson.decode(jobAttributes[1])
       if parentData['fpof'] then
         moveParentFromWaitingChildrenToFailed(
           parentData['queueKey'],

package/dist/esm/commands/includes/removeDebounceKey.lua

@@ -0,0 +1,12 @@
+--[[
+  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
+  

package/dist/esm/commands/includes/removeDebounceKeyIfNeeded.lua

@@ -0,0 +1,14 @@
+--[[
+  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

package/dist/esm/commands/includes/removeJob.lua

@@ -3,11 +3,15 @@
 ]]
 
 -- Includes
+--- @include "removeDebounceKey"
 --- @include "removeJobKeys"
 --- @include "removeParentDependencyKey"
 
-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

package/dist/esm/commands/includes/removeJobs.lua

@@ -7,7 +7,7 @@
 
 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/esm/commands/includes/removeJobsByMaxAge.lua

@@ -5,11 +5,12 @@
 -- Includes
 --- @include "removeJob"
 
-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

package/dist/esm/commands/includes/removeJobsByMaxCount.lua

@@ -9,7 +9,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

package/dist/esm/commands/includes/removeParentDependencyKey.lua

@@ -21,7 +21,7 @@ local function moveParentToWait(parentPrefix, parentId, emitEvent)
   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)
@@ -36,8 +36,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
@@ -49,7 +52,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"
@@ -65,8 +69,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

package/dist/esm/commands/includes/storeJob.lua

@@ -6,7 +6,8 @@ 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")
@@ -20,6 +21,11 @@ local function storeJob(eventsKey, jobIdKey, jobId, name, data, opts, timestamp,
         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))

package/dist/esm/commands/moveStalledJobsToWait-9.lua

@@ -29,6 +29,7 @@ local rcall = redis.call
 --- @include "includes/getTargetQueueList"
 --- @include "includes/moveParentFromWaitingChildrenToFailed"
 --- @include "includes/moveParentToWaitIfNeeded"
+--- @include "includes/removeDebounceKeyIfNeeded"
 --- @include "includes/removeJob"
 --- @include "includes/removeJobsByMaxAge"
 --- @include "includes/removeJobsByMaxCount"
@@ -83,12 +84,14 @@ 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,
@@ -122,7 +125,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/esm/commands/moveToFinished-14.lua

@@ -65,6 +65,7 @@ local rcall = redis.call
 --- @include "includes/moveParentToWaitIfNeeded"
 --- @include "includes/prepareJobForProcessing"
 --- @include "includes/promoteDelayedJobs"
+--- @include "includes/removeDebounceKeyIfNeeded"
 --- @include "includes/removeJobKeys"
 --- @include "includes/removeJobsByMaxAge"
 --- @include "includes/removeJobsByMaxCount"
@@ -93,12 +94,12 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
         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
@@ -116,6 +117,10 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
     -- 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
@@ -164,8 +169,6 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
         -- "returnvalue" / "failedReason" and "finishedOn"
 
         -- Remove old jobs?
-        local prefix = ARGV[7]
-
         if maxAge ~= nil then
             removeJobsByMaxAge(timestamp, maxAge, targetSet, prefix)
         end
@@ -179,7 +182,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
 
@@ -205,7 +208,7 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
         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'])
@@ -229,19 +232,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/esm/commands/removeChildDependency-1.lua

@@ -25,7 +25,7 @@ if rcall("EXISTS", jobKey) ~= 1 then return -1 end
 
 if rcall("EXISTS", parentKey) ~= 1 then return -5 end
 
-if removeParentDependencyKey(jobKey, false, parentKey, KEYS[1]) then
+if removeParentDependencyKey(jobKey, false, parentKey, KEYS[1], nil) then
   rcall("HDEL", jobKey, "parentKey", "parent")
 
   return 0

package/dist/esm/commands/removeJob-2.lua

@@ -19,6 +19,7 @@ local rcall = redis.call
 --- @include "includes/destructureJobKey"
 --- @include "includes/getOrSetMaxEvents"
 --- @include "includes/isLocked"
+--- @include "includes/removeDebounceKey"
 --- @include "includes/removeJobFromAnyState"
 --- @include "includes/removeJobKeys"
 --- @include "includes/removeParentDependencyKey"
@@ -26,7 +27,7 @@ local rcall = redis.call
 local function removeJob( prefix, jobId, parentKey, removeChildren)
     local jobKey = prefix .. jobId;
 
-    removeParentDependencyKey(jobKey, false, parentKey)
+    removeParentDependencyKey(jobKey, false, parentKey, nil)
 
     if removeChildren == "1" then
         -- Check if this job has children
@@ -66,6 +67,7 @@ local function removeJob( prefix, jobId, parentKey, removeChildren)
 
     local prev = removeJobFromAnyState(prefix, jobId)
 
+    removeDebounceKey(prefix, jobKey)
     if removeJobKeys(jobKey) > 0 then
         local maxEvents = getOrSetMaxEvents(KEYS[2])
         rcall("XADD", prefix .. "events", "MAXLEN", "~", maxEvents, "*", "event", "removed",

package/dist/esm/commands/{removeRepeatable-2.lua → removeRepeatable-3.lua}

@@ -4,6 +4,7 @@
   Input:
     KEYS[1] repeat jobs key
     KEYS[2] delayed jobs key
+    KEYS[3] events key
 
     ARGV[1] old repeat job id
     ARGV[2] options concat
@@ -29,7 +30,7 @@ if millis then
   local repeatJobId = ARGV[1] .. millis
   if(rcall("ZREM", KEYS[2], repeatJobId) == 1) then
     removeJobKeys(ARGV[4] .. repeatJobId)
-    rcall("XADD", ARGV[4] .. "events", "*", "event", "removed", "jobId", repeatJobId, "prev", "delayed");
+    rcall("XADD", KEYS[3], "*", "event", "removed", "jobId", repeatJobId, "prev", "delayed");
   end
 end
 
@@ -45,11 +46,12 @@ if millis then
   local repeatJobId = "repeat:" .. ARGV[3] .. ":" .. millis
   if(rcall("ZREM", KEYS[2], repeatJobId) == 1) then
     removeJobKeys(ARGV[4] .. repeatJobId)
-    rcall("XADD", ARGV[4] .. "events", "*", "event", "removed", "jobId", repeatJobId, "prev", "delayed");
+    rcall("XADD", KEYS[3], "*", "event", "removed", "jobId", repeatJobId, "prev", "delayed")
   end
 end
 
 if(rcall("ZREM", KEYS[1], ARGV[3]) == 1) then
+  rcall("DEL", KEYS[1] .. ":" .. ARGV[3])
   return 0
 end
 

package/dist/esm/interfaces/debounce-options.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Debounce options
+ */
+export interface DebounceOptions {
+    /**
+     * ttl in milliseconds
+     */
+    ttl?: number;
+    /**
+     * Identifier
+     */
+    id: string;
+}

package/dist/esm/interfaces/debounce-options.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=debounce-options.js.map

package/dist/esm/interfaces/debounce-options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"debounce-options.js","sourceRoot":"","sources":["../../../src/interfaces/debounce-options.ts"],"names":[],"mappings":""}

package/dist/esm/interfaces/index.d.ts

@@ -3,6 +3,7 @@ export * from './backoff-options';
 export * from './base-job-options';
 export * from './child-message';
 export * from './connection';
+export * from './debounce-options';
 export * from './flow-job';
 export * from './ioredis-events';
 export * from './job-json';

package/dist/esm/interfaces/index.js

@@ -3,6 +3,7 @@ export * from './backoff-options';
 export * from './base-job-options';
 export * from './child-message';
 export * from './connection';
+export * from './debounce-options';
 export * from './flow-job';
 export * from './ioredis-events';
 export * from './job-json';

package/dist/esm/interfaces/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/interfaces/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,mBAAmB,CAAC;AAClC,cAAc,WAAW,CAAC;AAC1B,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC;AACjC,cAAc,UAAU,CAAC;AACzB,cAAc,iBAAiB,CAAC;AAChC,cAAc,wBAAwB,CAAC;AACvC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,kBAAkB,CAAC;AACjC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/interfaces/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,oBAAoB,CAAC;AACnC,cAAc,YAAY,CAAC;AAC3B,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,mBAAmB,CAAC;AAClC,cAAc,WAAW,CAAC;AAC1B,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC;AACjC,cAAc,UAAU,CAAC;AACzB,cAAc,iBAAiB,CAAC;AAChC,cAAc,wBAAwB,CAAC;AACvC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,kBAAkB,CAAC;AACjC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC"}

package/dist/esm/interfaces/job-json.d.ts

@@ -17,6 +17,7 @@ export interface JobJson {
     parent?: ParentKeys;
     parentKey?: string;
     repeatJobKey?: string;
+    debounceId?: string;
     processedBy?: string;
 }
 export interface JobJsonRaw {
@@ -35,6 +36,7 @@ export interface JobJsonRaw {
     returnvalue: string;
     parentKey?: string;
     parent?: string;
+    deid?: string;
     rjk?: string;
     atm?: string;
     ats?: string;

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

@@ -22,6 +22,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:
@@ -39,8 +40,9 @@ local rcall = redis.call
 local args = cmsgpack.unpack(ARGV[1])
 local data = ARGV[2]
 local parentKey = args[5]
-local repeatJobKey = args[9]
 local parent = args[8]
+local repeatJobKey = args[9]
+local debounceKey = args[10]
 local parentData
 -- Includes
 --[[
@@ -67,6 +69,27 @@ local function addDelayMarkerIfNeeded(markerKey, delayedKey)
     rcall("ZADD", markerKey, nextTimestamp, "1")
   end
 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
 --[[
   Bake in the job id first 12 bits into the timestamp
   to guarantee correct execution order of delayed jobs
@@ -272,6 +295,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")
@@ -283,6 +307,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))
@@ -310,6 +338,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.
 local delay, priority = storeJob(eventsKey, jobIdKey, jobId, args[3], ARGV[2],
                                  opts, timestamp, parentKey, parentData,

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

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

package/dist/esm/scripts/addParentJob-4.js

@@ -18,6 +18,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:
@@ -35,10 +36,32 @@ 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
+--[[
+  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.
 ]]
@@ -244,6 +267,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")
@@ -255,6 +279,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))
@@ -281,6 +309,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/esm/scripts/addParentJob-4.js.map

@@ -1 +1 @@
-{"version":3,"file":"addParentJob-4.js","sourceRoot":"","sources":["../../../src/scripts/addParentJob-4.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuSf,CAAC;AACF,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,IAAI,EAAE,cAAc;IACpB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}
+{"version":3,"file":"addParentJob-4.js","sourceRoot":"","sources":["../../../src/scripts/addParentJob-4.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwUf,CAAC;AACF,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,IAAI,EAAE,cAAc;IACpB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}