bullmq 3.13.3 → 3.14.0

package/dist/esm/commands/includes/updateParentDepsIfNeeded.lua

@@ -5,7 +5,6 @@
 -- Includes
 --- @include "addDelayMarkerIfNeeded"
 --- @include "addJobWithPriority"
---- @include "getNextDelayedTimestamp"
 --- @include "getTargetQueueList"
 
 local function updateParentDepsIfNeeded(parentKey, parentQueueKey, parentDependenciesKey,

package/dist/esm/commands/isFinished-3.lua

@@ -12,15 +12,15 @@
     0 - Not finished.
     1 - Completed.
     2 - Failed.
-   -5 - Missing job. 
+   -1 - Missing job. 
 ]]
 local rcall = redis.call
 if rcall("EXISTS", KEYS[3]) ~= 1 then
   if ARGV[2] == "1" then
 
-    return {-5,"Missing key for job " .. KEYS[3] .. ". isFinished"}
+    return {-1,"Missing key for job " .. KEYS[3] .. ". isFinished"}
   end  
-  return -5
+  return -1
 end
 
 if rcall("ZSCORE", KEYS[1], ARGV[1]) ~= false then

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

@@ -8,11 +8,11 @@
     KEYS[4] job lock key
     KEYS[5] paused key
     KEYS[6] meta key
-    KEYS[7] event key
-
-    args[1] job id
-    args[2] lock token
+    KEYS[7] limiter key
+    KEYS[8] event key
 
+    ARGV[1] job id
+    ARGV[2] lock token
 ]]
 local rcall = redis.call
 
@@ -24,7 +24,8 @@ local token = ARGV[2]
 local lockKey = KEYS[4]
 
 local lockToken = rcall("GET", lockKey)
-if lockToken == token then
+local pttl = rcall("PTTL", KEYS[7])
+if lockToken == token and pttl > 0 then
   local removed = rcall("LREM", KEYS[1], 1, jobId)
   if (removed > 0) then
     local target = getTargetQueueList(KEYS[6], KEYS[2], KEYS[5])
@@ -34,6 +35,8 @@ if lockToken == token then
     rcall("DEL", lockKey)
 
     -- Emit waiting event
-    rcall("XADD", KEYS[7], "*", "event", "waiting", "jobId", jobId)
+    rcall("XADD", KEYS[8], "*", "event", "waiting", "jobId", jobId)
   end
 end
+
+return pttl

package/dist/esm/commands/moveToActive-9.lua

@@ -7,29 +7,29 @@
   so that no other worker picks this job again.
 
   Input:
-      KEYS[1] wait key
-      KEYS[2] active key
-      KEYS[3] priority key
-      KEYS[4] stream events key
-      KEYS[5] stalled key
+    KEYS[1] wait key
+    KEYS[2] active key
+    KEYS[3] priority key
+    KEYS[4] stream events key
+    KEYS[5] stalled key
 
-      -- Rate limiting
-      KEYS[6] rate limiter key
-      KEYS[7] delayed key
+    -- Rate limiting
+    KEYS[6] rate limiter key
+    KEYS[7] delayed key
 
-      -- Promote delayed jobs
-      KEYS[8] paused key
-      KEYS[9] meta key
+    -- Promote delayed jobs
+    KEYS[8] paused key
+    KEYS[9] meta key
 
-      -- Arguments
-      ARGV[1] key prefix
-      ARGV[2] timestamp
-      ARGV[3] optional job ID
-      ARGV[4] opts
+    -- Arguments
+    ARGV[1] key prefix
+    ARGV[2] timestamp
+    ARGV[3] optional job ID
+    ARGV[4] opts
 
-      opts - token - lock token
-      opts - lockDuration
-      opts - limiter
+    opts - token - lock token
+    opts - lockDuration
+    opts - limiter
 ]]
 local jobId
 local rcall = redis.call
@@ -45,39 +45,41 @@ promoteDelayedJobs(KEYS[7], KEYS[1], KEYS[3], KEYS[8], KEYS[9], KEYS[4], ARGV[1]
 
 local opts
 if (ARGV[3] ~= "") then
-    jobId = ARGV[3]
-    -- clean stalled key
-    rcall("SREM", KEYS[5], jobId)
+  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 }
-    end
+  -- 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 }
+  end
 
-    -- no job ID, try non-blocking move from wait to active
-    jobId = rcall("RPOPLPUSH", KEYS[1], KEYS[2])
+  -- no job ID, try non-blocking move from wait to active
+  jobId = rcall("RPOPLPUSH", KEYS[1], KEYS[2])
 end
 
 -- 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)
