bullmq 5.15.0 → 5.16.0

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/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/scripts/addJobScheduler-2.d.ts

@@ -0,0 +1,5 @@
+export declare const addJobScheduler: {
+    name: string;
+    content: string;
+    keys: number;
+};

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

@@ -0,0 +1,220 @@
+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])
+`;
+export const addJobScheduler = {
+    name: 'addJobScheduler',
+    content,
+    keys: 2,
+};
+//# sourceMappingURL=addJobScheduler-2.js.map

package/dist/esm/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;AACF,MAAM,CAAC,MAAM,eAAe,GAAG;IAC7B,IAAI,EAAE,iBAAiB;IACvB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}