bullmq 4.0.0-beta.1 → 4.0.0

package/dist/esm/scripts/addJob-9.js

@@ -0,0 +1,249 @@
+const content = `--[[
+  Adds a job to the queue by doing the following:
+    - Increases the job counter if needed.
+    - Creates a new job key with the job data.
+    - if delayed:
+      - computes timestamp.
+      - adds to delayed zset.
+      - Emits a global event 'delayed' if the job is delayed.
+    - if not delayed
+      - Adds the jobId to the wait/paused list in one of three ways:
+         - LIFO
+         - FIFO
+         - prioritized.
+      - Adds the job to the "added" list so that workers gets notified.
+    Input:
+      KEYS[1] 'wait',
+      KEYS[2] 'paused'
+      KEYS[3] 'meta'
+      KEYS[4] 'id'
+      KEYS[5] 'delayed'
+      KEYS[6] 'prioritized'
+      KEYS[7] 'completed'
+      KEYS[8] events stream key
+      KEYS[9] 'pc' priority counter
+      ARGV[1] msgpacked arguments array
+            [1]  key prefix,
+            [2]  custom id (will not generate one automatically)
+            [3]  name
+            [4]  timestamp
+            [5]  parentKey?
+            [6]  waitChildrenKey key.
+            [7]  parent dependencies key.
+            [8]  parent? {id, queueKey}
+            [9]  repeat job key
+      ARGV[2] Json stringified job data
+      ARGV[3] msgpacked options
+      Output:
+        jobId  - OK
+        -5     - Missing parent key
+]]
+local jobId
+local jobIdKey
+local rcall = redis.call
+local args = cmsgpack.unpack(ARGV[1])
+local data = ARGV[2]
+local opts = cmsgpack.unpack(ARGV[3])
+local parentKey = args[5]
+local repeatJobKey = args[9]
+local parent = args[8]
+local parentData
+-- Includes
+--[[
+  Add delay marker if needed.
+]]
+-- Includes
+--[[
+  Function to return the next delayed job timestamp.
+]] 
+local function getNextDelayedTimestamp(delayedKey)
+  local result = rcall("ZRANGE", delayedKey, 0, 0, "WITHSCORES")
+  if #result then
+    local nextTimestamp = tonumber(result[2])
+    if (nextTimestamp ~= nil) then 
+      nextTimestamp = nextTimestamp / 0x1000
+    end
+    return nextTimestamp
+  end
+end
+local function addDelayMarkerIfNeeded(targetKey, delayedKey)
+  if rcall("LLEN", targetKey) == 0 then
+    local nextTimestamp = getNextDelayedTimestamp(delayedKey)
+    if nextTimestamp ~= nil then
+      rcall("LPUSH", targetKey, "0:" .. nextTimestamp)
+    end
+  end
+end
+--[[
+  Function to add job considering priority.
+]]
+-- Includes
+--[[
+  Function priority marker to wait if needed
+  in order to wake up our workers and to respect priority
+  order as much as possible
+]]
+local function addPriorityMarkerIfNeeded(waitKey)
+  local waitLen = rcall("LLEN", waitKey)
+  if waitLen == 0 then
+    rcall("LPUSH", waitKey, "0:0")
+  end
+end
+local function addJobWithPriority(waitKey, prioritizedKey, priority, paused, jobId, priorityCounterKey)
+  local prioCounter = rcall("INCR", priorityCounterKey)
+  local score = priority * 0x100000000 + bit.band(prioCounter, 0xffffffffffff)
+  rcall("ZADD", prioritizedKey, score, jobId)
+  if not paused then
+    addPriorityMarkerIfNeeded(waitKey)
+  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, false
+  else
+    return pausedKey, true
+  end
+end
+--[[
+  Function to trim events, default 10000.
+]]
+local function trimEvents(metaKey, eventStreamKey)
+  local maxEvents = rcall("HGET", metaKey, "opts.maxLenEvents")
+  if maxEvents ~= false then
+    rcall("XTRIM", eventStreamKey, "MAXLEN", "~", maxEvents)
+  else
+    rcall("XTRIM", eventStreamKey, "MAXLEN", "~", 10000)
+  end
+end
+--[[
+  Validate and move or add dependencies to parent.
+]]
+-- Includes
+local function updateParentDepsIfNeeded(parentKey, parentQueueKey, parentDependenciesKey,
+  parentId, jobIdKey, returnvalue, timestamp )
+  local processedSet = parentKey .. ":processed"
+  rcall("HSET", processedSet, jobIdKey, returnvalue)
+  local activeParent = rcall("ZSCORE", parentQueueKey .. ":waiting-children", parentId)
+  if rcall("SCARD", parentDependenciesKey) == 0 and activeParent then 
+    rcall("ZREM", parentQueueKey .. ":waiting-children", parentId)
+    local parentWaitKey = parentQueueKey .. ":wait"
+    local parentTarget, paused = getTargetQueueList(parentQueueKey .. ":meta", parentWaitKey,
+      parentQueueKey .. ":paused")
+    local jobAttributes = rcall("HMGET", parentKey, "priority", "delay")
+    local priority = tonumber(jobAttributes[1]) or 0
+    local delay = tonumber(jobAttributes[2]) or 0
+    if delay > 0 then
+      local delayedTimestamp = tonumber(timestamp) + delay 
+      local score = delayedTimestamp * 0x1000
+      local parentDelayedKey = parentQueueKey .. ":delayed" 
+      rcall("ZADD", parentDelayedKey, score, parentId)
+      addDelayMarkerIfNeeded(parentTarget, parentDelayedKey)
+    -- Standard or priority add
+    elseif priority == 0 then
+      rcall("RPUSH", parentTarget, parentId)
+    else
+      addJobWithPriority(parentWaitKey, parentQueueKey .. ":prioritized", priority, paused,
+        parentId, parentQueueKey .. ":pc")
+    end
+    rcall("XADD", parentQueueKey .. ":events", "*", "event", "waiting", "jobId", parentId, "prev", "waiting-children")
+  end
+end
+if parentKey ~= nil then
+  if rcall("EXISTS", parentKey) ~= 1 then
+    return -5
+  end
+  parentData = cjson.encode(parent)
+end
+local jobCounter = rcall("INCR", KEYS[4])
+-- Trim events before emiting them to avoid trimming events emitted in this script
+trimEvents(KEYS[3], KEYS[8])
+local parentDependenciesKey = args[7]
+local timestamp = args[4]
+if args[2] == "" then
+  jobId = jobCounter
+  jobIdKey = args[1] .. jobId
+else
+  jobId = args[2]
+  jobIdKey = args[1] .. jobId
+  if rcall("EXISTS", jobIdKey) == 1 then
+    if parentKey ~= nil then
+      if rcall("ZSCORE", KEYS[7], jobId) ~= false then
+        local returnvalue = rcall("HGET", jobIdKey, "returnvalue")
+        updateParentDepsIfNeeded(parentKey, parent['queueKey'], parentDependenciesKey,
+          parent['id'], jobIdKey, returnvalue, timestamp)
+      else
+        if parentDependenciesKey ~= nil then
+          rcall("SADD", parentDependenciesKey, jobIdKey)
+        end
+      end
+      rcall("HMSET", jobIdKey, "parentKey", parentKey, "parent", parentData)
+    end
+    rcall("XADD", KEYS[8], "*", "event", "duplicated", "jobId", jobId)
+    return jobId .. "" -- convert to string
+  end
+end
+-- Store the job.
+local jsonOpts = cjson.encode(opts)
+local delay = opts['delay'] or 0
+local priority = opts['priority'] or 0
+local optionalValues = {}
+if parentKey ~= nil then
+  table.insert(optionalValues, "parentKey")
+  table.insert(optionalValues, parentKey)
+  table.insert(optionalValues, "parent")
+  table.insert(optionalValues, parentData)
+end
+if repeatJobKey ~= nil then
+  table.insert(optionalValues, "rjk")
+  table.insert(optionalValues, repeatJobKey)
+end
+rcall("HMSET", jobIdKey, "name", args[3], "data", ARGV[2], "opts", jsonOpts,
+  "timestamp", timestamp, "delay", delay, "priority", priority, unpack(optionalValues))
+rcall("XADD", KEYS[8], "*", "event", "added", "jobId", jobId, "name", args[3])
+-- Check if job is delayed
+local delayedTimestamp = (delay > 0 and (timestamp + delay)) or 0
+-- Check if job is a parent, if so add to the parents set
+local waitChildrenKey = args[6]
+if waitChildrenKey ~= nil then
+  rcall("ZADD", waitChildrenKey, timestamp, jobId)
+  rcall("XADD", KEYS[8], "*", "event", "waiting-children", "jobId", jobId)
+elseif (delayedTimestamp ~= 0) then
+  local score = delayedTimestamp * 0x1000 + bit.band(jobCounter, 0xfff)
+  rcall("ZADD", KEYS[5], score, jobId)
+  rcall("XADD", KEYS[8], "*", "event", "delayed", "jobId", jobId, "delay",
+        delayedTimestamp)
+  -- If wait list is empty, and this delayed job is the next one to be processed,
+  -- then we need to signal the workers by adding a dummy job (jobId 0:delay) to the wait list.
+  local target = getTargetQueueList(KEYS[3], KEYS[1], KEYS[2])
+  addDelayMarkerIfNeeded(target, KEYS[5])
+else
+  local target, paused = getTargetQueueList(KEYS[3], KEYS[1], KEYS[2])
+  -- Standard or priority add
+  if priority == 0 then
+    -- LIFO or FIFO
+    local pushCmd = opts['lifo'] and 'RPUSH' or 'LPUSH'
+    rcall(pushCmd, target, jobId)
+  else
+    addJobWithPriority(KEYS[1], KEYS[6], priority, paused, jobId, KEYS[9])
+  end
+  -- Emit waiting event
+  rcall("XADD", KEYS[8], "*", "event", "waiting", "jobId", jobId)
+end
+-- Check if this job is a child of another job, if so add it to the parents dependencies
+-- TODO: Should not be possible to add a child job to a parent that is not in the "waiting-children" status.
+-- fail in this case.
+if parentDependenciesKey ~= nil then
+  rcall("SADD", parentDependenciesKey, jobIdKey)
+end
+return jobId .. "" -- convert to string
+`;
+export const addJob = {
+    name: 'addJob',
+    content,
+    keys: 9,
+};
+//# sourceMappingURL=addJob-9.js.map

