bullmq 2.2.0 → 2.3.0

package/dist/{cjs/commands/reprocessJob-4.lua → esm/scripts/reprocessJob-4.js}

@@ -1,17 +1,14 @@
---[[
+const content = `--[[
   Attempts to reprocess a job
-
   Input:
     KEYS[1] job key
     KEYS[2] events stream
     KEYS[3] job state
     KEYS[4] wait key
-
     ARGV[1] job.id
     ARGV[2] (job.opts.lifo ? 'R' : 'L') + 'PUSH'
     ARGV[3] propVal - failedReason/returnvalue
     ARGV[4] prev state - failed/completed
-
   Output:
     1  means the operation was a success
     -1 means the job does not exist
@@ -23,7 +20,6 @@ if (rcall("EXISTS", KEYS[1]) == 1) then
   if (rcall("ZREM", KEYS[3], jobId) == 1) then
     rcall(ARGV[2], KEYS[4], jobId)
     rcall("HDEL", KEYS[1], "finishedOn", "processedOn", ARGV[3])
-
     -- Emit waiting event
     rcall("XADD", KEYS[2], "*", "event", "waiting", "jobId", jobId, "prev", ARGV[4]);
     return 1
@@ -33,3 +29,10 @@ if (rcall("EXISTS", KEYS[1]) == 1) then
 else
   return -1
 end
+`;
+export const reprocessJob = {
+    name: 'reprocessJob',
+    content,
+    keys: 4,
+};
+//# sourceMappingURL=reprocessJob-4.js.map

package/dist/esm/scripts/reprocessJob-4.js.map

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

package/dist/esm/scripts/retryJob-6.d.ts

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

package/dist/{cjs/commands/retryJob-6.lua → esm/scripts/retryJob-6.js}

@@ -1,6 +1,5 @@
---[[
+const content = `--[[
   Retries a failed job by moving it back to the wait queue.
-
     Input:
       KEYS[1] 'active',
       KEYS[2] 'wait'
@@ -8,26 +7,30 @@
       KEYS[4] job key
       KEYS[5] 'meta'
       KEYS[6] events stream
-
       ARGV[1]  pushCmd
       ARGV[2]  jobId
       ARGV[3]  token
-
     Events:
       'waiting'
-
     Output:
      0  - OK
      -1 - Missing key
      -2 - Missing lock
 ]]
 local rcall = redis.call
-
 -- Includes
---- @include "includes/getTargetQueueList"
-
+--[[
+  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, waitKey, pausedKey)
+  if rcall("HEXISTS", queueMetaKey, "paused") ~= 1 then
+    return waitKey
+  else
+    return pausedKey
+  end
+end
 if rcall("EXISTS", KEYS[4]) == 1 then
-
   if ARGV[3] ~= "0" then
     local lockKey = KEYS[4] .. ':lock'
     if rcall("GET", lockKey) == ARGV[3] then
@@ -36,16 +39,19 @@ if rcall("EXISTS", KEYS[4]) == 1 then
       return -2
     end
   end
-
   local target = getTargetQueueList(KEYS[5], KEYS[2], KEYS[3])
-
   rcall("LREM", KEYS[1], 0, ARGV[2])
   rcall(ARGV[1], target, ARGV[2])
-
   -- Emit waiting event
   rcall("XADD", KEYS[6], "*", "event", "waiting", "jobId", ARGV[2], "prev", "failed");
-  
   return 0
 else
   return -1
 end
+`;
+export const retryJob = {
+    name: 'retryJob',
+    content,
+    keys: 6,
+};
+//# sourceMappingURL=retryJob-6.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"retryJob-6.js","sourceRoot":"","sources":["../../../src/scripts/retryJob-6.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkDf,CAAC;AACF,MAAM,CAAC,MAAM,QAAQ,GAAG;IACtB,IAAI,EAAE,UAAU;IAChB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

package/dist/esm/scripts/retryJobs-6.d.ts

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

package/dist/esm/{commands/retryJobs-6.lua → scripts/retryJobs-6.js}

@@ -1,6 +1,5 @@
---[[
+const content = `--[[
   Attempts to retry all failed jobs
-
   Input:
     KEYS[1] base key
     KEYS[2] events stream
@@ -8,46 +7,67 @@
     KEYS[4] 'wait'
     KEYS[5] 'paused'
     KEYS[6] 'meta'
-
     ARGV[1] count
     ARGV[2] timestamp
     ARGV[3] prev state
-
   Output:
     1  means the operation is not completed
     0  means the operation is completed
 ]]
 local maxCount = tonumber(ARGV[1])
 local timestamp = tonumber(ARGV[2])
-
 local rcall = redis.call;
-
 -- Includes
---- @include "includes/batches"
---- @include "includes/getTargetQueueList"
-
+--[[
+  Function to loop in batches.
+  Just a bit of warning, some commands as ZREM
+  could receive a maximum of 7000 parameters per call.
+]]
+local function batches(n, batchSize)
+  local i = 0
+  return function()
+    local from = i * batchSize + 1
+    i = i + 1
+    if (from <= n) then
+      local to = math.min(from + batchSize - 1, n)
+      return from, to
+    end
+  end
+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, waitKey, pausedKey)
+  if rcall("HEXISTS", queueMetaKey, "paused") ~= 1 then
+    return waitKey
+  else
+    return pausedKey
+  end
+end
 local target = getTargetQueueList(KEYS[6], KEYS[4], KEYS[5])
-
 local jobs = rcall('ZRANGEBYSCORE', KEYS[3], 0, timestamp, 'LIMIT', 0, maxCount)
 if (#jobs > 0) then
   for i, key in ipairs(jobs) do
     local jobKey = KEYS[1] .. key
     rcall("HDEL", jobKey, "finishedOn", "processedOn", "failedReason", "returnvalue")
-
     -- Emit waiting event
     rcall("XADD", KEYS[2], "*", "event", "waiting", "jobId", key, "prev", ARGV[3]);
   end
-
   for from, to in batches(#jobs, 7000) do
     rcall("ZREM", KEYS[3], unpack(jobs, from, to))
     rcall("LPUSH", target, unpack(jobs, from, to))
   end
 end
-
 maxCount = maxCount - #jobs
-
 if(maxCount <= 0) then
   return 1
 end
-
 return 0
+`;
+export const retryJobs = {
+    name: 'retryJobs',
+    content,
+    keys: 6,
+};
+//# sourceMappingURL=retryJobs-6.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"retryJobs-6.js","sourceRoot":"","sources":["../../../src/scripts/retryJobs-6.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkEf,CAAC;AACF,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,IAAI,EAAE,WAAW;IACjB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

package/dist/esm/scripts/takeLock-1.d.ts

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

package/dist/esm/{commands/takeLock-1.lua → scripts/takeLock-1.js}

@@ -1,12 +1,9 @@
---[[
+const content = `--[[
   Takes a lock
-
      Input:
         KEYS[1] 'lock',
-      
         ARGV[1]  token
         ARGV[2]  lock duration in milliseconds
-      
       Output:
         "OK" if lock extented succesfully.
 ]]
@@ -15,3 +12,10 @@ if redis.call("SET", KEYS[1], ARGV[1], "NX", "PX", ARGV[2]) then
 else
   return 0
 end
+`;
+export const takeLock = {
+    name: 'takeLock',
+    content,
+    keys: 1,
+};
+//# sourceMappingURL=takeLock-1.js.map

package/dist/esm/scripts/takeLock-1.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"takeLock-1.js","sourceRoot":"","sources":["../../../src/scripts/takeLock-1.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;CAcf,CAAC;AACF,MAAM,CAAC,MAAM,QAAQ,GAAG;IACtB,IAAI,EAAE,UAAU;IAChB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

package/dist/esm/scripts/updateData-1.d.ts

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

package/dist/esm/{commands/updateData-1.lua → scripts/updateData-1.js}

@@ -1,16 +1,20 @@
---[[
+const content = `--[[
   Update job data
-
   Input:
     KEYS[1] Job id key
-  
     ARGV[1] data        
 ]]
 local rcall = redis.call
-
 if rcall("EXISTS",KEYS[1]) == 1 then -- // Make sure job exists
   rcall("HSET", KEYS[1], "data", ARGV[1])
   return 0
 else
   return -1
 end
+`;
+export const updateData = {
+    name: 'updateData',
+    content,
+    keys: 1,
+};
+//# sourceMappingURL=updateData-1.js.map

package/dist/esm/scripts/updateData-1.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"updateData-1.js","sourceRoot":"","sources":["../../../src/scripts/updateData-1.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;CAaf,CAAC;AACF,MAAM,CAAC,MAAM,UAAU,GAAG;IACxB,IAAI,EAAE,YAAY;IAClB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

package/dist/esm/scripts/updateProgress-2.d.ts

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

package/dist/{cjs/commands/updateProgress-2.lua → esm/scripts/updateProgress-2.js}

@@ -1,18 +1,14 @@
---[[
+const content = `--[[
   Update job progress
-
   Input:
     KEYS[1] Job id key
     KEYS[2] event stream key
-  
     ARGV[1] id
     ARGV[2] progress
-    
   Event:
     progress(jobId, progress)
 ]]
 local rcall = redis.call
-
 if rcall("EXISTS",KEYS[1]) == 1 then -- // Make sure job exists
   rcall("HSET", KEYS[1], "progress", ARGV[2])
   rcall("XADD", KEYS[2], "*", "event", "progress", "jobId", ARGV[1], "data", ARGV[2]);
@@ -20,3 +16,10 @@ if rcall("EXISTS",KEYS[1]) == 1 then -- // Make sure job exists
 else
   return -1
 end
+`;
+export const updateProgress = {
+    name: 'updateProgress',
+    content,
+    keys: 2,
+};
+//# sourceMappingURL=updateProgress-2.js.map

package/dist/esm/scripts/updateProgress-2.js.map

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bullmq",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "description": "Queue for messages and jobs based on Redis",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",
@@ -19,7 +19,7 @@
     "dist"
   ],
   "scripts": {
-    "build": "npm-run-all tsc:all copy:lua copy:includes:lua clean:temp:files",
+    "build": "npm-run-all pretest tsc:all clean:temp:files",
     "clean:temp:files": "rimraf dist/cjs/bullmq.d.ts dist/esm/bullmq.d.ts dist/tsdoc-metadata.json",
     "copy:lua": "copyfiles -f ./src/commands/*.lua ./dist/cjs/commands && copyfiles -f ./src/commands/*.lua ./dist/esm/commands",
     "copy:includes:lua": "copyfiles -f ./src/commands/includes/*.lua ./dist/cjs/commands/includes && copyfiles -f ./src/commands/includes/*.lua ./dist/esm/commands/includes",
@@ -39,6 +39,8 @@
     "pretty:quick": "pretty-quick --ignore-path ./.eslintignore --staged",
     "semantic-release": "semantic-release",
     "semantic-release-prepare": "ts-node tools/semantic-release-prepare",
+    "transform:commands": "node ./commandTransform.js ./rawScripts ./src/scripts",
+    "pretest": "npm-run-all generate:raw:scripts transform:commands",
     "test": "ts-mocha -p tsconfig-cjs.json --config ./.mocharc.js",
     "test:watch": "ts-mocha -p tsconfig-cjs.json --paths 'tests/test_*.ts' -w --watch-extensions ts",
     "tsc": "tsc",

package/dist/cjs/commands/cleanJobsInSet-2.lua

@@ -1,46 +0,0 @@
---[[
-  Remove jobs from the specific set.
-
-  Input:
-    KEYS[1]  set key,
-    KEYS[2]  events stream key
-
-    ARGV[1]  jobKey prefix
-    ARGV[2]  timestamp
-    ARGV[3]  limit the number of jobs to be removed. 0 is unlimited
-    ARGV[4]  set name, can be any of 'wait', 'active', 'paused', 'delayed', 'completed', or 'failed'
-]]
-local rcall = redis.call
-local rangeStart = 0
-local rangeEnd = -1
-
-local limit = tonumber(ARGV[3])
-
--- If we're only deleting _n_ items, avoid retrieving all items
--- for faster performance
---
--- Start from the tail of the list, since that's where oldest elements
--- are generally added for FIFO lists
-if limit > 0 then
-  rangeStart = -1 - limit + 1
-  rangeEnd = -1
-end
-
--- Includes
---- @include "includes/cleanList"
---- @include "includes/cleanSet"
-
-local result
-if ARGV[4] == "active" then
-  result = cleanList(KEYS[1], ARGV[1], rangeStart, rangeEnd, ARGV[2], false)
-elseif ARGV[4] == "delayed" then
-  result = cleanSet(KEYS[1], ARGV[1], rangeStart, rangeEnd, ARGV[2], limit, {"processedOn", "timestamp"})
-elseif ARGV[4] == "wait" or ARGV[4] == "paused" then
-  result = cleanList(KEYS[1], ARGV[1], rangeStart, rangeEnd, ARGV[2], true)
-else
-  result = cleanSet(KEYS[1], ARGV[1], rangeStart, rangeEnd, ARGV[2], limit, {"finishedOn"} )
-end
-
-rcall("XADD", KEYS[2], "*", "event", "cleaned", "count", result[2])
-
-return result[1]

package/dist/cjs/commands/drain-4.lua

@@ -1,25 +0,0 @@
---[[
-  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] 'priority'
-
-    ARGV[1]  queue key prefix
-]]
-local rcall = redis.call
-local queueBaseKey = ARGV[1]
-
---- @include "includes/removeJobs"
-
-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
-end
-
-rcall("DEL", KEYS[4])

package/dist/cjs/commands/includes/addJobWithPriority.lua

@@ -1,16 +0,0 @@
---[[
-  Function to add job considering priority.
-]]
-
-local function addJobWithPriority(priorityKey, priority, targetKey, jobId)
-  rcall("ZADD", priorityKey, priority, jobId)
-  local count = rcall("ZCOUNT", priorityKey, 0, priority)
-
-  local len = rcall("LLEN", targetKey)
-  local id = rcall("LINDEX", targetKey, len - (count - 1))
-  if id then
-    rcall("LINSERT", targetKey, "BEFORE", id, jobId)
-  else
-    rcall("RPUSH", targetKey, jobId)
-  end
-end

package/dist/cjs/commands/includes/batches.lua

@@ -1,18 +0,0 @@
---[[
-  Function to loop in batches.
-  Just a bit of warning, some commands as ZREM
-  could receive a maximum of 7000 parameters per call.
-]]
-
-local function batches(n, batchSize)
-  local i = 0
-
-  return function()
-    local from = i * batchSize + 1
-    i = i + 1
-    if (from <= n) then
-      local to = math.min(from + batchSize - 1, n)
-      return from, to
-    end
-  end
-end

package/dist/cjs/commands/includes/checkItemInList.lua

@@ -1,12 +0,0 @@
---[[
-  Functions to check if a item belongs to a list.
-]]
-
-local function checkItemInList(list, item)
-  for _, v in pairs(list) do
-    if v == item then
-      return 1
-    end
-  end
-  return nil
-end

package/dist/cjs/commands/includes/checkStalledJobs.lua

@@ -1,137 +0,0 @@
---[[
-  Move stalled jobs to wait.
-
-    Input:
-      stalledKey 'stalled' (SET)
-      waitKey 'wait',   (LIST)
-      activeKey 'active', (LIST)
-      failedKey 'failed', (ZSET)
-      stalledCheckKey 'stalled-check', (KEY)
-      metaKey 'meta', (KEY)
-      pausedKey 'paused', (LIST)
-      eventStreamKey 'event stream' (STREAM)
-
-      maxStalledJobCount  Max stalled job count
-      queueKeyPrefix  queue.toKey('')
-      timestamp  timestamp
-      maxCheckTime  max check time
-
-    Events:
-      'stalled' with stalled job id.
-]] local rcall = redis.call
-
--- Includes
---- @include "batches"
---- @include "getTargetQueueList"
---- @include "removeJob"
---- @include "removeJobsByMaxAge"
---- @include "removeJobsByMaxCount"
---- @include "trimEvents"
-
--- Check if we need to check for stalled jobs now.
-
-local function checkStalledJobs(stalledKey, waitKey, activeKey, failedKey, stalledCheckKey,
-    metaKey, pausedKey, eventStreamKey, maxStalledJobCount, queueKeyPrefix, timestamp, maxCheckTime)
-    if rcall("EXISTS", stalledCheckKey) == 1 then 
-        return {{}, {}}
-    end
-
-    rcall("SET", stalledCheckKey, timestamp, "PX", maxCheckTime)
-
-    -- Trim events before emiting them to avoid trimming events emitted in this script
-    trimEvents(metaKey, eventStreamKey)
-
-    -- Move all stalled jobs to wait
-    local stalling = rcall('SMEMBERS', stalledKey)
-    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
-
-            if jobId == '0' then
-                -- If the jobId is a delay marker ID we just remove it.
-                local removed = rcall("LREM", activeKey, 1, jobId)
-            else
-                local jobKey = queueKeyPrefix .. jobId
-
-                -- Check that the lock is also missing, then we can handle this job as really stalled.
-                if (rcall("EXISTS", jobKey .. ":lock") == 0) then
-                    --  Remove from the active queue.
-                    local removed = rcall("LREM", activeKey, 1, jobId)
-
-                    if (removed > 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
-                            local rawOpts = rcall("HGET", jobKey, "opts")
-                            local opts = cjson.decode(rawOpts)
-                            local removeOnFailType = type(opts["removeOnFail"])
-                            rcall("ZADD", failedKey, timestamp, jobId)
-                            local failedReason =
-                                "job stalled more than allowable limit"
-                            rcall("HMSET", jobKey, "failedReason", failedReason,
-                                "finishedOn", timestamp)
-                            rcall("XADD", eventStreamKey, "*", "event", "failed", "jobId",
-                                jobId, 'prev', 'active', 'failedReason',
-                                failedReason)
-
-                            if removeOnFailType == "number" then
-                                removeJobsByMaxCount(opts["removeOnFail"], failedKey,
-                                                    queueKeyPrefix)
-                            elseif removeOnFailType == "boolean" then
-                                if opts["removeOnFail"] then
-                                    removeJob(jobId, false, queueKeyPrefix)
-                                    rcall("ZREM", failedKey, jobId)
-                                end
-                            elseif removeOnFailType ~= "nil" then
-                                local maxAge = opts["removeOnFail"]["age"]
-                                local maxCount = opts["removeOnFail"]["count"]
-
-                                if maxAge ~= nil then
-                                    removeJobsByMaxAge(timestamp, maxAge, failedKey,
-                                                    queueKeyPrefix)
-                                end
-
-                                if maxCount ~= nil and maxCount > 0 then
-                                    removeJobsByMaxCount(maxCount, failedKey, queueKeyPrefix)
-                                end
-                            end
-
-                            table.insert(failed, jobId)
-                        else
-                            local target = getTargetQueueList(metaKey, waitKey,
-                                                            pausedKey)
-
-                            -- Move the job back to the wait queue, to immediately be picked up by a waiting worker.
-                            rcall("RPUSH", target, jobId)
-                            rcall("XADD", eventStreamKey, "*", "event", "waiting", "jobId",
-                                jobId, 'prev', 'active')
-
-                            -- Emit the stalled event
-                            rcall("XADD", eventStreamKey, "*", "event", "stalled", "jobId",
-                                jobId)
-                            table.insert(stalled, jobId)
-                        end
-                    end
-                end
-            end
-        end
-    end
-
-    -- Mark potentially stalled jobs
-    local active = rcall('LRANGE', activeKey, 0, -1)
-
-    if (#active > 0) then
-        for from, to in batches(#active, 7000) do
-            rcall('SADD', stalledKey, unpack(active, from, to))
-        end
-    end
-
-    return {failed, stalled}
-end

package/dist/cjs/commands/includes/cleanList.lua

@@ -1,50 +0,0 @@
---[[
-  Function to clean job list.
-  Returns jobIds and deleted count number.
-]]
-
--- Includes
---- @include "getTimestamp"
---- @include "removeJob"
-
-local function cleanList(listKey, jobKeyPrefix, rangeStart, rangeEnd,
-  timestamp, isWaiting)
-  local jobs = rcall("LRANGE", listKey, rangeStart, rangeEnd)
-  local deleted = {}
-  local deletedCount = 0
-  local jobTS
-  local deletionMarker = ''
-  local jobIdsLen = #jobs
-  for i, job in ipairs(jobs) do
-    if limit > 0 and deletedCount >= limit then
-      break
-    end
-  
-    local jobKey = jobKeyPrefix .. job
-    if (isWaiting or rcall("EXISTS", jobKey .. ":lock") == 0) then
-      -- Find the right timestamp of the job to compare to maxTimestamp:
-      -- * finishedOn says when the job was completed, but it isn't set unless the job has actually completed
-      -- * processedOn represents when the job was last attempted, but it doesn't get populated until
-      --   the job is first tried
-      -- * timestamp is the original job submission time
-      -- Fetch all three of these (in that order) and use the first one that is set so that we'll leave jobs
-      -- that have been active within the grace period:
-      jobTS = getTimestamp(jobKey, {"finishedOn", "processedOn", "timestamp"})
-      if (not jobTS or jobTS < timestamp) then
-        -- replace the entry with a deletion marker; the actual deletion will
-        -- occur at the end of the script
-        rcall("LSET", listKey, rangeEnd - jobIdsLen + i, deletionMarker)
-        removeJob(job, true, jobKeyPrefix)
-        if isWaiting then
-          rcall("ZREM", jobKeyPrefix .. "priority", job)
-        end
-        deletedCount = deletedCount + 1
-        table.insert(deleted, job)
-      end
-    end
-  end
-
-  rcall("LREM", listKey, 0, deletionMarker)
-
-  return {deleted, deletedCount}
-end