-        -- Move again since we just got the marker job.
-        jobId = rcall("RPOPLPUSH", KEYS[1], KEYS[2])
+if jobId then
+  if string.sub(jobId, 1, 2) == "0:" then
+    rcall("LREM", KEYS[2], 1, jobId)
+    -- Move again since we just got the marker job.
+    jobId = rcall("RPOPLPUSH", KEYS[1], KEYS[2])
 
-        if jobId and string.sub(jobId, 1, 2) == "0:" then
-            rcall("LREM", KEYS[2], 1, jobId)
-            jobId = nil
-        end
+    -- Since it is possible that between a call to BRPOPLPUSH and moveToActive
+    -- another script puts a new maker in wait, we need to check again.
+    if jobId and string.sub(jobId, 1, 2) == "0:" then
+      rcall("LREM", KEYS[2], 1, jobId)
+      jobId = rcall("RPOPLPUSH", KEYS[1], KEYS[2])
     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)
-    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)
+  end
 end
 
 -- Return the timestamp for the next delayed job if any.

package/dist/esm/commands/moveToDelayed-8.lua

@@ -35,34 +35,33 @@ local rcall = redis.call
 
 local jobKey = KEYS[5]
 if rcall("EXISTS", jobKey) == 1 then
-
-    local delayedKey = KEYS[4]
-    if ARGV[5] ~= "0" then
-        local lockKey = jobKey .. ':lock'
-        if rcall("GET", lockKey) == ARGV[5] then
-            rcall("DEL", lockKey)
-        else
-            return -2
-        end
+  local delayedKey = KEYS[4]
+  if ARGV[5] ~= "0" then
+    local lockKey = jobKey .. ':lock'
+    if rcall("GET", lockKey) == ARGV[5] then
+      rcall("DEL", lockKey)
+    else
+      return -2
     end
+  end
 
-    local jobId = ARGV[4]
-    local score = tonumber(ARGV[3])
-    local delayedTimestamp = (score / 0x1000)
+  local jobId = ARGV[4]
+  local score = tonumber(ARGV[3])
+  local delayedTimestamp = (score / 0x1000)
 
-    local numRemovedElements = rcall("LREM", KEYS[2], -1, jobId)
-    if (numRemovedElements < 1) then 
-      return -3
-    end
+  local numRemovedElements = rcall("LREM", KEYS[2], -1, jobId)
+  if numRemovedElements < 1 then
+    return -3
+  end
 
-    rcall("ZADD", delayedKey, score, jobId)
-    rcall("XADD", KEYS[6], "*", "event", "delayed", "jobId", jobId, "delay", delayedTimestamp)
+  rcall("ZADD", delayedKey, score, jobId)
+  rcall("XADD", KEYS[6], "*", "event", "delayed", "jobId", jobId, "delay", delayedTimestamp)
 
-    -- Check if we need to push a marker job to wake up sleeping workers.
-    local target = getTargetQueueList(KEYS[8], KEYS[1], KEYS[7])
-    addDelayMarkerIfNeeded(target, delayedKey)
+  -- Check if we need to push a marker job to wake up sleeping workers.
+  local target = getTargetQueueList(KEYS[8], KEYS[1], KEYS[7])
+  addDelayMarkerIfNeeded(target, delayedKey)
 
-    return 0
+  return 0
 else
-    return -1
+  return -1
 end

package/dist/esm/commands/pause-4.lua

@@ -1,16 +1,16 @@
 --[[
   Pauses or resumes a queue globably.
 
-   Input:
-      KEYS[1] 'wait' or 'paused''
-      KEYS[2] 'paused' or 'wait'
-      KEYS[3] 'meta'
-      KEYS[4] events stream key
+  Input:
+    KEYS[1] 'wait' or 'paused''
+    KEYS[2] 'paused' or 'wait'
+    KEYS[3] 'meta'
+    KEYS[4] events stream key
 
-      ARGV[1] 'paused' or 'resumed'
+    ARGV[1] 'paused' or 'resumed'
 
-    Event:
-      publish paused or resumed event.
+  Event:
+    publish paused or resumed event.
 ]]
 local rcall = redis.call
 

package/dist/esm/commands/promote-6.lua

