bullmq 3.14.2 → 3.15.1

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

@@ -57,9 +57,9 @@ end
 ]]
 local function getTargetQueueList(queueMetaKey, waitKey, pausedKey)
   if rcall("HEXISTS", queueMetaKey, "paused") ~= 1 then
-    return waitKey
+    return waitKey, false
   else
-    return pausedKey
+    return pausedKey, true
   end
 end
 --[[

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

@@ -43,16 +43,11 @@ local rcall = redis.call
     opts - lockDuration
     opts - limiter
 ]]
-local function moveJobFromWaitToActive(keys, keyPrefix, jobId, processedOn, opts)
+local function moveJobFromWaitToActive(keys, keyPrefix, targetKey, jobId, processedOn,
+    maxJobs, expireTime, opts)
   -- Check if we need to perform rate limiting.
-  local maxJobs = tonumber(opts['limiter'] and opts['limiter']['max'])
-  local expireTime
-  if(maxJobs) then
+  if maxJobs then
     local rateLimiterKey = keys[6];
-    expireTime = tonumber(rcall("PTTL", rateLimiterKey))
-    if expireTime <= 0 then
-      rcall("DEL", rateLimiterKey)
-    end
     local jobCounter = tonumber(rcall("INCR", rateLimiterKey))
     if jobCounter == 1 then
       local limiterDuration = opts['limiter'] and opts['limiter']['duration']
