bullmq 5.8.7 → 5.10.0

package/dist/{esm/commands/removeJob-1.lua → cjs/commands/removeJob-2.lua}

@@ -4,6 +4,7 @@
 
     Input:
       KEYS[1] queue prefix
+      KEYS[2] meta key
 
       ARGV[1] jobId
       ARGV[2] remove children
@@ -66,7 +67,7 @@ local function removeJob( prefix, jobId, parentKey, removeChildren)
     local prev = removeJobFromAnyState(prefix, jobId)
 
     if removeJobKeys(jobKey) > 0 then
-        local maxEvents = getOrSetMaxEvents(prefix .. "meta")
+        local maxEvents = getOrSetMaxEvents(KEYS[2])
         rcall("XADD", prefix .. "events", "MAXLEN", "~", maxEvents, "*", "event", "removed",
             "jobId", jobId, "prev", prev)
     end

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

@@ -5,9 +5,10 @@
     KEYS[1] repeat jobs key
     KEYS[2] delayed jobs key
 
-    ARGV[1] repeat job id
-    ARGV[2] repeat job key
-    ARGV[3] queue key
+    ARGV[1] old repeat job id
+    ARGV[2] options concat
+    ARGV[3] repeat job key
+    ARGV[4] prefix key
 
   Output:
     0 - OK
@@ -19,12 +20,16 @@
 local rcall = redis.call
 local millis = rcall("ZSCORE", KEYS[1], ARGV[2])
 
-if(millis) then
+-- Includes
+--- @include "includes/removeJobKeys"
+
+-- legacy removal TODO: remove in next breaking change
+if millis then
   -- Delete next programmed job.
   local repeatJobId = ARGV[1] .. millis
   if(rcall("ZREM", KEYS[2], repeatJobId) == 1) then
-    rcall("DEL", ARGV[3] .. repeatJobId)
-    rcall("XADD", ARGV[3] .. "events", "*", "event", "removed", "jobId", repeatJobId, "prev", "delayed");
+    removeJobKeys(ARGV[4] .. repeatJobId)
+    rcall("XADD", ARGV[4] .. "events", "*", "event", "removed", "jobId", repeatJobId, "prev", "delayed");
   end
 end
 
@@ -32,4 +37,20 @@ if(rcall("ZREM", KEYS[1], ARGV[2]) == 1) then
   return 0
 end
 
+-- new removal
+millis = rcall("ZSCORE", KEYS[1], ARGV[3])
+
+if millis then
+  -- Delete next programmed job.
+  local repeatJobId = "repeat:" .. ARGV[3] .. ":" .. millis
+  if(rcall("ZREM", KEYS[2], repeatJobId) == 1) then
+    removeJobKeys(ARGV[4] .. repeatJobId)
+    rcall("XADD", ARGV[4] .. "events", "*", "event", "removed", "jobId", repeatJobId, "prev", "delayed");
+  end
+end
+
+if(rcall("ZREM", KEYS[1], ARGV[3]) == 1) then
+  return 0
+end
+
 return 1

package/dist/{esm/commands/reprocessJob-7.lua → cjs/commands/reprocessJob-8.lua}

@@ -8,7 +8,8 @@
     KEYS[4] wait key
     KEYS[5] meta
     KEYS[6] paused key
-    KEYS[7] marker key
+    KEYS[7] active key
+    KEYS[8] marker key
 
     ARGV[1] job.id
     ARGV[2] (job.opts.lifo ? 'R' : 'L') + 'PUSH'
@@ -32,8 +33,8 @@ if rcall("EXISTS", KEYS[1]) == 1 then
   if (rcall("ZREM", KEYS[3], jobId) == 1) then
     rcall("HDEL", KEYS[1], "finishedOn", "processedOn", ARGV[3])
 
