bullmq 5.15.0 → 5.17.0

package/dist/cjs/scripts/{cleanJobsInSet-2.js → cleanJobsInSet-3.js}

@@ -6,6 +6,7 @@ const content = `--[[
   Input:
     KEYS[1]  set key,
     KEYS[2]  events stream key
+    KEYS[3]  job schedulers key
     ARGV[1]  jobKey prefix
     ARGV[2]  timestamp
     ARGV[3]  limit the number of jobs to be removed. 0 is unlimited
@@ -237,7 +238,7 @@ end
 --[[
   Function to clean job set.
   Returns jobIds and deleted count number.
-]]
+]] 
 -- Includes
 --[[
   Function to loop in batches.
@@ -268,54 +269,75 @@ local function getJobsInZset(zsetKey, rangeEnd, limit)
     return rcall("ZRANGEBYSCORE", zsetKey, 0, rangeEnd)
   end
 end
-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
-    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
+    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
+        -- 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
 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])
 return result[1]
@@ -323,6 +345,6 @@ return result[1]
 exports.cleanJobsInSet = {
     name: 'cleanJobsInSet',
     content,
-    keys: 2,
+    keys: 3,
 };
-//# sourceMappingURL=cleanJobsInSet-2.js.map
+//# sourceMappingURL=cleanJobsInSet-3.js.map

package/dist/cjs/scripts/{cleanJobsInSet-2.js.map → cleanJobsInSet-3.js.map}

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

package/dist/cjs/scripts/{drain-4.js → drain-5.js}

@@ -9,6 +9,7 @@ const content = `--[[
     KEYS[2] 'paused'
     KEYS[3] 'delayed'
     KEYS[4] 'prioritized'
+    KEYS[5] 'jobschedulers' (repeat)
     ARGV[1]  queue key prefix
 ]]
 local rcall = redis.call
@@ -212,8 +213,18 @@ end
 local function getZSetItems(keyName, max)
   return rcall('ZRANGE', keyName, 0, max - 1)
 end
-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
@@ -222,16 +233,26 @@ local function removeZSetJobs(keyName, hard, baseKey, max)
   end
   return count
 end
-removeListJobs(KEYS[1], true, queueBaseKey, 0) --wait
-removeListJobs(KEYS[2], true, queueBaseKey, 0) --paused
+removeListJobs(KEYS[1], true, queueBaseKey, 0) -- wait
+removeListJobs(KEYS[2], true, queueBaseKey, 0) -- paused
 if KEYS[3] ~= "" then
