bullmq 5.15.0 → 5.17.0

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

@@ -0,0 +1,75 @@
+--[[
+  Adds a job scheduler, i.e. a job factory that creates jobs based on a given schedule (repeat options).
+
+    Input:
+      KEYS[1] 'repeat' key
+      KEYS[2] 'delayed' key
+      
+      ARGV[1] next milliseconds
+      ARGV[2] msgpacked options
+            [1]  name
+            [2]  tz?
+            [3]  patten?
+            [4]  endDate?
+            [5]  every?
+      ARGV[3] jobs scheduler id
+      ARGV[4] prefix key
+
+      Output:
+        repeatableKey  - OK
+]]
+local rcall = redis.call
+local repeatKey = KEYS[1]
+local delayedKey = KEYS[2]
+
+local nextMillis = ARGV[1]
+local jobSchedulerId = ARGV[3]
+local prefixKey = ARGV[4]
+
+-- Includes
+--- @include "includes/removeJob"
+
+local function storeRepeatableJob(repeatKey, nextMillis, rawOpts)
+  rcall("ZADD", repeatKey, nextMillis, jobSchedulerId)
+  local opts = cmsgpack.unpack(rawOpts)
+
+  local optionalValues = {}
+  if opts['tz'] then
+    table.insert(optionalValues, "tz")
+    table.insert(optionalValues, opts['tz'])
+  end
+
+  if opts['pattern'] then
+    table.insert(optionalValues, "pattern")
+    table.insert(optionalValues, opts['pattern'])
+  end
+
+  if opts['endDate'] then
+    table.insert(optionalValues, "endDate")
+    table.insert(optionalValues, opts['endDate'])
+  end
+  
+  if opts['every'] then
+    table.insert(optionalValues, "every")
+    table.insert(optionalValues, opts['every'])
+  end
+
+  rcall("HMSET", repeatKey .. ":" .. jobSchedulerId, "name", opts['name'],
+    unpack(optionalValues))
+end
+
+-- If we are overriding a repeatable job we must delete the delayed job for
+-- the next iteration.
+local prevMillis = rcall("ZSCORE", repeatKey, jobSchedulerId)
+if prevMillis ~= false then
+  local delayedJobId =  "repeat:" .. jobSchedulerId .. ":" .. prevMillis
+  local nextDelayedJobId =  repeatKey .. ":" .. jobSchedulerId .. ":" .. nextMillis
+
+  if rcall("ZSCORE", delayedKey, delayedJobId) ~= false
+   and rcall("EXISTS", nextDelayedJobId) ~= 1 then
+    removeJob(delayedJobId, true, prefixKey, true --[[remove debounce key]])
+    rcall("ZREM", delayedKey, delayedJobId)
+  end
+end
+
+return storeRepeatableJob(repeatKey, nextMillis, ARGV[2])

package/dist/esm/commands/addParentJob-4.lua

@@ -20,7 +20,7 @@
             [7]  parent dependencies key.
             [8]  parent? {id, queueKey}
             [9]  repeat job key
-            [10] debounce key
+            [10] deduplication key
             
       ARGV[2] Json stringified job data
       ARGV[3] msgpacked options
@@ -47,11 +47,11 @@ local opts = cmsgpack.unpack(ARGV[3])
 local parentKey = args[5]
 local parent = args[8]
 local repeatJobKey = args[9]
-local debounceKey = args[10]
+local deduplicationKey = args[10]
 local parentData
 
 -- Includes
---- @include "includes/debounceJob"
+--- @include "includes/deduplicateJob"
 --- @include "includes/getOrSetMaxEvents"
 --- @include "includes/handleDuplicatedJob"
 --- @include "includes/storeJob"
@@ -81,10 +81,10 @@ else
     end
 end
 
-local debouncedJobId = debounceJob(args[1], opts['de'],
-  jobId, debounceKey, eventsKey, maxEvents)
-if debouncedJobId then
-  return debouncedJobId
+local deduplicationJobId = deduplicateJob(args[1], opts['de'],
+  jobId, deduplicationKey, eventsKey, maxEvents)
+if deduplicationJobId then
+  return deduplicationJobId
 end
 
 -- Store the job.

package/dist/esm/commands/addPrioritizedJob-8.lua