-    local target, isPaused = getTargetQueueList(KEYS[5], KEYS[4], KEYS[6])
-    addJobInTargetList(target, KEYS[7], ARGV[2], isPaused, jobId)
+    local target, isPausedOrMaxed = getTargetQueueList(KEYS[5], KEYS[7], KEYS[4], KEYS[6])
+    addJobInTargetList(target, KEYS[8], ARGV[2], isPausedOrMaxed, jobId)
 
     local maxEvents = getOrSetMaxEvents(KEYS[5])
     -- Emit waiting event

package/dist/cjs/commands/retryJob-11.lua

@@ -38,13 +38,14 @@ local rcall = redis.call
 --- @include "includes/getTargetQueueList"
 --- @include "includes/promoteDelayedJobs"
 --- @include "includes/removeLock"
+--- @include "includes/isQueuePausedOrMaxed"
 
-local target, paused = getTargetQueueList(KEYS[5], KEYS[2], KEYS[3])
+local target, isPausedOrMaxed = getTargetQueueList(KEYS[5], KEYS[1], KEYS[2], KEYS[3])
 local markerKey = KEYS[10]
 
 -- Check if there are delayed jobs that we can move to wait.
 -- test example: when there are delayed jobs between retries
-promoteDelayedJobs(KEYS[7], markerKey, target, KEYS[8], KEYS[6], ARGV[1], ARGV[2], KEYS[9], paused)
+promoteDelayedJobs(KEYS[7], markerKey, target, KEYS[8], KEYS[6], ARGV[1], ARGV[2], KEYS[9], isPausedOrMaxed)
 
 if rcall("EXISTS", KEYS[4]) == 1 then
   local errorCode = removeLock(KEYS[4], KEYS[11], ARGV[5], ARGV[4]) 
@@ -57,11 +58,14 @@ if rcall("EXISTS", KEYS[4]) == 1 then
 
   local priority = tonumber(rcall("HGET", KEYS[4], "priority")) or 0
 
+  --need to re-evaluate after removing job from active
+  isPausedOrMaxed = isQueuePausedOrMaxed(KEYS[5], KEYS[1])
+
   -- Standard or priority add
   if priority == 0 then
-    addJobInTargetList(target, KEYS[10], ARGV[3], paused, ARGV[4])
+    addJobInTargetList(target, markerKey, ARGV[3], isPausedOrMaxed, ARGV[4])
   else
-    addJobWithPriority(markerKey, KEYS[8], priority, ARGV[4], KEYS[9], paused)
+    addJobWithPriority(markerKey, KEYS[8], priority, ARGV[4], KEYS[9], isPausedOrMaxed)
   end
 
   rcall("HINCRBY", KEYS[4], "atm", 1)

package/dist/cjs/interfaces/index.js

@@ -20,6 +20,7 @@ tslib_1.__exportStar(require("./rate-limiter-options"), exports);
 tslib_1.__exportStar(require("./redis-options"), exports);
 tslib_1.__exportStar(require("./redis-streams"), exports);
 tslib_1.__exportStar(require("./repeatable-job"), exports);
+tslib_1.__exportStar(require("./repeatable-options"), exports);
 tslib_1.__exportStar(require("./repeat-options"), exports);
 tslib_1.__exportStar(require("./sandboxed-job-processor"), exports);
 tslib_1.__exportStar(require("./sandboxed-job"), exports);

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

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/interfaces/index.ts"],"names":[],"mappings":";;;AAAA,6DAAmC;AACnC,4DAAkC;AAClC,6DAAmC;AACnC,0DAAgC;AAChC,uDAA6B;AAC7B,qDAA2B;AAC3B,2DAAiC;AACjC,qDAA2B;AAC3B,sDAA4B;AAC5B,4DAAkC;AAClC,oDAA0B;AAC1B,wDAA8B;AAC9B,2DAAiC;AACjC,mDAAyB;AACzB,0DAAgC;AAChC,iEAAuC;AACvC,0DAAgC;AAChC,0DAAgC;AAChC,2DAAiC;AACjC,2DAAiC;AACjC,oEAA0C;AAC1C,0DAAgC;AAChC,2DAAiC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/interfaces/index.ts"],"names":[],"mappings":";;;AAAA,6DAAmC;AACnC,4DAAkC;AAClC,6DAAmC;AACnC,0DAAgC;AAChC,uDAA6B;AAC7B,qDAA2B;AAC3B,2DAAiC;AACjC,qDAA2B;AAC3B,sDAA4B;AAC5B,4DAAkC;AAClC,oDAA0B;AAC1B,wDAA8B;AAC9B,2DAAiC;AACjC,mDAAyB;AACzB,0DAAgC;AAChC,iEAAuC;AACvC,0DAAgC;AAChC,0DAAgC;AAChC,2DAAiC;AACjC,+DAAqC;AACrC,2DAAiC;AACjC,oEAA0C;AAC1C,0DAAgC;AAChC,2DAAiC"}