package/dist/esm/scripts/addJob-9.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"addJob-9.js","sourceRoot":"","sources":["../../../src/scripts/addJob-9.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkPf,CAAC;AACF,MAAM,CAAC,MAAM,MAAM,GAAG;IACpB,IAAI,EAAE,QAAQ;IACd,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

package/dist/esm/scripts/changeDelay-3.d.ts

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

package/dist/esm/scripts/changeDelay-3.js

@@ -0,0 +1,38 @@
+const content = `--[[
+  Change job delay when it is in delayed set.
+  Input:
+    KEYS[1] delayed key
+    KEYS[2] job key
+    KEYS[3] events stream
+    ARGV[1] delay
+    ARGV[2] delayedTimestamp
+    ARGV[3] the id of the job
+  Output:
+    0 - OK
+   -1 - Missing job.
+   -3 - Job not in delayed set.
+  Events:
+    - delayed key.
+]]
+local rcall = redis.call
+if rcall("EXISTS", KEYS[2]) == 1 then
+  local jobId = ARGV[3]
+  local score = tonumber(ARGV[2])
+  local delayedTimestamp = (score / 0x1000)
+  local numRemovedElements = rcall("ZREM", KEYS[1], jobId)
+  if numRemovedElements < 1 then
+    return -3
+  end
+  rcall("HSET", KEYS[2], "delay", tonumber(ARGV[1]))
+  rcall("ZADD", KEYS[1], score, jobId)
+  rcall("XADD", KEYS[3], "*", "event", "delayed", "jobId", jobId, "delay", delayedTimestamp)
+  return 0
+else
+  return -1
+end`;
+export const changeDelay = {
+    name: 'changeDelay',
+    content,
+    keys: 3,
+};
+//# sourceMappingURL=changeDelay-3.js.map

package/dist/esm/scripts/changeDelay-3.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"changeDelay-3.js","sourceRoot":"","sources":["../../../src/scripts/changeDelay-3.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA+BZ,CAAC;AACL,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,IAAI,EAAE,aAAa;IACnB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

package/dist/esm/scripts/changePriority-5.d.ts

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

package/dist/esm/scripts/changePriority-5.js

@@ -0,0 +1,84 @@
+const content = `--[[
+  Change job priority
+  Input:
+    KEYS[1] 'wait',
+    KEYS[2] 'paused'
+    KEYS[3] 'meta'
+    KEYS[4] 'prioritized'
+    KEYS[5] 'pc' priority counter
+    ARGV[1] priority value
+    ARGV[2] job key
+    ARGV[3] job id
+    ARGV[4] lifo
+    Output:
+       0  - OK
+      -1  - Missing job
+]]
+local jobKey = ARGV[2]
+local jobId = ARGV[3]
+local priority = tonumber(ARGV[1])
+local rcall = redis.call
+-- Includes
+--[[
+  Function to add job considering priority.
+]]
+-- Includes
+--[[
+  Function priority marker to wait if needed
+  in order to wake up our workers and to respect priority
+  order as much as possible
+]]
+local function addPriorityMarkerIfNeeded(waitKey)
+  local waitLen = rcall("LLEN", waitKey)
+  if waitLen == 0 then
+    rcall("LPUSH", waitKey, "0:0")
+  end
+end
+local function addJobWithPriority(waitKey, prioritizedKey, priority, paused, jobId, priorityCounterKey)
+  local prioCounter = rcall("INCR", priorityCounterKey)
+  local score = priority * 0x100000000 + bit.band(prioCounter, 0xffffffffffff)
+  rcall("ZADD", prioritizedKey, score, jobId)
+  if not paused then
+    addPriorityMarkerIfNeeded(waitKey)
+  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, false
+  else
+    return pausedKey, true
+  end
+end
+if rcall("EXISTS", jobKey) == 1 then
+  local target, paused = getTargetQueueList(KEYS[3], KEYS[1], KEYS[2])
+  if rcall("ZREM", KEYS[4], jobId) > 0 then
+    addJobWithPriority(KEYS[1], KEYS[4], priority, paused, jobId, KEYS[5])
+  else
+    local numRemovedElements = rcall("LREM", target, -1, jobId)
+    if numRemovedElements > 0 then
+      -- Standard or priority add
+      if priority == 0 then
+        -- LIFO or FIFO
+        local pushCmd = ARGV[4] == '1' and 'RPUSH' or 'LPUSH';
+        rcall(pushCmd, target, jobId)
+      else
+        addJobWithPriority(KEYS[1], KEYS[4], priority, paused, jobId, KEYS[5])
+      end
+    end
+  end
+  rcall("HSET", jobKey, "priority", priority)
+  return 0
+else
+  return -1
+end
+`;
+export const changePriority = {
+    name: 'changePriority',
+    content,
+    keys: 5,
+};
+//# sourceMappingURL=changePriority-5.js.map

package/dist/esm/scripts/changePriority-5.js.map

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

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

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

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

@@ -0,0 +1,256 @@
+const content = `--[[
+  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
+--[[
+  Function to clean job list.
+  Returns jobIds and deleted count number.
+]]
+-- Includes
+--[[
+  Function to get the latest saved timestamp.
+]]
+local function getTimestamp(jobKey, attributes)
+  if #attributes == 1 then
+    return rcall("HGET", jobKey, attributes[1])
+  end
+  local jobTs
+  for _, ts in ipairs(rcall("HMGET", jobKey, unpack(attributes))) do
+    if (ts) then
+      jobTs = ts
+      break
+    end
+  end
+  return jobTs
+end
+--[[
+  Function to remove job.
+]]
+-- Includes
+--[[
+  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"
+]]
+--[[
+  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, waitKey, pausedKey)
+  if rcall("HEXISTS", queueMetaKey, "paused") ~= 1 then
+    return waitKey, false
+  else
+    return pausedKey, true
+  end
+end
+local function moveParentToWait(parentPrefix, parentId, emitEvent)
+  local parentTarget = getTargetQueueList(parentPrefix .. "meta", parentPrefix .. "wait", parentPrefix .. "paused")
+  rcall("RPUSH", parentTarget, 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)
+  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
+            if parentPrefix == baseKey then
+              removeParentDependencyKey(parentKey, hard, nil, baseKey)
+              rcall("DEL", parentKey, parentKey .. ':logs',
+                parentKey .. ':dependencies', parentKey .. ':processed')
+            else
+              moveParentToWait(parentPrefix, parentId)
+            end
+          else
+            moveParentToWait(parentPrefix, parentId, true)
+          end
+        end
+      end
+    end
+  else
+    local missedParentKey = rcall("HGET", jobKey, "parentKey")
+    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)
+                rcall("DEL", missedParentKey, missedParentKey .. ':logs',
+                  missedParentKey .. ':dependencies', missedParentKey .. ':processed')
+              else
+                moveParentToWait(parentPrefix, parentId)
+              end
+            else
+              moveParentToWait(parentPrefix, parentId, true)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+local function removeJob(jobId, hard, baseKey)
+  local jobKey = baseKey .. jobId
+  removeParentDependencyKey(jobKey, hard, nil, baseKey)
+  rcall("DEL", jobKey, jobKey .. ':logs',
+    jobKey .. ':dependencies', jobKey .. ':processed')
+end
+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)
+        deletedCount = deletedCount + 1
+        table.insert(deleted, job)
+      end
+    end
+  end
+  rcall("LREM", listKey, 0, deletionMarker)
+  return {deleted, deletedCount}
+end
+--[[
+  Function to clean job set.
+  Returns jobIds and deleted count number.
+]]
+-- Includes
+--[[
+  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
+-- We use ZRANGEBYSCORE to make the case where we're deleting a limited number
+-- of items in a sorted set only run a single iteration. If we simply used
+-- ZRANGE, we may take a long time traversing through jobs that are within the
+-- grace period.
+local function getJobsInZset(zsetKey, rangeStart, rangeEnd, maxTimestamp, limit)
+  if limit > 0 then
+    return rcall("ZRANGEBYSCORE", zsetKey, 0, maxTimestamp, "LIMIT", 0, limit)
+  else
+    return rcall("ZRANGE", zsetKey, rangeStart, rangeEnd)
+  end
+end
+local function cleanSet(setKey, jobKeyPrefix, rangeStart, rangeEnd, timestamp, limit, attributes)
+  local jobs = getJobsInZset(setKey, rangeStart, rangeEnd, timestamp, 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
+    -- * 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)
+      deletedCount = deletedCount + 1
+      table.insert(deleted, job)
+    end
+  end
+  if(#deleted > 0) then
+    for from, to in batches(#deleted, 7000) do
+      rcall("ZREM", setKey, unpack(deleted, from, to))
+    end
+  end
+  return {deleted, deletedCount}
+end
+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] == "prioritized" then
+  result = cleanSet(KEYS[1], ARGV[1], rangeStart, rangeEnd, ARGV[2], limit, {"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]
+`;
+export const cleanJobsInSet = {
+    name: 'cleanJobsInSet',
+    content,
+    keys: 2,
+};
+//# sourceMappingURL=cleanJobsInSet-2.js.map

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

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

package/dist/esm/scripts/drain-4.d.ts

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