@@ -24,7 +24,7 @@
             [7]  parent dependencies key.
             [8]  parent? {id, queueKey}
             [9]  repeat job key
-            [10] debounce key
+            [10] deduplication key
 
       ARGV[2] Json stringified job data
       ARGV[3] msgpacked options
@@ -54,12 +54,12 @@ local opts = cmsgpack.unpack(ARGV[3])
 local parentKey = args[5]
 local parent = args[8]
 local repeatJobKey = args[9]
-local debounceKey = args[10]
+local deduplicationKey = args[10]
 local parentData
 
 -- Includes
 --- @include "includes/addJobWithPriority"
---- @include "includes/debounceJob"
+--- @include "includes/deduplicateJob"
 --- @include "includes/storeJob"
 --- @include "includes/getOrSetMaxEvents"
 --- @include "includes/handleDuplicatedJob"
@@ -90,10 +90,10 @@ else
     end
 end
 
-local debouncedJobId = debounceJob(args[1], opts['de'],
-  jobId, debounceKey, eventsKey, maxEvents)
-if debouncedJobId then
-  return debouncedJobId
+local deduplicationJobId = deduplicateJob(args[1], opts['de'],
+  jobId, deduplicationKey, eventsKey, maxEvents)
+if deduplicationJobId then
+  return deduplicationJobId
 end
 
 -- Store the job.

package/dist/esm/commands/addStandardJob-8.lua

@@ -34,7 +34,7 @@
             [7]  parent dependencies key.
             [8]  parent? {id, queueKey}
             [9]  repeat job key
-            [10] debounce key
+            [10] deduplication key
 
       ARGV[2] Json stringified job data
       ARGV[3] msgpacked options
@@ -57,12 +57,12 @@ local opts = cmsgpack.unpack(ARGV[3])
 local parentKey = args[5]
 local parent = args[8]
 local repeatJobKey = args[9]
-local debounceKey = args[10]
+local deduplicationKey = args[10]
 local parentData
 
 -- Includes
 --- @include "includes/addJobInTargetList"
---- @include "includes/debounceJob"
+--- @include "includes/deduplicateJob"
 --- @include "includes/getOrSetMaxEvents"
 --- @include "includes/getTargetQueueList"
 --- @include "includes/handleDuplicatedJob"
@@ -94,10 +94,10 @@ else
     end
 end
 
-local debouncedJobId = debounceJob(args[1], opts['de'],
-  jobId, debounceKey, eventsKey, maxEvents)
-if debouncedJobId then
-  return debouncedJobId
+local deduplicationJobId = deduplicateJob(args[1], opts['de'],
+  jobId, deduplicationKey, eventsKey, maxEvents)
+if deduplicationJobId then
+  return deduplicationJobId
 end
 
 -- Store the job.

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

@@ -4,6 +4,7 @@
   Input:
     KEYS[1]  set key,
     KEYS[2]  events stream key
+    KEYS[3]  job schedulers key
 
     ARGV[1]  jobKey prefix
     ARGV[2]  timestamp
@@ -32,21 +33,21 @@ end
 
 local result
 if ARGV[4] == "active" then
-  result = cleanList(KEYS[1], ARGV[1], rangeStart, rangeEnd, ARGV[2], false)
+  result = cleanList(KEYS[1], ARGV[1], rangeStart, rangeEnd, ARGV[2], false --[[ hasFinished ]])
 elseif ARGV[4] == "delayed" then
   rangeEnd = "+inf"
   result = cleanSet(KEYS[1], ARGV[1], rangeEnd, ARGV[2], limit,
-                    {"processedOn", "timestamp"}, false)
+                    {"processedOn", "timestamp"}, false  --[[ hasFinished ]], KEYS[3])
 elseif ARGV[4] == "prioritized" then
   rangeEnd = "+inf"
   result = cleanSet(KEYS[1], ARGV[1], rangeEnd, ARGV[2], limit,
-                    {"timestamp"}, false)
+                    {"timestamp"}, false  --[[ hasFinished ]])
 elseif ARGV[4] == "wait" or ARGV[4] == "paused" then
