bullmq 5.15.0 → 5.17.0

package/dist/cjs/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/cjs/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/cjs/enums/error-code.js

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

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

@@ -1 +1 @@
-{"version":3,"file":"error-code.js","sourceRoot":"","sources":["../../../src/enums/error-code.ts"],"names":[],"mappings":";;;AAAA,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,GAAT,iBAAS,KAAT,iBAAS,QAQpB"}
+{"version":3,"file":"error-code.js","sourceRoot":"","sources":["../../../src/enums/error-code.ts"],"names":[],"mappings":";;;AAAA,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,GAAT,iBAAS,KAAT,iBAAS,QASpB"}

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

@@ -25,7 +25,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:
@@ -45,7 +45,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
 --[[
@@ -75,20 +75,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
@@ -341,10 +343,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/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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyWf,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2Wf,CAAC;AACW,QAAA,aAAa,GAAG;IAC3B,IAAI,EAAE,eAAe;IACrB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

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

@@ -0,0 +1,223 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addJobScheduler = void 0;
+const content = `--[[
+  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
+--[[
+  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.
+]]
+local function removeJobKeys(jobKey)
+  return rcall("DEL", jobKey, jobKey .. ':logs',
+    jobKey .. ':dependencies', jobKey .. ':processed', jobKey .. ':failed')
+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"
+  which requires code from "moveToFinished"
+]]
+-- Includes
+--[[
+  Function to add job in target list and add marker if needed.
+]]
+-- Includes
+--[[
+  Add marker if needed when a job is available.
+]]
+local function addBaseMarkerIfNeeded(markerKey, isPausedOrMaxed)
+  if not isPausedOrMaxed then
+    rcall("ZADD", markerKey, 0, "0")
+  end  
+end
+local function addJobInTargetList(targetKey, markerKey, pushCmd, isPausedOrMaxed, jobId)
+  rcall(pushCmd, targetKey, jobId)
+  addBaseMarkerIfNeeded(markerKey, isPausedOrMaxed)
+end
+--[[
+  Functions to destructure job key.
+  Just a bit of warning, these functions may be a bit slow and affect performance significantly.
+]]
+local getJobIdFromKey = function (jobKey)
+  return string.match(jobKey, ".*:(.*)")
+end
+local getJobKeyPrefix = function (jobKey, jobId)
+  return string.sub(jobKey, 0, #jobKey - #jobId)
+end
+--[[
+  Function to check for the meta.paused key to decide if we are paused or not
+  (since an empty list and !EXISTS are not really the same).
+]]
+local function getTargetQueueList(queueMetaKey, activeKey, waitKey, pausedKey)
+  local queueAttributes = rcall("HMGET", queueMetaKey, "paused", "concurrency")
+  if queueAttributes[1] then
+    return pausedKey, true
+  else
+    if queueAttributes[2] then
+      local activeCount = rcall("LLEN", activeKey)
+      if activeCount >= tonumber(queueAttributes[2]) then
+        return waitKey, true
+      else
+        return waitKey, false
+      end
+    end
+  end
+  return waitKey, false
+end
+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)
+  if emitEvent then
+    local parentEventStream = parentPrefix .. "events"
+    rcall("XADD", parentEventStream, "*", "event", "waiting", "jobId", parentId, "prev", "waiting-children")
+  end
+end
+local function removeParentDependencyKey(jobKey, hard, parentKey, baseKey, debounceId)
+  if parentKey then
+    local parentDependenciesKey = parentKey .. ":dependencies"
+    local result = rcall("SREM", parentDependenciesKey, jobKey)
+    if result > 0 then
+      local pendingDependencies = rcall("SCARD", parentDependenciesKey)
+      if pendingDependencies == 0 then
+        local parentId = getJobIdFromKey(parentKey)
+        local parentPrefix = getJobKeyPrefix(parentKey, parentId)
+        local numRemovedElements = rcall("ZREM", parentPrefix .. "waiting-children", parentId)
+        if numRemovedElements == 1 then
+          if hard then -- remove parent in same queue
+            if parentPrefix == baseKey then
+              removeParentDependencyKey(parentKey, hard, nil, baseKey, nil)
+              removeJobKeys(parentKey)
+              if debounceId then
+                rcall("DEL", parentPrefix .. "de:" .. debounceId)
+              end
+            else
+              moveParentToWait(parentPrefix, parentId)
+            end
+          else
+            moveParentToWait(parentPrefix, parentId, true)
+          end
+        end
+      end
+      return true
+    end
+  else
+    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"
+      local result = rcall("SREM", parentDependenciesKey, jobKey)
+      if result > 0 then
+        local pendingDependencies = rcall("SCARD", parentDependenciesKey)
+        if pendingDependencies == 0 then
+          local parentId = getJobIdFromKey(missedParentKey)
+          local parentPrefix = getJobKeyPrefix(missedParentKey, parentId)
+          local numRemovedElements = rcall("ZREM", parentPrefix .. "waiting-children", parentId)
+          if numRemovedElements == 1 then
+            if hard then
+              if parentPrefix == baseKey then
+                removeParentDependencyKey(missedParentKey, hard, nil, baseKey, nil)
+                removeJobKeys(missedParentKey)
+                if parentAttributes[2] then
+                  rcall("DEL", parentPrefix .. "de:" .. parentAttributes[2])
+                end
+              else
+                moveParentToWait(parentPrefix, parentId)
+              end
+            else
+              moveParentToWait(parentPrefix, parentId, true)
+            end
+          end
+        end
+        return true
+      end
+    end
+  end
+  return false
+end
+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 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])
+`;
+exports.addJobScheduler = {
+    name: 'addJobScheduler',
+    content,
+    keys: 2,
+};
+//# sourceMappingURL=addJobScheduler-2.js.map

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

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

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

@@ -21,7 +21,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:
@@ -41,26 +41,28 @@ 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
 --[[
   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
@@ -312,10 +314,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.
 storeJob(eventsKey, jobIdKey, jobId, args[3], ARGV[2], opts, timestamp,

package/dist/cjs/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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwUf,CAAC;AACW,QAAA,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0Uf,CAAC;AACW,QAAA,YAAY,GAAG;IAC1B,IAAI,EAAE,cAAc;IACpB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

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

@@ -25,7 +25,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:
@@ -48,7 +48,7 @@ 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
 --[[
@@ -73,20 +73,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
@@ -319,10 +321,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/cjs/scripts/addPrioritizedJob-8.js.map

@@ -1 +1 @@
-{"version":3,"file":"addPrioritizedJob-8.js","sourceRoot":"","sources":["../../../src/scripts/addPrioritizedJob-8.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkVf,CAAC;AACW,QAAA,iBAAiB,GAAG;IAC/B,IAAI,EAAE,mBAAmB;IACzB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}
+{"version":3,"file":"addPrioritizedJob-8.js","sourceRoot":"","sources":["../../../src/scripts/addPrioritizedJob-8.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoVf,CAAC;AACW,QAAA,iBAAiB,GAAG;IAC/B,IAAI,EAAE,mBAAmB;IACzB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

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

@@ -34,7 +34,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:
@@ -51,7 +51,7 @@ 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
 --[[
@@ -73,20 +73,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
@@ -323,10 +325,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.
 storeJob(eventsKey, jobIdKey, jobId, args[3], ARGV[2], opts, timestamp,

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