@@ -1,7 +1,7 @@
 --[[
   Promotes a job that is currently "delayed" to the "waiting" state
 
-     Input:
+    Input:
       KEYS[1] 'delayed'
       KEYS[2] 'wait'
       KEYS[3] 'paused'
@@ -12,10 +12,14 @@
       ARGV[1]  queue.toKey('')
       ARGV[2]  jobId
 
-     Events:
+    Output:
+       0 - OK
+      -3 - Job not in delayed zset.
+
+    Events:
       'waiting'
 ]]
-local rcall = redis.call;
+local rcall = redis.call
 local jobId = ARGV[2]
 
 -- Includes

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

@@ -12,6 +12,9 @@
   Output:
     0 - OK
     1 - Missing repeat job
+
+  Events:
+    'removed'
 ]]
 local rcall = redis.call
 local millis = rcall("ZSCORE", KEYS[1], ARGV[2])

package/dist/esm/commands/reprocessJob-6.lua

@@ -15,7 +15,7 @@
     ARGV[4] prev state - failed/completed
 
   Output:
-    1  means the operation was a success
+     1 means the operation was a success
     -1 means the job does not exist
     -3 means the job was not found in the expected set.
 ]]

package/dist/esm/commands/retryJob-8.lua

@@ -50,8 +50,8 @@ if rcall("EXISTS", KEYS[4]) == 1 then
   rcall(ARGV[3], target, ARGV[4])
 
   -- Emit waiting event
-  rcall("XADD", KEYS[6], "*", "event", "waiting", "jobId", ARGV[4], "prev", "failed");
-  
+  rcall("XADD", KEYS[6], "*", "event", "waiting", "jobId", ARGV[4], "prev", "failed")
+
   return 0
 else
   return -1

package/dist/esm/commands/saveStacktrace-1.lua

@@ -8,15 +8,14 @@
     ARGV[2]  failedReason
 
   Output:
-    0  - OK
+     0 - OK
     -1 - Missing key
 ]]
 local rcall = redis.call
 
 if rcall("EXISTS", KEYS[1]) == 1 then
-
   rcall("HMSET", KEYS[1], "stacktrace", ARGV[1], "failedReason", ARGV[2])
-  
+
   return 0
 else
   return -1

package/dist/esm/commands/updateData-1.lua

@@ -3,8 +3,12 @@
 
   Input:
     KEYS[1] Job id key
-  
-    ARGV[1] data        
+
+    ARGV[1] data
+
+  Output:
+    0 - OK
+   -1 - Missing job.
 ]]
 local rcall = redis.call
 

package/dist/esm/commands/updateProgress-2.lua

@@ -4,10 +4,14 @@
   Input:
     KEYS[1] Job id key
     KEYS[2] event stream key
-  
+
     ARGV[1] id
     ARGV[2] progress
-    
+
+  Output:
+     0 - OK
+    -1 - Missing job.
+
   Event:
     progress(jobId, progress)
 ]]

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

@@ -172,7 +172,7 @@ else
     end
     rcall("XADD", KEYS[8], "*", "event", "duplicated", "jobId", jobId)
     return jobId .. "" -- convert to string
-  end  
+  end
 end
 -- Store the job.
 local jsonOpts = cjson.encode(opts)
@@ -213,7 +213,7 @@ else
   -- Standard or priority add
   if priority == 0 then
     -- LIFO or FIFO
-    local pushCmd = opts['lifo'] and 'RPUSH' or 'LPUSH';
+    local pushCmd = opts['lifo'] and 'RPUSH' or 'LPUSH'
     rcall(pushCmd, target, jobId)
   else
     -- Priority add

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

@@ -20,12 +20,12 @@ if rcall("EXISTS", KEYS[2]) == 1 then
   local score = tonumber(ARGV[2])
   local delayedTimestamp = (score / 0x1000)
   local numRemovedElements = rcall("ZREM", KEYS[1], jobId)
-  if (numRemovedElements < 1)  then
+  if numRemovedElements < 1 then
     return -3
   end
   rcall("HSET", KEYS[2], "delay", tonumber(ARGV[1]))
   rcall("ZADD", KEYS[1], score, jobId)
-  rcall("XADD", KEYS[3], "*", "event", "delayed", "jobId", jobId, "delay", delayedTimestamp);
+  rcall("XADD", KEYS[3], "*", "event", "delayed", "jobId", jobId, "delay", delayedTimestamp)
   return 0
 else
   return -1

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