-  result = cleanList(KEYS[1], ARGV[1], rangeStart, rangeEnd, ARGV[2], true)
+  result = cleanList(KEYS[1], ARGV[1], rangeStart, rangeEnd, ARGV[2], true --[[ hasFinished ]])
 else
   rangeEnd = ARGV[2]
   result = cleanSet(KEYS[1], ARGV[1], rangeEnd, ARGV[2], limit,
-                    {"finishedOn"}, true)
+                    {"finishedOn"}, true  --[[ hasFinished ]])
 end
 
 rcall("XADD", KEYS[2], "*", "event", "cleaned", "count", result[2])

package/dist/esm/commands/drain-5.lua

@@ -0,0 +1,41 @@
+--[[
+  Drains the queue, removes all jobs that are waiting
+  or delayed, but not active, completed or failed
+
+  Input:
+    KEYS[1] 'wait',
+    KEYS[2] 'paused'
+    KEYS[3] 'delayed'
+    KEYS[4] 'prioritized'
+    KEYS[5] 'jobschedulers' (repeat)
+
+    ARGV[1]  queue key prefix
+]]
+local rcall = redis.call
+local queueBaseKey = ARGV[1]
+
+--- @include "includes/removeListJobs"
+--- @include "includes/removeZSetJobs"
+
+removeListJobs(KEYS[1], true, queueBaseKey, 0) -- wait
+removeListJobs(KEYS[2], true, queueBaseKey, 0) -- paused
+
+if KEYS[3] ~= "" then
+
+    -- We must not remove delayed jobs if they are associated to a job scheduler.
+    local scheduledJobs = {}
+    local jobSchedulers = rcall("ZRANGE", KEYS[5], 0, -1, "WITHSCORES")
+
+    -- For every job scheduler, get the current delayed job id.
+    for i = 1, #jobSchedulers, 2 do
+        local jobSchedulerId = jobSchedulers[i]
+        local jobSchedulerMillis = jobSchedulers[i + 1]
+
+        local delayedJobId = "repeat:" .. jobSchedulerId .. ":" .. jobSchedulerMillis
+        scheduledJobs[delayedJobId] = true
+    end
+
+    removeZSetJobs(KEYS[3], true, queueBaseKey, 0, scheduledJobs) -- delayed
+end
+
+removeZSetJobs(KEYS[4], true, queueBaseKey, 0) -- prioritized

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

@@ -1,45 +1,66 @@
 --[[
   Function to clean job set.
   Returns jobIds and deleted count number.
-]]
+]] 
 
 -- Includes
 --- @include "batches"
 --- @include "getJobsInZset"
 --- @include "getTimestamp"
 --- @include "removeJob"
-
-local function cleanSet(setKey, jobKeyPrefix, rangeEnd, timestamp, limit, attributes, isFinished)
-  local jobs = getJobsInZset(setKey, rangeEnd, limit)
-  local deleted = {}
-  local deletedCount = 0
-  local jobTS
-  for i, job in ipairs(jobs) do
-    if limit > 0 and deletedCount >= limit then
-      break
+local function isJobSchedulerJob(jobId, jobSchedulersKey)
+    if jobSchedulersKey then
+        local jobSchedulerId = jobId:match("repeat:(.*):%d+")
+        if jobSchedulerId then
+            return rcall("ZSCORE", jobSchedulersKey, jobSchedulerId)
+        end
     end
+    return false
+end
+
+local function cleanSet(
+    setKey,
+    jobKeyPrefix,
+    rangeEnd,
+    timestamp,
+    limit,
+    attributes,
+    isFinished,
+    jobSchedulersKey)
+    local jobs = getJobsInZset(setKey, rangeEnd, limit)
+    local deleted = {}
+    local deletedCount = 0
+    local jobTS
+    for i, job in ipairs(jobs) do
+        if limit > 0 and deletedCount >= limit then
+            break
+        end
 
-    local jobKey = jobKeyPrefix .. job
-    if isFinished then
-      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, true --[[remove debounce key]])
-        deletedCount = deletedCount + 1
-        table.insert(deleted, job)
-      end
+        -- Extract a Job Scheduler Id from jobId ("repeat:job-scheduler-id:millis") 
+        -- and check if it is in the scheduled jobs
+        if not isJobSchedulerJob(job, jobSchedulersKey) then
+            local jobKey = jobKeyPrefix .. job
+            if isFinished then
+                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, true --[[remove debounce key]] )
+                    deletedCount = deletedCount + 1
+                    table.insert(deleted, job)
+                end
+            end
+        end
     end
