bullmq 4.16.0 → 5.0.0

package/dist/cjs/scripts/{addPrioritizedJob-8.js → addPrioritizedJob-7.js}

@@ -7,14 +7,13 @@ const content = `--[[
     - Creates a new job key with the job data.
     - 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] 'prioritized'
-      KEYS[6] 'completed'
-      KEYS[7] events stream key
-      KEYS[8] 'pc' priority counter
+      KEYS[1] 'marker',
+      KEYS[2] 'meta'
+      KEYS[3] 'id'
+      KEYS[4] 'prioritized'
+      KEYS[5] 'completed'
+      KEYS[6] events stream key
+      KEYS[7] 'pc' priority counter
       ARGV[1] msgpacked arguments array
             [1]  key prefix,
             [2]  custom id (will not generate one automatically)
@@ -30,15 +29,13 @@ const content = `--[[
       Output:
         jobId  - OK
         -5     - Missing parent key
-]]
-local waitKey = KEYS[1]
-local pausedKey = KEYS[2]
-local metaKey = KEYS[3]
-local idKey = KEYS[4]
-local priorityKey = KEYS[5]
-local completedKey = KEYS[6]
-local eventsKey = KEYS[7]
-local priorityCounterKey = KEYS[8]
+]] 
+local metaKey = KEYS[2]
+local idKey = KEYS[3]
+local priorityKey = KEYS[4]
+local completedKey = KEYS[5]
+local eventsKey = KEYS[6]
+local priorityCounterKey = KEYS[7]
 local jobId
 local jobIdKey
 local rcall = redis.call
@@ -76,37 +73,21 @@ local function storeJob(eventsKey, jobIdKey, jobId, name, data, opts, timestamp,
     return delay, priority
 end
 --[[
-  Function to add job considering priority.
+  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).
 ]]
--- Includes
+local function isQueuePaused(queueMetaKey)
+    return rcall("HEXISTS", queueMetaKey, "paused") == 1
+end
 --[[
-  Function priority marker to wait if needed
-  in order to wake up our workers and to respect priority
-  order as much as possible
+  Function to add job considering priority.
 ]]
-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 function addJobWithPriority(markerKey, prioritizedKey, priority, jobId, priorityCounterKey, isPaused)
   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
+  if not isPaused then
+    rcall("ZADD", markerKey, 0, "0")
   end
 end
 --[[
@@ -119,7 +100,7 @@ end
 -- Includes
 --[[
   Add delay marker if needed.
-]]
+]] 
 -- Includes
 --[[
   Function to return the next delayed job timestamp.
@@ -134,55 +115,63 @@ local function getNextDelayedTimestamp(delayedKey)
     return nextTimestamp
   end
 end
-local function addDelayMarkerIfNeeded(targetKey, delayedKey)
-  local waitLen = rcall("LLEN", targetKey)
-  if waitLen <= 1 then
+local function addDelayMarkerIfNeeded(markerKey, delayedKey)
     local nextTimestamp = getNextDelayedTimestamp(delayedKey)
     if nextTimestamp ~= nil then
-      -- Check if there is already a marker with older timestamp
-      -- if there is, we need to replace it.
-      if waitLen == 1 then
-        local marker = rcall("LINDEX", targetKey, 0)
-        local oldTimestamp = tonumber(marker:sub(3))
-        if oldTimestamp and oldTimestamp > nextTimestamp then
-          rcall("LSET", targetKey, 0, "0:" .. nextTimestamp)
-        end
-      else
-        -- if there is no marker, then we need to add one
-        rcall("LPUSH", targetKey, "0:" .. nextTimestamp)
-      end
+        -- Replace the score of the marker with the newest known
+        -- next timestamp.
+        rcall("ZADD", markerKey, nextTimestamp, "0")
     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
-local function moveParentToWaitIfNeeded(parentQueueKey, parentDependenciesKey, parentKey, parentId, timestamp)
-  local isParentActive = rcall("ZSCORE", parentQueueKey .. ":waiting-children", parentId)
-  if rcall("SCARD", parentDependenciesKey) == 0 and isParentActive 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)
-      rcall("XADD", parentQueueKey .. ":events", "*", "event", "delayed", "jobId", parentId,
-        "delay", delayedTimestamp)
-      addDelayMarkerIfNeeded(parentTarget, parentDelayedKey)
-    else
-      if 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")
+local function moveParentToWaitIfNeeded(parentQueueKey, parentDependenciesKey,
+                                        parentKey, parentId, timestamp)
+    local isParentActive = rcall("ZSCORE",
+                                 parentQueueKey .. ":waiting-children", parentId)
+    if rcall("SCARD", parentDependenciesKey) == 0 and isParentActive then
+        rcall("ZREM", parentQueueKey .. ":waiting-children", parentId)
+        local parentWaitKey = parentQueueKey .. ":wait"
+        local parentPausedKey = parentQueueKey .. ":paused"
+        local parentMetaKey = parentQueueKey .. ":meta"
+        local parentMarkerKey = parentQueueKey .. ":marker"
+        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)
+            rcall("XADD", parentQueueKey .. ":events", "*", "event", "delayed",
+                  "jobId", parentId, "delay", delayedTimestamp)
+            addDelayMarkerIfNeeded(parentMarkerKey, parentDelayedKey)
+        else
+            if priority == 0 then
+                local parentTarget, _paused =
+                    getTargetQueueList(parentMetaKey, parentWaitKey,
+                                       parentPausedKey)
+                rcall("RPUSH", parentTarget, parentId)
+                rcall("ZADD", parentMarkerKey, 0, "0")
+            else
+                local isPaused = isQueuePaused(parentMetaKey)
+                addJobWithPriority(parentMarkerKey,
+                                   parentQueueKey .. ":prioritized", priority,
+                                   parentId, parentQueueKey .. ":pc", isPaused)
+            end
+            rcall("XADD", parentQueueKey .. ":events", "*", "event", "waiting",
+                  "jobId", parentId, "prev", "waiting-children")
+        end
     end
