bullmq 5.8.7 → 5.10.0

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

@@ -21,8 +21,9 @@ const content = `--[[
       KEYS[3] 'meta'
       KEYS[4] 'id'
       KEYS[5] 'completed'
-      KEYS[6] events stream key
-      KEYS[7] marker key
+      KEYS[6] 'active'
+      KEYS[7] events stream key
+      KEYS[8] marker key
       ARGV[1] msgpacked arguments array
             [1]  key prefix,
             [2]  custom id (will not generate one automatically)
@@ -39,7 +40,7 @@ const content = `--[[
         jobId  - OK
         -5     - Missing parent key
 ]]
-local eventsKey = KEYS[6]
+local eventsKey = KEYS[7]
 local jobId
 local jobIdKey
 local rcall = redis.call
@@ -58,14 +59,14 @@ local parentData
 --[[
   Add marker if needed when a job is available.
 ]]
-local function addBaseMarkerIfNeeded(markerKey, isPaused)
-  if not isPaused then
+local function addBaseMarkerIfNeeded(markerKey, isPausedOrMaxed)
+  if not isPausedOrMaxed then
     rcall("ZADD", markerKey, 0, "0")
   end  
 end
-local function addJobInTargetList(targetKey, markerKey, pushCmd, isPaused, jobId)
+local function addJobInTargetList(targetKey, markerKey, pushCmd, isPausedOrMaxed, jobId)
   rcall(pushCmd, targetKey, jobId)