-  end
 
-  if(#deleted > 0) then
-    for from, to in batches(#deleted, 7000) do
-      rcall("ZREM", setKey, unpack(deleted, from, to))
+    if (#deleted > 0) then
+        for from, to in batches(#deleted, 7000) do
+            rcall("ZREM", setKey, unpack(deleted, from, to))
+        end
     end
-  end
 
-  return {deleted, deletedCount}
+    return {deleted, deletedCount}
 end

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

@@ -0,0 +1,25 @@
+--[[
+  Function to debounce a job.
+]]
+
+local function deduplicateJob(prefixKey, 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
+  end
+end
+  

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

@@ -3,8 +3,20 @@
 --- @include "getZSetItems"
 --- @include "removeJobs"  
 
-local function removeZSetJobs(keyName, hard, baseKey, max)
+local function removeZSetJobs(keyName, hard, baseKey, max, jobsToIgnore)
   local jobs = getZSetItems(keyName, max)
+
+  -- filter out jobs to ignore
+  if jobsToIgnore then
+    local filteredJobs = {}
+    for i = 1, #jobs do
+      if not jobsToIgnore[jobs[i]] then
+        table.insert(filteredJobs, jobs[i])
+      end
+    end
+    jobs = filteredJobs
+  end
+
   local count = removeJobs(jobs, hard, baseKey, max)
   if(#jobs > 0) then
     for from, to in batches(#jobs, 7000) do

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

@@ -44,7 +44,7 @@ local metaKey = KEYS[6]
 local pausedKey = KEYS[7]
 local markerKey = KEYS[8]
 local eventStreamKey = KEYS[9]
-local maxStalledJobCount = ARGV[1]
+local maxStalledJobCount = tonumber(ARGV[1])
 local queueKeyPrefix = ARGV[2]
 local timestamp = ARGV[3]
 local maxCheckTime = ARGV[4]
@@ -63,8 +63,6 @@ local failed = {}
 if (#stalling > 0) then
     rcall('DEL', stalledKey)
 
-    local MAX_STALLED_JOB_COUNT = tonumber(maxStalledJobCount)
-
     -- Remove from active list
     for i, jobId in ipairs(stalling) do
         -- Markers in waitlist DEPRECATED in v5: Remove in v6.
@@ -83,7 +81,7 @@ if (#stalling > 0) then
                     -- If this job has been stalled too many times, such as if it crashes the worker, then fail it.
                     local stalledCount =
                         rcall("HINCRBY", jobKey, "stalledCounter", 1)
-                    if (stalledCount > MAX_STALLED_JOB_COUNT) then
+                    if (stalledCount > maxStalledJobCount) then
                         local jobAttributes = rcall("HMGET", jobKey, "opts", "parent", "deid")
                         local rawOpts = jobAttributes[1]
                         local rawParentData = jobAttributes[2]

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

@@ -24,7 +24,7 @@ local rcall = redis.call
 --- @include "includes/removeJobKeys"
 --- @include "includes/removeParentDependencyKey"
 
-local function removeJob( prefix, jobId, parentKey, removeChildren)
+local function removeJob(prefix, jobId, parentKey, removeChildren)
     local jobKey = prefix .. jobId;
 
     removeParentDependencyKey(jobKey, false, parentKey, nil)
@@ -33,14 +33,14 @@ local function removeJob( prefix, jobId, parentKey, removeChildren)
         -- 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 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 )
+                removeJob(childJobPrefix, childJobId, jobKey, removeChildren)
             end
         end
 
@@ -50,7 +50,7 @@ local function removeJob( prefix, jobId, parentKey, removeChildren)
                 -- We need to get the jobId for this job.
                 local childJobId = getJobIdFromKey(childJobKey)
                 local childJobPrefix = getJobKeyPrefix(childJobKey, childJobId)
-                removeJob( childJobPrefix, childJobId, jobKey, removeChildren )
+                removeJob(childJobPrefix, childJobId, jobKey, removeChildren)
             end
         end
 
@@ -60,7 +60,7 @@ local function removeJob( prefix, jobId, parentKey, removeChildren)
             for i = 1, #failed, 2 do
                 local childJobId = getJobIdFromKey(failed[i])
                 local childJobPrefix = getJobKeyPrefix(failed[i], childJobId)
-                removeJob( childJobPrefix, childJobId, jobKey, removeChildren )
+                removeJob(childJobPrefix, childJobId, jobKey, removeChildren)
             end
         end
     end
@@ -70,15 +70,23 @@ local function removeJob( prefix, jobId, parentKey, removeChildren)
     removeDebounceKey(prefix, jobKey)
     if removeJobKeys(jobKey) > 0 then
         local maxEvents = getOrSetMaxEvents(KEYS[2])
-        rcall("XADD", prefix .. "events", "MAXLEN", "~", maxEvents, "*", "event", "removed",
-            "jobId", jobId, "prev", prev)
+        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
 
-if not isLocked(prefix, ARGV[1], ARGV[2]) then
-    removeJob(prefix, ARGV[1], nil, ARGV[2])
+-- Check if the job belongs to a job scheduler and it is in delayed state.
+if rcall("ZSCORE", prefix .. "delayed", jobId) and rcall("HGET", jobKey, "rjk") then
+    return -8 -- Return error code as the job is part of a job scheduler and is in delayed state.
+end
+
+if not isLocked(prefix, jobId, shouldRemoveChildren) then
+    removeJob(prefix, jobId, nil, shouldRemoveChildren)
     return 1
 end
 return 0

package/dist/esm/commands/removeJobScheduler-3.lua

@@ -0,0 +1,43 @@
+
+--[[
+  Removes a repeatable job
+  Input:
+    KEYS[1] job schedulers key
+    KEYS[2] delayed jobs key
+    KEYS[3] events key
+
+    ARGV[1] job scheduler id
+    ARGV[2] prefix key
+
+  Output:
+    0 - OK
+    1 - Missing repeat job
+
+  Events:
+    'removed'
+]]
+local rcall = redis.call
+
+-- Includes
+--- @include "includes/removeJobKeys"
+
+local jobSchedulerId = ARGV[1]
+local prefix = ARGV[2]
+
+local millis = rcall("ZSCORE", KEYS[1], jobSchedulerId)
+
+if millis then
+  -- Delete next programmed job.
+  local delayedJobId = "repeat:" .. jobSchedulerId .. ":" .. millis
+  if(rcall("ZREM", KEYS[2], delayedJobId) == 1) then
+    removeJobKeys(prefix .. delayedJobId)
+    rcall("XADD", KEYS[3], "*", "event", "removed", "jobId", delayedJobId, "prev", "delayed")
+  end
+end
+
+if(rcall("ZREM", KEYS[1], jobSchedulerId) == 1) then
+  rcall("DEL", KEYS[1] .. ":" .. jobSchedulerId)
+  return 0
+end
+
+return 1

package/dist/esm/enums/error-code.d.ts

@@ -5,5 +5,6 @@ export declare enum ErrorCode {
     JobPendingDependencies = -4,
     ParentJobNotExist = -5,
     JobLockMismatch = -6,
-    ParentJobCannotBeReplaced = -7
+    ParentJobCannotBeReplaced = -7,
+    JobBelongsToJobScheduler = -8
 }

package/dist/esm/enums/error-code.js

@@ -7,5 +7,6 @@ export var ErrorCode;
     ErrorCode[ErrorCode["ParentJobNotExist"] = -5] = "ParentJobNotExist";
     ErrorCode[ErrorCode["JobLockMismatch"] = -6] = "JobLockMismatch";
     ErrorCode[ErrorCode["ParentJobCannotBeReplaced"] = -7] = "ParentJobCannotBeReplaced";
+    ErrorCode[ErrorCode["JobBelongsToJobScheduler"] = -8] = "JobBelongsToJobScheduler";
 })(ErrorCode || (ErrorCode = {}));
 //# sourceMappingURL=error-code.js.map

package/dist/esm/enums/error-code.js.map

@@ -1 +1 @@
-{"version":3,"file":"error-code.js","sourceRoot":"","sources":["../../../src/enums/error-code.ts"],"names":[],"mappings":"AAAA,MAAM,CAAN,IAAY,SAQX;AARD,WAAY,SAAS;IACnB,wDAAgB,CAAA;IAChB,gEAAoB,CAAA;IACpB,4DAAkB,CAAA;IAClB,8EAA2B,CAAA;IAC3B,oEAAsB,CAAA;IACtB,gEAAoB,CAAA;IACpB,oFAA8B,CAAA;AAChC,CAAC,EARW,SAAS,KAAT,SAAS,QAQpB"}
+{"version":3,"file":"error-code.js","sourceRoot":"","sources":["../../../src/enums/error-code.ts"],"names":[],"mappings":"AAAA,MAAM,CAAN,IAAY,SASX;AATD,WAAY,SAAS;IACnB,wDAAgB,CAAA;IAChB,gEAAoB,CAAA;IACpB,4DAAkB,CAAA;IAClB,8EAA2B,CAAA;IAC3B,oEAAsB,CAAA;IACtB,gEAAoB,CAAA;IACpB,oFAA8B,CAAA;IAC9B,kFAA6B,CAAA;AAC/B,CAAC,EATW,SAAS,KAAT,SAAS,QASpB"}

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

@@ -18,6 +18,7 @@ export interface JobJson {
     parentKey?: string;
     repeatJobKey?: string;
     debounceId?: string;
+    deduplicationId?: string;
     processedBy?: string;
 }
 export interface JobJsonRaw {

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

@@ -22,7 +22,7 @@ const content = `--[[
             [7]  parent dependencies key.
             [8]  parent? {id, queueKey}
             [9]  repeat job key
-            [10] debounce key
+            [10] deduplication key
       ARGV[2] Json stringified job data
       ARGV[3] msgpacked options
       Output:
@@ -42,7 +42,7 @@ local data = ARGV[2]
 local parentKey = args[5]
 local parent = args[8]
 local repeatJobKey = args[9]
-local debounceKey = args[10]
+local deduplicationKey = args[10]
 local parentData
 -- Includes
 --[[
@@ -72,20 +72,22 @@ 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
+local function deduplicateJob(prefixKey, deduplicationOpts, jobId, deduplicationKey, eventsKey, maxEvents)
+  local deduplicationId = deduplicationOpts and deduplicationOpts['id']
+  if deduplicationId then
+    local ttl = deduplicationOpts['ttl']
+    local deduplicationKeyExists
     if ttl then
-      debounceKeyExists = not rcall('SET', debounceKey, jobId, 'PX', ttl, 'NX')
+      deduplicationKeyExists = not rcall('SET', deduplicationKey, jobId, 'PX', ttl, 'NX')
     else
-      debounceKeyExists = not rcall('SET', debounceKey, jobId, 'NX')
+      deduplicationKeyExists = not rcall('SET', deduplicationKey, jobId, 'NX')
     end
-    if debounceKeyExists then
-      local currentDebounceJobId = rcall('GET', debounceKey)
+    if deduplicationKeyExists then
+      local currentDebounceJobId = rcall('GET', deduplicationKey)
       rcall("XADD", eventsKey, "MAXLEN", "~", maxEvents, "*", "event",
-        "debounced", "jobId", currentDebounceJobId, "debounceId", debounceId)
+        "debounced", "jobId", currentDebounceJobId, "debounceId", deduplicationId)
+      rcall("XADD", eventsKey, "MAXLEN", "~", maxEvents, "*", "event",
+        "deduplicated", "jobId", currentDebounceJobId, "deduplicationId", deduplicationId)
       return currentDebounceJobId
     end
   end
@@ -338,10 +340,10 @@ else
             maxEvents, timestamp)
     end
 end
-local debouncedJobId = debounceJob(args[1], opts['de'],
-  jobId, debounceKey, eventsKey, maxEvents)
-if debouncedJobId then
-  return debouncedJobId
+local deduplicationJobId = deduplicateJob(args[1], opts['de'],
+  jobId, deduplicationKey, eventsKey, maxEvents)
+if deduplicationJobId then
+  return deduplicationJobId
 end
 -- Store the job.
 local delay, priority = storeJob(eventsKey, jobIdKey, jobId, args[3], ARGV[2],

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyWf,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2Wf,CAAC;AACF,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,IAAI,EAAE,eAAe;IACrB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}