package/dist/cjs/interfaces/repeatable-options.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=repeatable-options.js.map

package/dist/cjs/interfaces/repeatable-options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"repeatable-options.js","sourceRoot":"","sources":["../../../src/interfaces/repeatable-options.ts"],"names":[],"mappings":""}

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

@@ -131,42 +131,61 @@ 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
 --[[
   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
 --[[
   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 moveParentToWaitIfNeeded(parentQueueKey, parentDependenciesKey,
                                         parentKey, parentId, timestamp)
@@ -176,6 +195,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")
@@ -191,15 +211,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")

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

@@ -1 +1 @@
-{"version":3,"file":"addDelayedJob-6.js","sourceRoot":"","sources":["../../../src/scripts/addDelayedJob-6.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmTf,CAAC;AACW,QAAA,aAAa,GAAG;IAC3B,IAAI,EAAE,eAAe;IACrB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}
+{"version":3,"file":"addDelayedJob-6.js","sourceRoot":"","sources":["../../../src/scripts/addDelayedJob-6.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwUf,CAAC;AACW,QAAA,aAAa,GAAG;IAC3B,IAAI,EAAE,eAAe;IACrB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

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

@@ -103,42 +103,61 @@ 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
 --[[
   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
 --[[
   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 moveParentToWaitIfNeeded(parentQueueKey, parentDependenciesKey,
                                         parentKey, parentId, timestamp)
@@ -148,6 +167,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")
@@ -163,15 +183,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")

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

@@ -1 +1 @@
-{"version":3,"file":"addParentJob-4.js","sourceRoot":"","sources":["../../../src/scripts/addParentJob-4.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkRf,CAAC;AACW,QAAA,YAAY,GAAG;IAC1B,IAAI,EAAE,cAAc;IACpB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}
+{"version":3,"file":"addParentJob-4.js","sourceRoot":"","sources":["../../../src/scripts/addParentJob-4.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuSf,CAAC;AACW,QAAA,YAAY,GAAG;IAC1B,IAAI,EAAE,cAAc;IACpB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

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

@@ -12,8 +12,9 @@ const content = `--[[
       KEYS[3] 'id'
       KEYS[4] 'prioritized'
       KEYS[5] 'completed'
-      KEYS[6] events stream key
-      KEYS[7] 'pc' priority counter
+      KEYS[6] 'active'
+      KEYS[7] events stream key
+      KEYS[8] 'pc' priority counter
       ARGV[1] msgpacked arguments array
             [1]  key prefix,
             [2]  custom id (will not generate one automatically)
@@ -34,8 +35,9 @@ 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 activeKey = KEYS[6]
+local eventsKey = KEYS[7]
+local priorityCounterKey = KEYS[8]
 local jobId
 local jobIdKey
 local rcall = redis.call
@@ -54,16 +56,17 @@ 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 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 store a job
@@ -148,27 +151,45 @@ end
   Function to add job in target list and add marker if needed.
 ]]
 -- Includes
-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 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
 --[[
   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 moveParentToWaitIfNeeded(parentQueueKey, parentDependenciesKey,
                                         parentKey, parentId, timestamp)
@@ -178,6 +199,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")
@@ -193,15 +215,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")
@@ -273,8 +296,8 @@ local delay, priority = storeJob(eventsKey, jobIdKey, jobId, args[3], ARGV[2],
                                  opts, timestamp, parentKey, parentData,
                                  repeatJobKey)
 -- Add the job to the prioritized set
-local isPause = isQueuePaused(metaKey)
-addJobWithPriority( KEYS[1], priorityKey, priority, jobId, priorityCounterKey, isPause)
+local isPausedOrMaxed = isQueuePausedOrMaxed(metaKey, activeKey)
+addJobWithPriority( KEYS[1], priorityKey, priority, jobId, priorityCounterKey, isPausedOrMaxed)
 -- Emit waiting event
 rcall("XADD", eventsKey, "MAXLEN", "~", maxEvents, "*", "event", "waiting",
       "jobId", jobId)
@@ -287,6 +310,6 @@ return jobId .. "" -- convert to string
 exports.addPrioritizedJob = {
     name: 'addPrioritizedJob',
     content,
-    keys: 7,
+    keys: 8,
 };
-//# sourceMappingURL=addPrioritizedJob-7.js.map
+//# sourceMappingURL=addPrioritizedJob-8.js.map

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

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

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

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addRepeatableJob = void 0;
+const content = `--[[
+  Adds a repeatable job
+    Input:
+      KEYS[1] 'repeat' key
+      KEYS[2] custom key
+      ARGV[1] next milliseconds
+      ARGV[2] msgpacked options
+            [1]  name
+            [2]  tz?
+            [3]  patten?
+            [4]  endDate?
+            [5]  every?
+      ARGV[3] legacy custom key TODO: remove this logic in next breaking change
+      ARGV[4] skipCheckExists
+      Output:
+        repeatableKey  - OK
+]]
+local rcall = redis.call
+local repeatKey = KEYS[1]
+local customKey = KEYS[2]
+local legacyCustomKey = ARGV[3]
+local nextMilli = ARGV[1]
+local function storeRepeatableJob(repeatKey, customKey, nextMilli, rawOpts)
+  rcall("ZADD", repeatKey, nextMilli, customKey)
+  local opts = cmsgpack.unpack(rawOpts)
+  local optionalValues = {}
+  if opts['tz'] then
+    table.insert(optionalValues, "tz")
+    table.insert(optionalValues, opts['tz'])
+  end
+  if opts['pattern'] then
+    table.insert(optionalValues, "pattern")
+    table.insert(optionalValues, opts['pattern'])
+  end
+  if opts['endDate'] then
+    table.insert(optionalValues, "endDate")
+    table.insert(optionalValues, opts['endDate'])
+  end
+  if opts['every'] then
+    table.insert(optionalValues, "every")
+    table.insert(optionalValues, opts['every'])
+  end
+  rcall("HMSET", repeatKey .. ":" .. customKey, "name", opts['name'],
+    unpack(optionalValues))
+  return customKey
+end
+if ARGV[4] == '0' then
+  if rcall("ZSCORE", repeatKey, legacyCustomKey) ~= false then
+    rcall("ZADD", repeatKey, nextMilli, legacyCustomKey)
+    return legacyCustomKey
+  elseif rcall("ZSCORE", repeatKey, customKey) ~= false then
+    return storeRepeatableJob(repeatKey, customKey, nextMilli, ARGV[2])
+  end
+else
+  return storeRepeatableJob(repeatKey, customKey, nextMilli, ARGV[2])
+end
+return ''`;
+exports.addRepeatableJob = {
+    name: 'addRepeatableJob',
+    content,
+    keys: 2,
+};
+//# sourceMappingURL=addRepeatableJob-2.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"addRepeatableJob-2.js","sourceRoot":"","sources":["../../../src/scripts/addRepeatableJob-2.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAwDN,CAAC;AACE,QAAA,gBAAgB,GAAG;IAC9B,IAAI,EAAE,kBAAkB;IACxB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}