@@ -60,12 +55,12 @@ local function moveJobFromWaitToActive(keys, keyPrefix, jobId, processedOn, opts
       rcall("PEXPIRE", rateLimiterKey, integerDuration)
     end
     -- check if we passed rate limit, we need to remove the job and return expireTime
-    if jobCounter > maxJobs then      
+    if expireTime > 0 then
       -- remove from active queue and add back to the wait list
       rcall("LREM", keys[2], 1, jobId)
-      rcall("RPUSH", keys[1], jobId)
+      rcall("RPUSH", targetKey, jobId)
       -- Return when we can process more jobs
-      return {0, 0, expireTime}
+      return {0, 0, expireTime, 0}
     end
   end
   local jobKey = keyPrefix .. jobId
@@ -78,7 +73,7 @@ local function moveJobFromWaitToActive(keys, keyPrefix, jobId, processedOn, opts
   rcall("XADD", keys[4], "*", "event", "active", "jobId", jobId, "prev", "waiting")
   rcall("HSET", jobKey, "processedOn", processedOn)
   rcall("HINCRBY", jobKey, "attemptsMade", 1)
-  return {rcall("HGETALL", jobKey), jobId, expireTime} -- get job data
+  return {rcall("HGETALL", jobKey), jobId, 0, 0} -- get job data
 end
 --[[
   Function to return the next delayed job timestamp.
@@ -93,13 +88,15 @@ local function getNextDelayedTimestamp(delayedKey)
     return nextTimestamp
   end
 end
-local function getRateLimitTTL(opts, limiterKey)
-  local maxJobs = tonumber(opts['limiter'] and opts['limiter']['max'])
+local function getRateLimitTTL(maxJobs, rateLimiterKey)
   if maxJobs then
-    local jobCounter = tonumber(rcall("GET", limiterKey))
-    if jobCounter ~= nil and jobCounter >= maxJobs then
-      local pttl = rcall("PTTL", limiterKey)
-      if pttl > 0 then 
+    local pttl = rcall("PTTL", rateLimiterKey)
+    if pttl <= 0 then
+      rcall("DEL", rateLimiterKey)
+    end
+    local jobCounter = tonumber(rcall("GET", rateLimiterKey) or 0)
+    if jobCounter >= maxJobs then
+      if pttl > 0 then
         return pttl
       end
     end
@@ -112,9 +109,9 @@ end
 ]]
 local function getTargetQueueList(queueMetaKey, waitKey, pausedKey)
   if rcall("HEXISTS", queueMetaKey, "paused") ~= 1 then
-    return waitKey
+    return waitKey, false
   else
-    return pausedKey
+    return pausedKey, true
   end
 end
 --[[
@@ -163,17 +160,17 @@ end
 local target = getTargetQueueList(KEYS[9], KEYS[1], KEYS[8])
 -- Check if there are delayed jobs that we can move to wait.
 promoteDelayedJobs(KEYS[7], target, KEYS[3], KEYS[4], ARGV[1], ARGV[2])
-local opts
+local opts = cmsgpack.unpack(ARGV[4])
+local maxJobs = tonumber(opts['limiter'] and opts['limiter']['max'])
+local expireTime = getRateLimitTTL(maxJobs, KEYS[6])
 if (ARGV[3] ~= "") then
   jobId = ARGV[3]
   -- clean stalled key
   rcall("SREM", KEYS[5], jobId)
 else
   -- Check if we are rate limited first.
-  opts = cmsgpack.unpack(ARGV[4])
-  local pttl = getRateLimitTTL(opts, KEYS[6])
-  if pttl > 0 then
-    return { 0, 0, pttl }
+  if expireTime > 0 then
+    return { 0, 0, expireTime, 0 }
   end
   -- no job ID, try non-blocking move from wait to active
   jobId = rcall("RPOPLPUSH", KEYS[1], KEYS[2])
@@ -182,6 +179,9 @@ end
 if jobId then
   if string.sub(jobId, 1, 2) == "0:" then
     rcall("LREM", KEYS[2], 1, jobId)
+    if expireTime > 0 then
+      return { 0, 0, expireTime, 0 }
+    end
     -- Move again since we just got the marker job.
     jobId = rcall("RPOPLPUSH", KEYS[1], KEYS[2])
     -- Since it is possible that between a call to BRPOPLPUSH and moveToActive
@@ -192,9 +192,8 @@ if jobId then
     end
   end
   if jobId then
-    opts = opts or cmsgpack.unpack(ARGV[4])
     -- this script is not really moving, it is preparing the job for processing
-    return moveJobFromWaitToActive(KEYS, ARGV[1], jobId, ARGV[2], opts)
+    return moveJobFromWaitToActive(KEYS, ARGV[1], target, jobId, ARGV[2], maxJobs, expireTime, opts)
   end
 end
 -- Return the timestamp for the next delayed job if any.
@@ -202,6 +201,7 @@ local nextTimestamp = getNextDelayedTimestamp(KEYS[7])
 if (nextTimestamp ~= nil) then
   return { 0, 0, 0, nextTimestamp}
 end
+return { 0, 0, 0, 0}
 `;
 export const moveToActive = {
     name: 'moveToActive',

package/dist/esm/scripts/moveToDelayed-8.js

@@ -54,9 +54,9 @@ end
 ]]
 local function getTargetQueueList(queueMetaKey, waitKey, pausedKey)
   if rcall("HEXISTS", queueMetaKey, "paused") ~= 1 then
-    return waitKey
+    return waitKey, false
   else
-    return pausedKey
+    return pausedKey, true
   end
 end
 --[[

package/dist/esm/scripts/moveToFinished-12.js

@@ -127,16 +127,11 @@ end
     opts - lockDuration
     opts - limiter
 ]]
-local function moveJobFromWaitToActive(keys, keyPrefix, jobId, processedOn, opts)
+local function moveJobFromWaitToActive(keys, keyPrefix, targetKey, jobId, processedOn,
+    maxJobs, expireTime, opts)
   -- Check if we need to perform rate limiting.
-  local maxJobs = tonumber(opts['limiter'] and opts['limiter']['max'])
-  local expireTime
-  if(maxJobs) then
+  if maxJobs then
     local rateLimiterKey = keys[6];
-    expireTime = tonumber(rcall("PTTL", rateLimiterKey))
-    if expireTime <= 0 then
-      rcall("DEL", rateLimiterKey)
-    end
     local jobCounter = tonumber(rcall("INCR", rateLimiterKey))
     if jobCounter == 1 then
       local limiterDuration = opts['limiter'] and opts['limiter']['duration']
@@ -144,12 +139,12 @@ local function moveJobFromWaitToActive(keys, keyPrefix, jobId, processedOn, opts
       rcall("PEXPIRE", rateLimiterKey, integerDuration)
     end
     -- check if we passed rate limit, we need to remove the job and return expireTime
-    if jobCounter > maxJobs then      
+    if expireTime > 0 then
       -- remove from active queue and add back to the wait list
       rcall("LREM", keys[2], 1, jobId)
-      rcall("RPUSH", keys[1], jobId)
+      rcall("RPUSH", targetKey, jobId)
       -- Return when we can process more jobs
-      return {0, 0, expireTime}
+      return {0, 0, expireTime, 0}
     end
   end
   local jobKey = keyPrefix .. jobId
@@ -162,7 +157,7 @@ local function moveJobFromWaitToActive(keys, keyPrefix, jobId, processedOn, opts
   rcall("XADD", keys[4], "*", "event", "active", "jobId", jobId, "prev", "waiting")
   rcall("HSET", jobKey, "processedOn", processedOn)
   rcall("HINCRBY", jobKey, "attemptsMade", 1)
-  return {rcall("HGETALL", jobKey), jobId, expireTime} -- get job data
+  return {rcall("HGETALL", jobKey), jobId, 0, 0} -- get job data
 end
 --[[
   Function to recursively move from waitingChildren to failed.
@@ -261,9 +256,9 @@ end
 ]]
 local function getTargetQueueList(queueMetaKey, waitKey, pausedKey)
   if rcall("HEXISTS", queueMetaKey, "paused") ~= 1 then
-    return waitKey
+    return waitKey, false
   else
-    return pausedKey
+    return pausedKey, true
   end
 end
 local function moveParentToWait(parentPrefix, parentId, emitEvent)
@@ -408,13 +403,15 @@ local function updateParentDepsIfNeeded(parentKey, parentQueueKey, parentDepende
     rcall("XADD", parentQueueKey .. ":events", "*", "event", "waiting", "jobId", parentId, "prev", "waiting-children")
   end
 end
-local function getRateLimitTTL(opts, limiterKey)
-  local maxJobs = tonumber(opts['limiter'] and opts['limiter']['max'])
+local function getRateLimitTTL(maxJobs, rateLimiterKey)
   if maxJobs then
-    local jobCounter = tonumber(rcall("GET", limiterKey))
-    if jobCounter ~= nil and jobCounter >= maxJobs then
-      local pttl = rcall("PTTL", limiterKey)
-      if pttl > 0 then 
+    local pttl = rcall("PTTL", rateLimiterKey)
+    if pttl <= 0 then
+      rcall("DEL", rateLimiterKey)
+    end
+    local jobCounter = tonumber(rcall("GET", rateLimiterKey) or 0)
+    if jobCounter >= maxJobs then
+      if pttl > 0 then
         return pttl
       end
     end
@@ -527,23 +524,23 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
         -- Check if there are delayed jobs that can be promoted
         promoteDelayedJobs(KEYS[7], target, KEYS[3],
                            KEYS[4], ARGV[8], timestamp)
+        local maxJobs = tonumber(opts['limiter'] and opts['limiter']['max'])
         -- Check if we are rate limited first.
-        local pttl = getRateLimitTTL(opts, KEYS[6])
-        if pttl > 0 then return {0, 0, pttl} end
+        local expireTime = getRateLimitTTL(maxJobs, KEYS[6])
+        if expireTime > 0 then return {0, 0, expireTime, 0} end
         jobId = rcall("RPOPLPUSH", KEYS[1], KEYS[2])
         -- If jobId is special ID 0:delay, then there is no job to process
         if jobId then
             if string.sub(jobId, 1, 2) == "0:" then
                 rcall("LREM", KEYS[2], 1, jobId)
             else
-                opts = opts or cmsgpack.unpack(ARGV[4])
                 -- this script is not really moving, it is preparing the job for processing
-                return moveJobFromWaitToActive(KEYS, ARGV[8], jobId, timestamp, opts)
+                return moveJobFromWaitToActive(KEYS, ARGV[8], target, jobId, timestamp, maxJobs, expireTime, opts)
             end
         end
         -- Return the timestamp for the next delayed job if any.
         local nextTimestamp = getNextDelayedTimestamp(KEYS[7])
-        if (nextTimestamp ~= nil) then
+        if nextTimestamp ~= nil then
             -- The result is guaranteed to be positive, since the
             -- ZRANGEBYSCORE command would have return a job otherwise.
             return {0, 0, 0, nextTimestamp}

package/dist/esm/scripts/moveToFinished-12.js.map

@@ -1 +1 @@
-{"version":3,"file":"moveToFinished-12.js","sourceRoot":"","sources":["../../../src/scripts/moveToFinished-12.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkjBf,CAAC;AACF,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,IAAI,EAAE,gBAAgB;IACtB,OAAO;IACP,IAAI,EAAE,EAAE;CACT,CAAC"}
+{"version":3,"file":"moveToFinished-12.js","sourceRoot":"","sources":["../../../src/scripts/moveToFinished-12.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+iBf,CAAC;AACF,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,IAAI,EAAE,gBAAgB;IACtB,OAAO;IACP,IAAI,EAAE,EAAE;CACT,CAAC"}

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

@@ -69,9 +69,9 @@ end
 ]]
 local function getTargetQueueList(queueMetaKey, waitKey, pausedKey)
   if rcall("HEXISTS", queueMetaKey, "paused") ~= 1 then
-    return waitKey
+    return waitKey, false
   else
-    return pausedKey
+    return pausedKey, true
   end
 end
 local function moveParentToWait(parentPrefix, parentId, emitEvent)

package/dist/esm/scripts/promote-6.js

@@ -38,9 +38,9 @@ end
 ]]
 local function getTargetQueueList(queueMetaKey, waitKey, pausedKey)
   if rcall("HEXISTS", queueMetaKey, "paused") ~= 1 then
-    return waitKey
+    return waitKey, false
   else
-    return pausedKey
+    return pausedKey, true
   end
 end
 if rcall("ZREM", KEYS[1], jobId) == 1 then

package/dist/esm/scripts/removeJob-1.js

@@ -87,9 +87,9 @@ end
 ]]
 local function getTargetQueueList(queueMetaKey, waitKey, pausedKey)
   if rcall("HEXISTS", queueMetaKey, "paused") ~= 1 then
-    return waitKey
+    return waitKey, false
   else
-    return pausedKey
+    return pausedKey, true
   end
 end
 local function moveParentToWait(parentPrefix, parentId, emitEvent)

package/dist/esm/scripts/reprocessJob-6.js

@@ -24,9 +24,9 @@ local rcall = redis.call;
 ]]
 local function getTargetQueueList(queueMetaKey, waitKey, pausedKey)
   if rcall("HEXISTS", queueMetaKey, "paused") ~= 1 then
-    return waitKey
+    return waitKey, false
   else
-    return pausedKey
+    return pausedKey, true
   end
 end
 if (rcall("EXISTS", KEYS[1]) == 1) then

package/dist/esm/scripts/retryJob-8.js

@@ -29,9 +29,9 @@ local rcall = redis.call
 ]]
 local function getTargetQueueList(queueMetaKey, waitKey, pausedKey)
   if rcall("HEXISTS", queueMetaKey, "paused") ~= 1 then
-    return waitKey
+    return waitKey, false
   else
-    return pausedKey
+    return pausedKey, true
   end
 end
 --[[

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

@@ -40,9 +40,9 @@ end
 ]]
 local function getTargetQueueList(queueMetaKey, waitKey, pausedKey)
   if rcall("HEXISTS", queueMetaKey, "paused") ~= 1 then
-    return waitKey
+    return waitKey, false
   else
-    return pausedKey
+    return pausedKey, true
   end
 end
 local target = getTargetQueueList(KEYS[6], KEYS[4], KEYS[5])