@@ -7,7 +7,7 @@ const content = `--[[
       ARGV[3]    asc
       ARGV[4...] types
 ]]
-local rcall = redis.call;
+local rcall = redis.call
 local prefix = KEYS[1]
 local rangeStart = tonumber(ARGV[1])
 local rangeEnd = tonumber(ARGV[2])

package/dist/esm/scripts/index.d.ts

@@ -9,7 +9,7 @@ export * from './getState-7';
 export * from './getStateV2-7';
 export * from './isFinished-3';
 export * from './isJobInList-1';
-export * from './moveJobFromActiveToWait-7';
+export * from './moveJobFromActiveToWait-8';
 export * from './moveStalledJobsToWait-8';
 export * from './moveToActive-9';
 export * from './moveToDelayed-8';
@@ -25,6 +25,5 @@ export * from './reprocessJob-6';
 export * from './retryJob-8';
 export * from './retryJobs-6';
 export * from './saveStacktrace-1';
-export * from './takeLock-1';
 export * from './updateData-1';
 export * from './updateProgress-2';

package/dist/esm/scripts/index.js

@@ -9,7 +9,7 @@ export * from './getState-7';
 export * from './getStateV2-7';
 export * from './isFinished-3';
 export * from './isJobInList-1';
-export * from './moveJobFromActiveToWait-7';
+export * from './moveJobFromActiveToWait-8';
 export * from './moveStalledJobsToWait-8';
 export * from './moveToActive-9';
 export * from './moveToDelayed-8';
@@ -25,7 +25,6 @@ export * from './reprocessJob-6';
 export * from './retryJob-8';
 export * from './retryJobs-6';
 export * from './saveStacktrace-1';
-export * from './takeLock-1';
 export * from './updateData-1';
 export * from './updateProgress-2';
 //# sourceMappingURL=index.js.map

package/dist/esm/scripts/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/scripts/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,WAAW,CAAC;AAC1B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,gBAAgB,CAAC;AAC/B,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,sBAAsB,CAAC;AACrC,cAAc,kBAAkB,CAAC;AACjC,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,oBAAoB,CAAC;AACnC,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,oBAAoB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/scripts/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,WAAW,CAAC;AAC1B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,gBAAgB,CAAC;AAC/B,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,sBAAsB,CAAC;AACrC,cAAc,kBAAkB,CAAC;AACjC,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,oBAAoB,CAAC"}

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

@@ -10,14 +10,14 @@ const content = `--[[
     0 - Not finished.
     1 - Completed.
     2 - Failed.
-   -5 - Missing job. 
+   -1 - Missing job. 
 ]]
 local rcall = redis.call
 if rcall("EXISTS", KEYS[3]) ~= 1 then
   if ARGV[2] == "1" then
-    return {-5,"Missing key for job " .. KEYS[3] .. ". isFinished"}
+    return {-1,"Missing key for job " .. KEYS[3] .. ". isFinished"}
   end  
-  return -5
+  return -1
 end
 if rcall("ZSCORE", KEYS[1], ARGV[1]) ~= false then
   if ARGV[2] == "1" then

package/dist/esm/scripts/{moveJobFromActiveToWait-7.js → moveJobFromActiveToWait-8.js}

@@ -7,9 +7,10 @@ const content = `--[[
     KEYS[4] job lock key
     KEYS[5] paused key
     KEYS[6] meta key
-    KEYS[7] event key
-    args[1] job id
-    args[2] lock token
+    KEYS[7] limiter key
+    KEYS[8] event key
+    ARGV[1] job id
+    ARGV[2] lock token
 ]]
 local rcall = redis.call
 -- Includes
@@ -28,7 +29,8 @@ local jobId = ARGV[1]
 local token = ARGV[2]
 local lockKey = KEYS[4]
 local lockToken = rcall("GET", lockKey)
-if lockToken == token then
+local pttl = rcall("PTTL", KEYS[7])
+if lockToken == token and pttl > 0 then
   local removed = rcall("LREM", KEYS[1], 1, jobId)
   if (removed > 0) then
     local target = getTargetQueueList(KEYS[6], KEYS[2], KEYS[5])
@@ -36,13 +38,14 @@ if lockToken == token then
     rcall("RPUSH", target, jobId)
     rcall("DEL", lockKey)
     -- Emit waiting event
-    rcall("XADD", KEYS[7], "*", "event", "waiting", "jobId", jobId)
+    rcall("XADD", KEYS[8], "*", "event", "waiting", "jobId", jobId)
   end
 end
+return pttl
 `;
 export const moveJobFromActiveToWait = {
     name: 'moveJobFromActiveToWait',
     content,
-    keys: 7,
+    keys: 8,
 };