-  end
 end
 local function updateParentDepsIfNeeded(parentKey, parentQueueKey, parentDependenciesKey,
   parentId, jobIdKey, returnvalue, timestamp )
@@ -248,15 +237,13 @@ end
 local delay, priority = storeJob(eventsKey, jobIdKey, jobId, args[3], ARGV[2],
                                  opts, timestamp, parentKey, parentData,
                                  repeatJobKey)
-local target, paused = getTargetQueueList(metaKey, waitKey, pausedKey)
-addJobWithPriority(waitKey, priorityKey, priority, paused, jobId,
-                   priorityCounterKey)
+-- Add the job to the prioritized set
+local isPause = isQueuePaused(metaKey)
+addJobWithPriority( KEYS[1], priorityKey, priority, jobId, priorityCounterKey, isPause)
 -- Emit waiting event
 rcall("XADD", eventsKey, "MAXLEN", "~", maxEvents, "*", "event", "waiting",
       "jobId", jobId)
 -- 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
@@ -265,6 +252,6 @@ return jobId .. "" -- convert to string
 exports.addPrioritizedJob = {
     name: 'addPrioritizedJob',
     content,
-    keys: 8,
+    keys: 7,
 };
-//# sourceMappingURL=addPrioritizedJob-8.js.map
+//# sourceMappingURL=addPrioritizedJob-7.js.map

package/dist/cjs/scripts/addPrioritizedJob-7.js.map

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

package/dist/cjs/scripts/{addStandardJob-6.js → addStandardJob-7.js}