-  removeZSetJobs(KEYS[3], true, queueBaseKey, 0) --delayed
+    -- 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
+removeZSetJobs(KEYS[4], true, queueBaseKey, 0) -- prioritized
 `;
 exports.drain = {
     name: 'drain',
     content,
-    keys: 4,
+    keys: 5,
 };
-//# sourceMappingURL=drain-4.js.map
+//# sourceMappingURL=drain-5.js.map

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

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

package/dist/cjs/scripts/index.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./addDelayedJob-6"), exports);
+tslib_1.__exportStar(require("./addJobScheduler-2"), exports);
 tslib_1.__exportStar(require("./addLog-2"), exports);
 tslib_1.__exportStar(require("./addParentJob-4"), exports);
 tslib_1.__exportStar(require("./addPrioritizedJob-8"), exports);
@@ -9,8 +10,8 @@ tslib_1.__exportStar(require("./addRepeatableJob-2"), exports);
 tslib_1.__exportStar(require("./addStandardJob-8"), exports);
 tslib_1.__exportStar(require("./changeDelay-4"), exports);
 tslib_1.__exportStar(require("./changePriority-7"), exports);
-tslib_1.__exportStar(require("./cleanJobsInSet-2"), exports);
-tslib_1.__exportStar(require("./drain-4"), exports);
+tslib_1.__exportStar(require("./cleanJobsInSet-3"), exports);
+tslib_1.__exportStar(require("./drain-5"), exports);
 tslib_1.__exportStar(require("./extendLock-2"), exports);
 tslib_1.__exportStar(require("./getCounts-1"), exports);
 tslib_1.__exportStar(require("./getCountsPerPriority-4"), exports);
@@ -35,6 +36,7 @@ tslib_1.__exportStar(require("./promote-9"), exports);
 tslib_1.__exportStar(require("./releaseLock-1"), exports);
 tslib_1.__exportStar(require("./removeChildDependency-1"), exports);
 tslib_1.__exportStar(require("./removeJob-2"), exports);
+tslib_1.__exportStar(require("./removeJobScheduler-3"), exports);
 tslib_1.__exportStar(require("./removeRepeatable-3"), exports);
 tslib_1.__exportStar(require("./reprocessJob-8"), exports);
 tslib_1.__exportStar(require("./retryJob-11"), exports);

package/dist/cjs/scripts/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/scripts/index.ts"],"names":[],"mappings":";;;AAAA,4DAAkC;AAClC,qDAA2B;AAC3B,2DAAiC;AACjC,gEAAsC;AACtC,+DAAqC;AACrC,6DAAmC;AACnC,0DAAgC;AAChC,6DAAmC;AACnC,6DAAmC;AACnC,oDAA0B;AAC1B,yDAA+B;AAC/B,wDAA8B;AAC9B,mEAAyC;AACzC,wDAA8B;AAC9B,8DAAoC;AACpC,uDAA6B;AAC7B,yDAA+B;AAC/B,yDAA+B;AAC/B,0DAAgC;AAChC,sDAA4B;AAC5B,uEAA6C;AAC7C,6DAAmC;AACnC,oEAA0C;AAC1C,4DAAkC;AAClC,4DAAkC;AAClC,8DAAoC;AACpC,oEAA0C;AAC1C,yDAA+B;AAC/B,uDAA6B;AAC7B,oDAA0B;AAC1B,sDAA4B;AAC5B,0DAAgC;AAChC,oEAA0C;AAC1C,wDAA8B;AAC9B,+DAAqC;AACrC,2DAAiC;AACjC,wDAA8B;AAC9B,6DAAmC;AACnC,yDAA+B;AAC/B,6DAAmC;AACnC,wEAA8C"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/scripts/index.ts"],"names":[],"mappings":";;;AAAA,4DAAkC;AAClC,8DAAoC;AACpC,qDAA2B;AAC3B,2DAAiC;AACjC,gEAAsC;AACtC,+DAAqC;AACrC,6DAAmC;AACnC,0DAAgC;AAChC,6DAAmC;AACnC,6DAAmC;AACnC,oDAA0B;AAC1B,yDAA+B;AAC/B,wDAA8B;AAC9B,mEAAyC;AACzC,wDAA8B;AAC9B,8DAAoC;AACpC,uDAA6B;AAC7B,yDAA+B;AAC/B,yDAA+B;AAC/B,0DAAgC;AAChC,sDAA4B;AAC5B,uEAA6C;AAC7C,6DAAmC;AACnC,oEAA0C;AAC1C,4DAAkC;AAClC,4DAAkC;AAClC,8DAAoC;AACpC,oEAA0C;AAC1C,yDAA+B;AAC/B,uDAA6B;AAC7B,oDAA0B;AAC1B,sDAA4B;AAC5B,0DAAgC;AAChC,oEAA0C;AAC1C,wDAA8B;AAC9B,iEAAuC;AACvC,+DAAqC;AACrC,2DAAiC;AACjC,wDAA8B;AAC9B,6DAAmC;AACnC,yDAA+B;AAC/B,6DAAmC;AACnC,wEAA8C"}

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

@@ -393,7 +393,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]
@@ -407,7 +407,6 @@ local stalled = {}
 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.
@@ -424,7 +423,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/cjs/scripts/moveStalledJobsToWait-9.js.map

@@ -1 +1 @@
-{"version":3,"file":"moveStalledJobsToWait-9.js","sourceRoot":"","sources":["../../../src/scripts/moveStalledJobsToWait-9.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBA4fS,CAAC;AACb,QAAA,qBAAqB,GAAG;IACnC,IAAI,EAAE,uBAAuB;IAC7B,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}
+{"version":3,"file":"moveStalledJobsToWait-9.js","sourceRoot":"","sources":["../../../src/scripts/moveStalledJobsToWait-9.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBA2fS,CAAC;AACb,QAAA,qBAAqB,GAAG;IACnC,IAAI,EAAE,uBAAuB;IAC7B,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

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

@@ -218,8 +218,18 @@ end
 local function getZSetItems(keyName, max)
   return rcall('ZRANGE', keyName, 0, max - 1)
 end
-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/cjs/scripts/obliterate-2.js.map

@@ -1 +1 @@
-{"version":3,"file":"obliterate-2.js","sourceRoot":"","sources":["../../../src/scripts/obliterate-2.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmTf,CAAC;AACW,QAAA,UAAU,GAAG;IACxB,IAAI,EAAE,YAAY;IAClB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}
+{"version":3,"file":"obliterate-2.js","sourceRoot":"","sources":["../../../src/scripts/obliterate-2.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6Tf,CAAC;AACW,QAAA,UAAU,GAAG;IACxB,IAAI,EAAE,YAAY;IAClB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

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

@@ -228,20 +228,20 @@ local function removeParentDependencyKey(jobKey, hard, parentKey, baseKey, debou
   end
   return false
 end
-local function removeJob( prefix, jobId, parentKey, removeChildren)
+local function removeJob(prefix, jobId, parentKey, removeChildren)
     local jobKey = prefix .. jobId;
     removeParentDependencyKey(jobKey, false, parentKey, nil)
     if removeChildren == "1" then
         -- 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
         local dependencies = rcall("SMEMBERS", jobKey .. ":dependencies")
@@ -250,7 +250,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
         local failed = rcall("HGETALL", jobKey .. ":failed")
@@ -258,7 +258,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
@@ -266,13 +266,20 @@ 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]
-if not isLocked(prefix, ARGV[1], ARGV[2]) then
-    removeJob(prefix, ARGV[1], nil, ARGV[2])
+local jobId = ARGV[1]
+local shouldRemoveChildren = ARGV[2]
+local jobKey = prefix .. jobId
+-- 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/scripts/removeJob-2.js.map

@@ -1 +1 @@
-{"version":3,"file":"removeJob-2.js","sourceRoot":"","sources":["../../../src/scripts/removeJob-2.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmRf,CAAC;AACW,QAAA,SAAS,GAAG;IACvB,IAAI,EAAE,WAAW;IACjB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}
+{"version":3,"file":"removeJob-2.js","sourceRoot":"","sources":["../../../src/scripts/removeJob-2.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0Rf,CAAC;AACW,QAAA,SAAS,GAAG;IACvB,IAAI,EAAE,WAAW;IACjB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

package/dist/cjs/scripts/removeJobScheduler-3.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeJobScheduler = void 0;
+const content = `--[[
+  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
+--[[
+  Function to remove job keys.
+]]
+local function removeJobKeys(jobKey)
+  return rcall("DEL", jobKey, jobKey .. ':logs',
+    jobKey .. ':dependencies', jobKey .. ':processed', jobKey .. ':failed')
+end
+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
+`;
+exports.removeJobScheduler = {
+    name: 'removeJobScheduler',
+    content,
+    keys: 3,
+};
+//# sourceMappingURL=removeJobScheduler-3.js.map

package/dist/cjs/scripts/removeJobScheduler-3.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"removeJobScheduler-3.js","sourceRoot":"","sources":["../../../src/scripts/removeJobScheduler-3.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuCf,CAAC;AACW,QAAA,kBAAkB,GAAG;IAChC,IAAI,EAAE,oBAAoB;IAC1B,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}