-  addBaseMarkerIfNeeded(markerKey, isPaused)
+  addBaseMarkerIfNeeded(markerKey, isPausedOrMaxed)
 end
 --[[
   Function to get max events value or set by default 10000.
@@ -82,12 +83,21 @@ 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
+local function getTargetQueueList(queueMetaKey, activeKey, waitKey, pausedKey)
+  local queueAttributes = rcall("HMGET", queueMetaKey, "paused", "concurrency")
+  if queueAttributes[1] then
     return pausedKey, true
+  else
+    if queueAttributes[2] then
+      local activeCount = rcall("LLEN", activeKey)
+      if activeCount >= tonumber(queueAttributes[2]) then
+        return waitKey, true
+      else
+        return waitKey, false
+      end
+    end
   end
+  return waitKey, false
 end
 --[[
   Function to handle the case when job is duplicated.
@@ -136,18 +146,28 @@ end
   Function to add job considering priority.
 ]]
 -- Includes
-local function addJobWithPriority(markerKey, prioritizedKey, priority, jobId, priorityCounterKey, isPaused)
+local function addJobWithPriority(markerKey, prioritizedKey, priority, jobId, priorityCounterKey,
+  isPausedOrMaxed)
   local prioCounter = rcall("INCR", priorityCounterKey)
   local score = priority * 0x100000000 + prioCounter % 0x100000000
   rcall("ZADD", prioritizedKey, score, jobId)
-  addBaseMarkerIfNeeded(markerKey, isPaused)
+  addBaseMarkerIfNeeded(markerKey, isPausedOrMaxed)
 end
 --[[
-  Function to check for the meta.paused key to decide if we are paused or not
+  Function to check if queue is paused or maxed
   (since an empty list and !EXISTS are not really the same).
 ]]
-local function isQueuePaused(queueMetaKey)
-    return rcall("HEXISTS", queueMetaKey, "paused") == 1
+local function isQueuePausedOrMaxed(queueMetaKey, activeKey)
+  local queueAttributes = rcall("HMGET", queueMetaKey, "paused", "concurrency")
+  if queueAttributes[1] then
+    return true
+  else
+    if queueAttributes[2] then
+      local activeCount = rcall("LLEN", activeKey)
+      return activeCount >= tonumber(queueAttributes[2])
+    end
+  end
+  return false
 end
 local function moveParentToWaitIfNeeded(parentQueueKey, parentDependenciesKey,
                                         parentKey, parentId, timestamp)
@@ -157,6 +177,7 @@ local function moveParentToWaitIfNeeded(parentQueueKey, parentDependenciesKey,
         rcall("ZREM", parentQueueKey .. ":waiting-children", parentId)
         local parentWaitKey = parentQueueKey .. ":wait"
         local parentPausedKey = parentQueueKey .. ":paused"
+        local parentActiveKey = parentQueueKey .. ":active"
         local parentMetaKey = parentQueueKey .. ":meta"
         local parentMarkerKey = parentQueueKey .. ":marker"
         local jobAttributes = rcall("HMGET", parentKey, "priority", "delay")
@@ -172,15 +193,16 @@ local function moveParentToWaitIfNeeded(parentQueueKey, parentDependenciesKey,
             addDelayMarkerIfNeeded(parentMarkerKey, parentDelayedKey)
         else
             if priority == 0 then
-                local parentTarget, isParentPaused =
-                    getTargetQueueList(parentMetaKey, parentWaitKey,
+                local parentTarget, isParentPausedOrMaxed =
+                    getTargetQueueList(parentMetaKey, parentActiveKey, parentWaitKey,
                                        parentPausedKey)
-                addJobInTargetList(parentTarget, parentMarkerKey, "RPUSH", isParentPaused, parentId)
+                addJobInTargetList(parentTarget, parentMarkerKey, "RPUSH", isParentPausedOrMaxed,
+                    parentId)
             else
-                local isPaused = isQueuePaused(parentMetaKey)
+                local isPausedOrMaxed = isQueuePausedOrMaxed(parentMetaKey, parentActiveKey)
                 addJobWithPriority(parentMarkerKey,
                                    parentQueueKey .. ":prioritized", priority,
-                                   parentId, parentQueueKey .. ":pc", isPaused)
+                                   parentId, parentQueueKey .. ":pc", isPausedOrMaxed)
             end
             rcall("XADD", parentQueueKey .. ":events", "*", "event", "waiting",
                   "jobId", parentId, "prev", "waiting-children")
@@ -276,10 +298,10 @@ end
 -- Store the job.
 storeJob(eventsKey, jobIdKey, jobId, args[3], ARGV[2], opts, timestamp,
          parentKey, parentData, repeatJobKey)
-local target, paused = getTargetQueueList(metaKey, KEYS[1], KEYS[2])
+local target, isPausedOrMaxed = getTargetQueueList(metaKey, KEYS[6], KEYS[1], KEYS[2])
 -- LIFO or FIFO
 local pushCmd = opts['lifo'] and 'RPUSH' or 'LPUSH'
-addJobInTargetList(target, KEYS[7], pushCmd, paused, jobId)
+addJobInTargetList(target, KEYS[8], pushCmd, isPausedOrMaxed, jobId)
 -- Emit waiting event
 rcall("XADD", eventsKey, "MAXLEN", "~", maxEvents, "*", "event", "waiting",
       "jobId", jobId)
@@ -292,6 +314,6 @@ return jobId .. "" -- convert to string
 exports.addStandardJob = {
     name: 'addStandardJob',
     content,
-    keys: 7,
+    keys: 8,
 };
-//# sourceMappingURL=addStandardJob-7.js.map
+//# sourceMappingURL=addStandardJob-8.js.map

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

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

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

@@ -8,8 +8,9 @@ const content = `--[[
     KEYS[2] 'paused'
     KEYS[3] 'meta'
     KEYS[4] 'prioritized'
-    KEYS[5] 'pc' priority counter
-    KEYS[6] 'marker'
+    KEYS[5] 'active'
+    KEYS[6] 'pc' priority counter
+    KEYS[7] 'marker'
     ARGV[1] priority value
     ARGV[2] job key
     ARGV[3] job id
@@ -30,35 +31,45 @@ local rcall = redis.call
 --[[
   Add marker if needed when a job is available.
 ]]
-local function addBaseMarkerIfNeeded(markerKey, isPaused)
-  if not isPaused then
+local function addBaseMarkerIfNeeded(markerKey, isPausedOrMaxed)
+  if not isPausedOrMaxed then
     rcall("ZADD", markerKey, 0, "0")
   end  
 end
-local function addJobInTargetList(targetKey, markerKey, pushCmd, isPaused, jobId)
+local function addJobInTargetList(targetKey, markerKey, pushCmd, isPausedOrMaxed, jobId)
   rcall(pushCmd, targetKey, jobId)
-  addBaseMarkerIfNeeded(markerKey, isPaused)
+  addBaseMarkerIfNeeded(markerKey, isPausedOrMaxed)
 end
 --[[
   Function to add job considering priority.
 ]]
 -- Includes
-local function addJobWithPriority(markerKey, prioritizedKey, priority, jobId, priorityCounterKey, isPaused)
+local function addJobWithPriority(markerKey, prioritizedKey, priority, jobId, priorityCounterKey,
+  isPausedOrMaxed)
   local prioCounter = rcall("INCR", priorityCounterKey)
   local score = priority * 0x100000000 + prioCounter % 0x100000000
   rcall("ZADD", prioritizedKey, score, jobId)
-  addBaseMarkerIfNeeded(markerKey, isPaused)
+  addBaseMarkerIfNeeded(markerKey, isPausedOrMaxed)
 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
+local function getTargetQueueList(queueMetaKey, activeKey, waitKey, pausedKey)
+  local queueAttributes = rcall("HMGET", queueMetaKey, "paused", "concurrency")
+  if queueAttributes[1] then
     return pausedKey, true
+  else
+    if queueAttributes[2] then
+      local activeCount = rcall("LLEN", activeKey)
+      if activeCount >= tonumber(queueAttributes[2]) then
+        return waitKey, true
+      else
+        return waitKey, false
+      end
+    end
   end
+  return waitKey, false
 end
 --[[
   Function to push back job considering priority in front of same prioritized jobs.
@@ -70,31 +81,32 @@ local function pushBackJobWithPriority(prioritizedKey, priority, jobId)
   rcall("ZADD", prioritizedKey, score, jobId)
 end
 local function reAddJobWithNewPriority( prioritizedKey, markerKey, targetKey,
-    priorityCounter, lifo, priority, jobId, paused)
+    priorityCounter, lifo, priority, jobId, isPausedOrMaxed)
     if priority == 0 then
         local pushCmd = lifo and 'RPUSH' or 'LPUSH'
-        addJobInTargetList(targetKey, markerKey, pushCmd, paused, jobId)
+        addJobInTargetList(targetKey, markerKey, pushCmd, isPausedOrMaxed, jobId)
     else
         if lifo then
             pushBackJobWithPriority(prioritizedKey, priority, jobId)
         else
             addJobWithPriority(markerKey, prioritizedKey, priority, jobId,
-                priorityCounter, paused)
+                priorityCounter, isPausedOrMaxed)
         end
     end
 end
 if rcall("EXISTS", jobKey) == 1 then
     local metaKey = KEYS[3]
-    local target, isPaused = getTargetQueueList(metaKey, KEYS[1], KEYS[2])
-    local markerKey = KEYS[6]
+    local target, isPausedOrMaxed = getTargetQueueList(metaKey, KEYS[5], KEYS[1], KEYS[2])
     local prioritizedKey = KEYS[4]
+    local priorityCounterKey = KEYS[6]
+    local markerKey = KEYS[7]
     -- Re-add with the new priority
     if rcall("ZREM", KEYS[4], jobId) > 0 then
         reAddJobWithNewPriority( prioritizedKey, markerKey, target,
-            KEYS[5], ARGV[4] == '1', priority, jobId, isPaused)
+            priorityCounterKey, ARGV[4] == '1', priority, jobId, isPausedOrMaxed)
     elseif rcall("LREM", target, -1, jobId) > 0 then
         reAddJobWithNewPriority( prioritizedKey, markerKey, target,
-            KEYS[5], ARGV[4] == '1', priority, jobId, isPaused)
+            priorityCounterKey, ARGV[4] == '1', priority, jobId, isPausedOrMaxed)
     end
     rcall("HSET", jobKey, "priority", priority)
     return 0
@@ -105,6 +117,6 @@ end
 exports.changePriority = {
     name: 'changePriority',
     content,
-    keys: 6,
+    keys: 7,
 };
-//# sourceMappingURL=changePriority-6.js.map
+//# sourceMappingURL=changePriority-7.js.map

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

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

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

@@ -70,14 +70,14 @@ end
 --[[
   Add marker if needed when a job is available.
 ]]
-local function addBaseMarkerIfNeeded(markerKey, isPaused)
-  if not isPaused then
+local function addBaseMarkerIfNeeded(markerKey, isPausedOrMaxed)
+  if not isPausedOrMaxed then
     rcall("ZADD", markerKey, 0, "0")
   end  
 end
-local function addJobInTargetList(targetKey, markerKey, pushCmd, isPaused, jobId)
+local function addJobInTargetList(targetKey, markerKey, pushCmd, isPausedOrMaxed, jobId)
   rcall(pushCmd, targetKey, jobId)
-  addBaseMarkerIfNeeded(markerKey, isPaused)
+  addBaseMarkerIfNeeded(markerKey, isPausedOrMaxed)
 end
 --[[
   Functions to destructure job key.
@@ -93,17 +93,26 @@ 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
+local function getTargetQueueList(queueMetaKey, activeKey, waitKey, pausedKey)
+  local queueAttributes = rcall("HMGET", queueMetaKey, "paused", "concurrency")
+  if queueAttributes[1] then
     return pausedKey, true
+  else
+    if queueAttributes[2] then
+      local activeCount = rcall("LLEN", activeKey)
+      if activeCount >= tonumber(queueAttributes[2]) then
+        return waitKey, true
+      else
+        return waitKey, false
+      end
+    end
   end
+  return waitKey, false
 end
 local function moveParentToWait(parentPrefix, parentId, emitEvent)
-  local parentTarget, isPaused = getTargetQueueList(parentPrefix .. "meta", parentPrefix .. "wait",
-    parentPrefix .. "paused")
-  addJobInTargetList(parentTarget, parentPrefix .. "marker", "RPUSH", isPaused, parentId)
+  local parentTarget, isPausedOrMaxed = getTargetQueueList(parentPrefix .. "meta", parentPrefix .. "active",
+    parentPrefix .. "wait", parentPrefix .. "paused")
+  addJobInTargetList(parentTarget, parentPrefix .. "marker", "RPUSH", isPausedOrMaxed, parentId)
   if emitEvent then
     local parentEventStream = parentPrefix .. "events"
     rcall("XADD", parentEventStream, "*", "event", "waiting", "jobId", parentId, "prev", "waiting-children")

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

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

package/dist/cjs/scripts/drain-4.js

@@ -45,14 +45,14 @@ end
 --[[
   Add marker if needed when a job is available.
 ]]
-local function addBaseMarkerIfNeeded(markerKey, isPaused)
-  if not isPaused then
+local function addBaseMarkerIfNeeded(markerKey, isPausedOrMaxed)
+  if not isPausedOrMaxed then
     rcall("ZADD", markerKey, 0, "0")
   end  
 end
-local function addJobInTargetList(targetKey, markerKey, pushCmd, isPaused, jobId)
+local function addJobInTargetList(targetKey, markerKey, pushCmd, isPausedOrMaxed, jobId)
   rcall(pushCmd, targetKey, jobId)
-  addBaseMarkerIfNeeded(markerKey, isPaused)
+  addBaseMarkerIfNeeded(markerKey, isPausedOrMaxed)
 end
 --[[
   Functions to destructure job key.
@@ -68,17 +68,26 @@ 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
+local function getTargetQueueList(queueMetaKey, activeKey, waitKey, pausedKey)
+  local queueAttributes = rcall("HMGET", queueMetaKey, "paused", "concurrency")
+  if queueAttributes[1] then
     return pausedKey, true
+  else
+    if queueAttributes[2] then
+      local activeCount = rcall("LLEN", activeKey)
+      if activeCount >= tonumber(queueAttributes[2]) then
+        return waitKey, true
+      else
+        return waitKey, false
+      end
+    end
   end
+  return waitKey, false
 end
 local function moveParentToWait(parentPrefix, parentId, emitEvent)
-  local parentTarget, isPaused = getTargetQueueList(parentPrefix .. "meta", parentPrefix .. "wait",
-    parentPrefix .. "paused")
-  addJobInTargetList(parentTarget, parentPrefix .. "marker", "RPUSH", isPaused, parentId)
+  local parentTarget, isPausedOrMaxed = getTargetQueueList(parentPrefix .. "meta", parentPrefix .. "active",
+    parentPrefix .. "wait", parentPrefix .. "paused")
+  addJobInTargetList(parentTarget, parentPrefix .. "marker", "RPUSH", isPausedOrMaxed, parentId)
   if emitEvent then
     local parentEventStream = parentPrefix .. "events"
     rcall("XADD", parentEventStream, "*", "event", "waiting", "jobId", parentId, "prev", "waiting-children")

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

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

package/dist/cjs/scripts/getCountsPerPriority-4.js

@@ -20,18 +20,17 @@ local prioritizedKey = KEYS[4]
   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
+local function isQueuePaused(queueMetaKey)
+  return rcall("HEXISTS", queueMetaKey, "paused") == 1
 end
 for i = 1, #ARGV do
   local priority = tonumber(ARGV[i])
   if priority == 0 then
-    local target = getTargetQueueList(KEYS[3], waitKey, pausedKey)
-    results[#results+1] = rcall("LLEN", target)
+    if isQueuePaused(KEYS[3]) then
+      results[#results+1] = rcall("LLEN", pausedKey)
+    else
+      results[#results+1] = rcall("LLEN", waitKey)
+    end
   else
     results[#results+1] = rcall("ZCOUNT", prioritizedKey,
       priority * 0x100000000, (priority + 1)  * 0x100000000 - 1)

package/dist/cjs/scripts/getCountsPerPriority-4.js.map

@@ -1 +1 @@
-{"version":3,"file":"getCountsPerPriority-4.js","sourceRoot":"","sources":["../../../src/scripts/getCountsPerPriority-4.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqCf,CAAC;AACW,QAAA,oBAAoB,GAAG;IAClC,IAAI,EAAE,sBAAsB;IAC5B,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}
+{"version":3,"file":"getCountsPerPriority-4.js","sourceRoot":"","sources":["../../../src/scripts/getCountsPerPriority-4.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoCf,CAAC;AACW,QAAA,oBAAoB,GAAG;IAClC,IAAI,EAAE,sBAAsB;IAC5B,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

package/dist/cjs/scripts/index.js

@@ -4,10 +4,11 @@ const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./addDelayedJob-6"), exports);
 tslib_1.__exportStar(require("./addLog-2"), exports);
 tslib_1.__exportStar(require("./addParentJob-4"), exports);
-tslib_1.__exportStar(require("./addPrioritizedJob-7"), exports);
-tslib_1.__exportStar(require("./addStandardJob-7"), exports);
+tslib_1.__exportStar(require("./addPrioritizedJob-8"), exports);
+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-6"), 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("./extendLock-2"), exports);
@@ -19,8 +20,9 @@ tslib_1.__exportStar(require("./getState-8"), exports);
 tslib_1.__exportStar(require("./getStateV2-8"), exports);
 tslib_1.__exportStar(require("./isFinished-3"), exports);
 tslib_1.__exportStar(require("./isJobInList-1"), exports);
+tslib_1.__exportStar(require("./isMaxed-2"), exports);
 tslib_1.__exportStar(require("./moveJobFromActiveToWait-10"), exports);
-tslib_1.__exportStar(require("./moveJobsToWait-7"), exports);
+tslib_1.__exportStar(require("./moveJobsToWait-8"), exports);
 tslib_1.__exportStar(require("./moveStalledJobsToWait-9"), exports);
 tslib_1.__exportStar(require("./moveToActive-11"), exports);
 tslib_1.__exportStar(require("./moveToDelayed-8"), exports);
@@ -29,12 +31,12 @@ tslib_1.__exportStar(require("./moveToWaitingChildren-5"), exports);
 tslib_1.__exportStar(require("./obliterate-2"), exports);
 tslib_1.__exportStar(require("./paginate-1"), exports);
 tslib_1.__exportStar(require("./pause-7"), exports);
-tslib_1.__exportStar(require("./promote-8"), exports);
+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-1"), exports);
+tslib_1.__exportStar(require("./removeJob-2"), exports);
 tslib_1.__exportStar(require("./removeRepeatable-2"), exports);
-tslib_1.__exportStar(require("./reprocessJob-7"), exports);
+tslib_1.__exportStar(require("./reprocessJob-8"), exports);
 tslib_1.__exportStar(require("./retryJob-11"), exports);
 tslib_1.__exportStar(require("./saveStacktrace-1"), exports);
 tslib_1.__exportStar(require("./updateData-1"), 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,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,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"}
+{"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"}

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMaxed = void 0;
+const content = `--[[
+  Checks if queue is maxed.
+  Input:
+    KEYS[1] meta key
+    KEYS[2] active key
+  Output:
+    1 if element found in the list.
+]]
+local rcall = redis.call
+-- Includes
+--[[
+  Function to check if queue is maxed or not.
+]]
+local function isQueueMaxed(queueMetaKey, activeKey)
+  local maxConcurrency = rcall("HGET", queueMetaKey, "concurrency")
+  if maxConcurrency then
+    local activeCount = rcall("LLEN", activeKey)
+    if activeCount >= tonumber(maxConcurrency) then
+      return true
+    end
+  end
+  return false
+end
+return isQueueMaxed(KEYS[1], KEYS[2])
+`;
+exports.isMaxed = {
+    name: 'isMaxed',
+    content,
+    keys: 2,
+};
+//# sourceMappingURL=isMaxed-2.js.map

package/dist/cjs/scripts/isMaxed-2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isMaxed-2.js","sourceRoot":"","sources":["../../../src/scripts/isMaxed-2.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;CAwBf,CAAC;AACW,QAAA,OAAO,GAAG;IACrB,IAAI,EAAE,SAAS;IACf,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

package/dist/cjs/scripts/moveJobFromActiveToWait-10.js

@@ -27,14 +27,14 @@ local rcall = redis.call
 --[[
   Add marker if needed when a job is available.
 ]]
-local function addBaseMarkerIfNeeded(markerKey, isPaused)
-  if not isPaused then
+local function addBaseMarkerIfNeeded(markerKey, isPausedOrMaxed)
+  if not isPausedOrMaxed then
     rcall("ZADD", markerKey, 0, "0")
   end  
 end
-local function addJobInTargetList(targetKey, markerKey, pushCmd, isPaused, jobId)
+local function addJobInTargetList(targetKey, markerKey, pushCmd, isPausedOrMaxed, jobId)
   rcall(pushCmd, targetKey, jobId)
-  addBaseMarkerIfNeeded(markerKey, isPaused)
+  addBaseMarkerIfNeeded(markerKey, isPausedOrMaxed)
 end
 --[[
   Function to push back job considering priority in front of same prioritized jobs.
@@ -60,12 +60,21 @@ 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
+local function getTargetQueueList(queueMetaKey, activeKey, waitKey, pausedKey)
+  local queueAttributes = rcall("HMGET", queueMetaKey, "paused", "concurrency")
+  if queueAttributes[1] then
     return pausedKey, true
+  else
+    if queueAttributes[2] then
+      local activeCount = rcall("LLEN", activeKey)
+      if activeCount >= tonumber(queueAttributes[2]) then
+        return waitKey, true
+      else
+        return waitKey, false
+      end
+    end
   end
+  return waitKey, false
 end
 local jobId = ARGV[1]
 local token = ARGV[2]
@@ -76,13 +85,13 @@ if lockToken == token then
   local metaKey = KEYS[6]
   local removed = rcall("LREM", KEYS[1], 1, jobId)
   if removed > 0 then
-    local target, isPaused = getTargetQueueList(metaKey, KEYS[2], KEYS[5])
+    local target, isPausedOrMaxed = getTargetQueueList(metaKey, KEYS[1], KEYS[2], KEYS[5])
     rcall("SREM", KEYS[3], jobId)
     local priority = tonumber(rcall("HGET", ARGV[3], "priority")) or 0
     if priority > 0 then
       pushBackJobWithPriority(KEYS[8], priority, jobId)
     else
-      addJobInTargetList(target, KEYS[9], "RPUSH", isPaused, jobId)
+      addJobInTargetList(target, KEYS[9], "RPUSH", isPausedOrMaxed, jobId)
     end
     rcall("DEL", lockKey)
     local maxEvents = getOrSetMaxEvents(metaKey)

package/dist/cjs/scripts/moveJobFromActiveToWait-10.js.map

@@ -1 +1 @@
-{"version":3,"file":"moveJobFromActiveToWait-10.js","sourceRoot":"","sources":["../../../src/scripts/moveJobFromActiveToWait-10.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2Ff,CAAC;AACW,QAAA,uBAAuB,GAAG;IACrC,IAAI,EAAE,yBAAyB;IAC/B,OAAO;IACP,IAAI,EAAE,EAAE;CACT,CAAC"}
+{"version":3,"file":"moveJobFromActiveToWait-10.js","sourceRoot":"","sources":["../../../src/scripts/moveJobFromActiveToWait-10.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoGf,CAAC;AACW,QAAA,uBAAuB,GAAG;IACrC,IAAI,EAAE,yBAAyB;IAC/B,OAAO;IACP,IAAI,EAAE,EAAE;CACT,CAAC"}

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

@@ -11,7 +11,8 @@ const content = `--[[
     KEYS[4] 'wait'
     KEYS[5] 'paused'
     KEYS[6] 'meta'
-    KEYS[7] 'marker'
+    KEYS[7] 'active'
+    KEYS[8] 'marker'
     ARGV[1] count
     ARGV[2] timestamp
     ARGV[3] prev state
@@ -26,8 +27,8 @@ local rcall = redis.call;
 --[[
   Add marker if needed when a job is available.
 ]]
-local function addBaseMarkerIfNeeded(markerKey, isPaused)
-  if not isPaused then
+local function addBaseMarkerIfNeeded(markerKey, isPausedOrMaxed)
+  if not isPausedOrMaxed then
     rcall("ZADD", markerKey, 0, "0")
   end  
 end
@@ -62,15 +63,24 @@ 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
+local function getTargetQueueList(queueMetaKey, activeKey, waitKey, pausedKey)
+  local queueAttributes = rcall("HMGET", queueMetaKey, "paused", "concurrency")
+  if queueAttributes[1] then
     return pausedKey, true
+  else
+    if queueAttributes[2] then
+      local activeCount = rcall("LLEN", activeKey)
+      if activeCount >= tonumber(queueAttributes[2]) then
+        return waitKey, true
+      else
+        return waitKey, false
+      end
+    end
   end
+  return waitKey, false
 end
 local metaKey = KEYS[6]
-local target, paused = getTargetQueueList(metaKey, KEYS[4], KEYS[5])
+local target, isPausedOrMaxed = getTargetQueueList(metaKey, KEYS[7], KEYS[4], KEYS[5])
 local jobs = rcall('ZRANGEBYSCORE', KEYS[3], 0, timestamp, 'LIMIT', 0, maxCount)
 if (#jobs > 0) then
     if ARGV[3] == "failed" then
@@ -94,7 +104,7 @@ if (#jobs > 0) then
         rcall("ZREM", KEYS[3], unpack(jobs, from, to))
         rcall("LPUSH", target, unpack(jobs, from, to))
     end
-    addBaseMarkerIfNeeded(KEYS[7], paused)
+    addBaseMarkerIfNeeded(KEYS[8], isPausedOrMaxed)
 end
 maxCount = maxCount - #jobs
 if (maxCount <= 0) then return 1 end
@@ -103,6 +113,6 @@ return 0
 exports.moveJobsToWait = {
     name: 'moveJobsToWait',
     content,
-    keys: 7,
+    keys: 8,
 };
-//# sourceMappingURL=moveJobsToWait-7.js.map
+//# sourceMappingURL=moveJobsToWait-8.js.map

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

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