@@ -22,6 +22,7 @@ const content = `--[[
       KEYS[4] 'id'
       KEYS[5] 'completed'
       KEYS[6] events stream key
+      KEYS[7] marker key
       ARGV[1] msgpacked arguments array
             [1]  key prefix,
             [2]  custom id (will not generate one automatically)
@@ -85,7 +86,7 @@ end
 -- Includes
 --[[
   Add delay marker if needed.
-]]
+]] 
 -- Includes
 --[[
   Function to return the next delayed job timestamp.
@@ -100,47 +101,30 @@ local function getNextDelayedTimestamp(delayedKey)
     return nextTimestamp
   end
 end
-local function addDelayMarkerIfNeeded(targetKey, delayedKey)
-  local waitLen = rcall("LLEN", targetKey)
-  if waitLen <= 1 then
+local function addDelayMarkerIfNeeded(markerKey, delayedKey)
     local nextTimestamp = getNextDelayedTimestamp(delayedKey)
     if nextTimestamp ~= nil then
-      -- Check if there is already a marker with older timestamp
-      -- if there is, we need to replace it.
-      if waitLen == 1 then
-        local marker = rcall("LINDEX", targetKey, 0)
-        local oldTimestamp = tonumber(marker:sub(3))
-        if oldTimestamp and oldTimestamp > nextTimestamp then
-          rcall("LSET", targetKey, 0, "0:" .. nextTimestamp)
-        end
-      else
-        -- if there is no marker, then we need to add one
-        rcall("LPUSH", targetKey, "0:" .. nextTimestamp)
-      end
+        -- Replace the score of the marker with the newest known
+        -- next timestamp.
+        rcall("ZADD", markerKey, nextTimestamp, "0")
     end
-  end
 end
 --[[
-  Function to add job considering priority.
+  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).
 ]]
--- Includes
+local function isQueuePaused(queueMetaKey)
+    return rcall("HEXISTS", queueMetaKey, "paused") == 1
+end
 --[[
-  Function priority marker to wait if needed
-  in order to wake up our workers and to respect priority
-  order as much as possible
+  Function to add job considering priority.
 ]]
-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 function addJobWithPriority(markerKey, prioritizedKey, priority, jobId, priorityCounterKey, isPaused)
   local prioCounter = rcall("INCR", priorityCounterKey)
   local score = priority * 0x100000000 + bit.band(prioCounter, 0xffffffffffff)
   rcall("ZADD", prioritizedKey, score, jobId)
-  if not paused then
-    addPriorityMarkerIfNeeded(waitKey)
+  if not isPaused then
+    rcall("ZADD", markerKey, 0, "0")
   end
 end
 --[[
@@ -154,35 +138,44 @@ local function getTargetQueueList(queueMetaKey, waitKey, pausedKey)
     return pausedKey, true
   end
 end
-local function moveParentToWaitIfNeeded(parentQueueKey, parentDependenciesKey, parentKey, parentId, timestamp)
-  local isParentActive = rcall("ZSCORE", parentQueueKey .. ":waiting-children", parentId)
-  if rcall("SCARD", parentDependenciesKey) == 0 and isParentActive 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)
-      rcall("XADD", parentQueueKey .. ":events", "*", "event", "delayed", "jobId", parentId,
-        "delay", delayedTimestamp)
-      addDelayMarkerIfNeeded(parentTarget, parentDelayedKey)
-    else
-      if 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")
+local function moveParentToWaitIfNeeded(parentQueueKey, parentDependenciesKey,
+                                        parentKey, parentId, timestamp)
+    local isParentActive = rcall("ZSCORE",
+                                 parentQueueKey .. ":waiting-children", parentId)
+    if rcall("SCARD", parentDependenciesKey) == 0 and isParentActive then
+        rcall("ZREM", parentQueueKey .. ":waiting-children", parentId)
+        local parentWaitKey = parentQueueKey .. ":wait"
+        local parentPausedKey = parentQueueKey .. ":paused"
+        local parentMetaKey = parentQueueKey .. ":meta"
+        local parentMarkerKey = parentQueueKey .. ":marker"
+        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)
+            rcall("XADD", parentQueueKey .. ":events", "*", "event", "delayed",
+                  "jobId", parentId, "delay", delayedTimestamp)
+            addDelayMarkerIfNeeded(parentMarkerKey, parentDelayedKey)
+        else
+            if priority == 0 then
+                local parentTarget, _paused =
+                    getTargetQueueList(parentMetaKey, parentWaitKey,
+                                       parentPausedKey)
+                rcall("RPUSH", parentTarget, parentId)
+                rcall("ZADD", parentMarkerKey, 0, "0")
+            else
+                local isPaused = isQueuePaused(parentMetaKey)
+                addJobWithPriority(parentMarkerKey,
+                                   parentQueueKey .. ":prioritized", priority,
+                                   parentId, parentQueueKey .. ":pc", isPaused)
+            end
+            rcall("XADD", parentQueueKey .. ":events", "*", "event", "waiting",
+                  "jobId", parentId, "prev", "waiting-children")
+        end
     end
-  end
 end
 local function updateParentDepsIfNeeded(parentKey, parentQueueKey, parentDependenciesKey,
   parentId, jobIdKey, returnvalue, timestamp )
@@ -249,6 +242,10 @@ end
 storeJob(eventsKey, jobIdKey, jobId, args[3], ARGV[2], opts, timestamp,
          parentKey, parentData, repeatJobKey)
 local target, paused = getTargetQueueList(metaKey, KEYS[1], KEYS[2])
+if not paused then
+    -- mark that a job is available
+    rcall("ZADD", KEYS[7], 0, "0")
+end
 -- LIFO or FIFO
 local pushCmd = opts['lifo'] and 'RPUSH' or 'LPUSH'
 rcall(pushCmd, target, jobId)
@@ -256,8 +253,6 @@ rcall(pushCmd, target, jobId)
 rcall("XADD", eventsKey, "MAXLEN", "~", maxEvents, "*", "event", "waiting",
       "jobId", jobId)
 -- 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
@@ -266,6 +261,6 @@ return jobId .. "" -- convert to string
 exports.addStandardJob = {
     name: 'addStandardJob',
     content,
-    keys: 6,
+    keys: 7,
 };
-//# sourceMappingURL=addStandardJob-6.js.map
+//# sourceMappingURL=addStandardJob-7.js.map

package/dist/cjs/scripts/addStandardJob-7.js.map

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

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

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.changePriority = void 0;
+const content = `--[[
+  Change job priority
+  Input:
+    KEYS[1] 'wait',
+    KEYS[2] 'paused'
+    KEYS[3] 'meta'
+    KEYS[4] 'prioritized'
+    KEYS[5] 'pc' priority counter
+    KEYS[6] 'marker'
+    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 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 isQueuePaused(queueMetaKey)
+    return rcall("HEXISTS", queueMetaKey, "paused") == 1
+end
+--[[
+  Function to add job considering priority.
+]]
+local function addJobWithPriority(markerKey, prioritizedKey, priority, jobId, priorityCounterKey, isPaused)
+  local prioCounter = rcall("INCR", priorityCounterKey)
+  local score = priority * 0x100000000 + bit.band(prioCounter, 0xffffffffffff)
+  rcall("ZADD", prioritizedKey, score, jobId)
+  if not isPaused then
+    rcall("ZADD", markerKey, 0, "0")
+  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 metaKey = KEYS[3]
+    local isPaused = isQueuePaused(metaKey)
+    local markerKey = KEYS[6]
+    local prioritizedKey = KEYS[4]
+    -- Re-add with the new priority
+    if rcall("ZREM", KEYS[4], jobId) > 0 then
+        addJobWithPriority(markerKey, prioritizedKey, priority, jobId, KEYS[5],
+                           isPaused)
+        -- If the new priority is 0, then just leave the job where it is in the wait list.
+    elseif priority > 0 then
+        -- Job is already in the wait list, we need to re-add it with the new priority.
+        local target = isPaused and KEYS[2] or KEYS[1]
+        local numRemovedElements = rcall("LREM", target, -1, jobId)
+        if numRemovedElements > 0 then
+            addJobWithPriority(markerKey, prioritizedKey, priority, jobId,
+                               KEYS[5], isPaused)
+        end
+    end
+    rcall("HSET", jobKey, "priority", priority)
+    return 0
+else
+    return -1
+end
+`;
+exports.changePriority = {
+    name: 'changePriority',
+    content,
+    keys: 6,
+};
+//# sourceMappingURL=changePriority-6.js.map

package/dist/cjs/scripts/changePriority-6.js.map

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

package/dist/cjs/scripts/getCounts-1.js

@@ -13,6 +13,7 @@ local results = {}
 for i = 1, #ARGV do
   local stateKey = prefix .. ARGV[i]
   if ARGV[i] == "wait" or ARGV[i] == "paused" then
+    -- Markers in waitlist DEPRECATED in v5: Remove in v6.
     local marker = rcall("LINDEX", stateKey, -1)
     if marker and string.sub(marker, 1, 2) == "0:" then
       local count = rcall("LLEN", stateKey)

package/dist/cjs/scripts/getCounts-1.js.map

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

package/dist/cjs/scripts/getRanges-1.js

@@ -40,6 +40,7 @@ end
 for i = 4, #ARGV do
   local stateKey = prefix .. ARGV[i]
   if ARGV[i] == "wait" or ARGV[i] == "paused" then
+    -- Markers in waitlist DEPRECATED in v5: Remove in v6.
     local marker = rcall("LINDEX", stateKey, -1)
     if marker and string.sub(marker, 1, 2) == "0:" then
       local count = rcall("LLEN", stateKey)

package/dist/cjs/scripts/getRanges-1.js.map

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

package/dist/cjs/scripts/index.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./addDelayedJob-7"), exports);
+tslib_1.__exportStar(require("./addDelayedJob-6"), exports);
 tslib_1.__exportStar(require("./addParentJob-4"), exports);
-tslib_1.__exportStar(require("./addPrioritizedJob-8"), exports);
-tslib_1.__exportStar(require("./addStandardJob-6"), exports);
+tslib_1.__exportStar(require("./addPrioritizedJob-7"), exports);
+tslib_1.__exportStar(require("./addStandardJob-7"), exports);
 tslib_1.__exportStar(require("./changeDelay-3"), exports);
-tslib_1.__exportStar(require("./changePriority-5"), exports);
+tslib_1.__exportStar(require("./changePriority-6"), exports);
 tslib_1.__exportStar(require("./cleanJobsInSet-2"), exports);
 tslib_1.__exportStar(require("./drain-4"), exports);
 tslib_1.__exportStar(require("./extendLock-2"), exports);
@@ -19,19 +19,19 @@ tslib_1.__exportStar(require("./isJobInList-1"), exports);
 tslib_1.__exportStar(require("./moveJobFromActiveToWait-9"), exports);
 tslib_1.__exportStar(require("./moveJobsToWait-6"), exports);
 tslib_1.__exportStar(require("./moveStalledJobsToWait-8"), exports);
-tslib_1.__exportStar(require("./moveToActive-10"), exports);
-tslib_1.__exportStar(require("./moveToDelayed-8"), exports);
-tslib_1.__exportStar(require("./moveToFinished-13"), exports);
+tslib_1.__exportStar(require("./moveToActive-11"), exports);
+tslib_1.__exportStar(require("./moveToDelayed-7"), exports);
+tslib_1.__exportStar(require("./moveToFinished-14"), exports);
 tslib_1.__exportStar(require("./moveToWaitingChildren-4"), exports);
 tslib_1.__exportStar(require("./obliterate-2"), exports);
 tslib_1.__exportStar(require("./paginate-1"), exports);
-tslib_1.__exportStar(require("./pause-5"), exports);
-tslib_1.__exportStar(require("./promote-7"), exports);
+tslib_1.__exportStar(require("./pause-7"), exports);
+tslib_1.__exportStar(require("./promote-8"), exports);
 tslib_1.__exportStar(require("./releaseLock-1"), exports);
 tslib_1.__exportStar(require("./removeJob-1"), exports);
 tslib_1.__exportStar(require("./removeRepeatable-2"), exports);
 tslib_1.__exportStar(require("./reprocessJob-6"), exports);
-tslib_1.__exportStar(require("./retryJob-9"), exports);
+tslib_1.__exportStar(require("./retryJob-10"), exports);
 tslib_1.__exportStar(require("./saveStacktrace-1"), exports);
 tslib_1.__exportStar(require("./updateData-1"), exports);
 tslib_1.__exportStar(require("./updateProgress-3"), 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,2DAAiC;AACjC,gEAAsC;AACtC,6DAAmC;AACnC,0DAAgC;AAChC,6DAAmC;AACnC,6DAAmC;AACnC,oDAA0B;AAC1B,yDAA+B;AAC/B,wDAA8B;AAC9B,wDAA8B;AAC9B,uDAA6B;AAC7B,yDAA+B;AAC/B,yDAA+B;AAC/B,0DAAgC;AAChC,sEAA4C;AAC5C,6DAAmC;AACnC,oEAA0C;AAC1C,4DAAkC;AAClC,4DAAkC;AAClC,8DAAoC;AACpC,oEAA0C;AAC1C,yDAA+B;AAC/B,uDAA6B;AAC7B,oDAA0B;AAC1B,sDAA4B;AAC5B,0DAAgC;AAChC,wDAA8B;AAC9B,+DAAqC;AACrC,2DAAiC;AACjC,uDAA6B;AAC7B,6DAAmC;AACnC,yDAA+B;AAC/B,6DAAmC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/scripts/index.ts"],"names":[],"mappings":";;;AAAA,4DAAkC;AAClC,2DAAiC;AACjC,gEAAsC;AACtC,6DAAmC;AACnC,0DAAgC;AAChC,6DAAmC;AACnC,6DAAmC;AACnC,oDAA0B;AAC1B,yDAA+B;AAC/B,wDAA8B;AAC9B,wDAA8B;AAC9B,uDAA6B;AAC7B,yDAA+B;AAC/B,yDAA+B;AAC/B,0DAAgC;AAChC,sEAA4C;AAC5C,6DAAmC;AACnC,oEAA0C;AAC1C,4DAAkC;AAClC,4DAAkC;AAClC,8DAAoC;AACpC,oEAA0C;AAC1C,yDAA+B;AAC/B,uDAA6B;AAC7B,oDAA0B;AAC1B,sDAA4B;AAC5B,0DAAgC;AAChC,wDAA8B;AAC9B,+DAAqC;AACrC,2DAAiC;AACjC,wDAA8B;AAC9B,6DAAmC;AACnC,yDAA+B;AAC/B,6DAAmC"}

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

@@ -206,6 +206,7 @@ local function checkStalledJobs(stalledKey, waitKey, activeKey, failedKey,
         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.
             if string.sub(jobId, 1, 2) == "0:" then
                 -- If the jobId is a delay marker ID we just remove it.
                 rcall("LREM", activeKey, 1, jobId)

package/dist/cjs/scripts/moveStalledJobsToWait-8.js.map

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