-//# sourceMappingURL=moveJobFromActiveToWait-7.js.map
+//# sourceMappingURL=moveJobFromActiveToWait-8.js.map

package/dist/esm/scripts/moveJobFromActiveToWait-8.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"moveJobFromActiveToWait-8.js","sourceRoot":"","sources":["../../../src/scripts/moveJobFromActiveToWait-8.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4Cf,CAAC;AACF,MAAM,CAAC,MAAM,uBAAuB,GAAG;IACrC,IAAI,EAAE,yBAAyB;IAC/B,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

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

@@ -5,25 +5,25 @@ const content = `--[[
   expiration time. The worker is responsible of keeping the lock fresh
   so that no other worker picks this job again.
   Input:
-      KEYS[1] wait key
-      KEYS[2] active key
-      KEYS[3] priority key
-      KEYS[4] stream events key
-      KEYS[5] stalled key
-      -- Rate limiting
-      KEYS[6] rate limiter key
-      KEYS[7] delayed key
-      -- Promote delayed jobs
-      KEYS[8] paused key
-      KEYS[9] meta key
-      -- Arguments
-      ARGV[1] key prefix
-      ARGV[2] timestamp
-      ARGV[3] optional job ID
-      ARGV[4] opts
-      opts - token - lock token
-      opts - lockDuration
-      opts - limiter
+    KEYS[1] wait key
+    KEYS[2] active key
+    KEYS[3] priority key
+    KEYS[4] stream events key
+    KEYS[5] stalled key
+    -- Rate limiting
+    KEYS[6] rate limiter key
+    KEYS[7] delayed key
+    -- Promote delayed jobs
+    KEYS[8] paused key
+    KEYS[9] meta key
+    -- Arguments
+    ARGV[1] key prefix
+    ARGV[2] timestamp
+    ARGV[3] optional job ID
+    ARGV[4] opts
+    opts - token - lock token
+    opts - lockDuration
+    opts - limiter
 ]]
 local jobId
 local rcall = redis.call
@@ -157,7 +157,7 @@ local function getRateLimitTTL(opts, limiterKey)
     if jobCounter ~= nil and jobCounter >= maxJobs then
       local pttl = rcall("PTTL", limiterKey)
       if pttl > 0 then 
-        return pttl 
+        return pttl
       end
     end
   end
@@ -167,35 +167,37 @@ end
 promoteDelayedJobs(KEYS[7], KEYS[1], KEYS[3], KEYS[8], KEYS[9], KEYS[4], ARGV[1], ARGV[2])
 local opts
 if (ARGV[3] ~= "") then
-    jobId = ARGV[3]
-    -- clean stalled key
-    rcall("SREM", KEYS[5], jobId)
+  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 }
-    end
-    -- no job ID, try non-blocking move from wait to active
-    jobId = rcall("RPOPLPUSH", KEYS[1], KEYS[2])
+  -- 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 }
+  end
+  -- no job ID, try non-blocking move from wait to active
+  jobId = rcall("RPOPLPUSH", KEYS[1], KEYS[2])
 end
 -- 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)
-        -- Move again since we just got the marker job.
-        jobId = rcall("RPOPLPUSH", KEYS[1], KEYS[2])
-        if jobId and string.sub(jobId, 1, 2) == "0:" then
-            rcall("LREM", KEYS[2], 1, jobId)
-            jobId = nil
-        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)
+if jobId then
+  if string.sub(jobId, 1, 2) == "0:" then
+    rcall("LREM", KEYS[2], 1, jobId)
+    -- 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
+    -- another script puts a new maker in wait, we need to check again.
+    if jobId and string.sub(jobId, 1, 2) == "0:" then
+      rcall("LREM", KEYS[2], 1, jobId)
+      jobId = rcall("RPOPLPUSH", KEYS[1], KEYS[2])
     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)
+  end
 end
 -- Return the timestamp for the next delayed job if any.
 local nextTimestamp = getNextDelayedTimestamp(KEYS[7])

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

@@ -1 +1 @@
-{"version":3,"file":"moveToActive-9.js","sourceRoot":"","sources":["../../../src/scripts/moveToActive-9.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4Mf,CAAC;AACF,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,IAAI,EAAE,cAAc;IACpB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}
+{"version":3,"file":"moveToActive-9.js","sourceRoot":"","sources":["../../../src/scripts/moveToActive-9.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8Mf,CAAC;AACF,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,IAAI,EAAE,cAAc;IACpB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}