bullmq 5.1.3 → 5.1.5

package/dist/esm/scripts/{moveStalledJobsToWait-8.js.map → moveStalledJobsToWait-9.js.map}

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

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

@@ -30,6 +30,7 @@ const content = `--[[
 local rcall = redis.call
 local waitKey = KEYS[1]
 local activeKey = KEYS[2]
+local eventStreamKey = KEYS[4]
 local rateLimiterKey = KEYS[6]
 local delayedKey = KEYS[7]
 local opts = cmsgpack.unpack(ARGV[3])
@@ -88,50 +89,15 @@ end
 --[[
   Function to move job from wait state to active.
   Input:
-    keys[1] wait key
-    keys[2] active key
-    keys[3] prioritized key
-    keys[4] stream events key
-    keys[5] stalled key
-    -- Rate limiting
-    keys[6] rate limiter key
-    keys[7] delayed key
-    keys[8] paused key
-    keys[9] meta key
-    keys[10] pc priority counter
     opts - token - lock token
     opts - lockDuration
     opts - limiter
 ]]
--- Includes
---[[
-  Function to push back job considering priority in front of same prioritized jobs.
-]]
-local function pushBackJobWithPriority(prioritizedKey, priority, jobId)
-  -- in order to put it at front of same prioritized jobs
-  -- we consider prioritized counter as 0
-  local score = priority * 0x100000000
-  rcall("ZADD", prioritizedKey, score, jobId)
-end
-local function prepareJobForProcessing(keys, keyPrefix, targetKey, jobId, processedOn,
-    maxJobs, expireTime, opts)
+local function prepareJobForProcessing(keyPrefix, rateLimiterKey, eventStreamKey,
+    jobId, processedOn, maxJobs, opts)
   local jobKey = keyPrefix .. jobId
   -- Check if we need to perform rate limiting.
   if maxJobs then
-    local rateLimiterKey = keys[6];
-    -- check if we exceeded rate limit, we need to remove the job and return expireTime
-    if expireTime > 0 then
-      -- remove from active queue and add back to the wait list
-      rcall("LREM", keys[2], 1, jobId)
-      local priority = tonumber(rcall("HGET", jobKey, "priority")) or 0
-      if priority == 0 then
-        rcall("RPUSH", targetKey, jobId)
-      else
-        pushBackJobWithPriority(keys[3], priority, jobId)
-      end
-      -- Return when we can process more jobs
-      return {0, 0, expireTime, 0}
-    end
     local jobCounter = tonumber(rcall("INCR", rateLimiterKey))
     if jobCounter == 1 then
       local limiterDuration = opts['limiter'] and opts['limiter']['duration']
@@ -144,7 +110,7 @@ local function prepareJobForProcessing(keys, keyPrefix, targetKey, jobId, proces
   if opts['token'] ~= "0" then
     rcall("SET", lockKey, opts['token'], "PX", opts['lockDuration'])
   end
-  rcall("XADD", keys[4], "*", "event", "active", "jobId", jobId, "prev", "waiting")
+  rcall("XADD", eventStreamKey, "*", "event", "active", "jobId", jobId, "prev", "waiting")
   rcall("HSET", jobKey, "processedOn", processedOn)
   rcall("HINCRBY", jobKey, "ats", 1)
   return {rcall("HGETALL", jobKey), jobId, 0, 0} -- get job data
@@ -156,16 +122,31 @@ end
       'waiting'
 ]]
 -- Includes
+--[[
+  Function to add job in target list and add marker if needed.
+]]
+-- Includes
+--[[
+  Add marker if needed when a job is available.
+]]
+local function addBaseMarkerIfNeeded(markerKey, isPaused)
+  if not isPaused then
+    rcall("ZADD", markerKey, 0, "0")
+  end  
+end
+local function addJobInTargetList(targetKey, markerKey, pushCmd, isPaused, jobId)
+  rcall(pushCmd, targetKey, jobId)
+  addBaseMarkerIfNeeded(markerKey, isPaused)
+end
 --[[
   Function to add job considering priority.
 ]]
+-- Includes
 local function addJobWithPriority(markerKey, prioritizedKey, priority, jobId, priorityCounterKey, isPaused)
   local prioCounter = rcall("INCR", priorityCounterKey)
   local score = priority * 0x100000000 + bit.band(prioCounter, 0xffffffffffff)
   rcall("ZADD", prioritizedKey, score, jobId)
-  if not isPaused then
-    rcall("ZADD", markerKey, 0, "0")
-  end
+  addBaseMarkerIfNeeded(markerKey, isPaused)
 end
 -- Try to get as much as 1000 jobs at once
 local function promoteDelayedJobs(delayedKey, markerKey, targetKey, prioritizedKey,
@@ -179,10 +160,7 @@ local function promoteDelayedJobs(delayedKey, markerKey, targetKey, prioritizedK
                 tonumber(rcall("HGET", jobKey, "priority")) or 0
             if priority == 0 then
                 -- LIFO or FIFO
-                rcall("LPUSH", targetKey, jobId)
-                if not isPaused then
-                    rcall("ZADD", markerKey, 0, "0")
-                end
+                addJobInTargetList(targetKey, markerKey, "LPUSH", isPaused, jobId)
             else
                 addJobWithPriority(markerKey, prioritizedKey, priority,
                   jobId, priorityCounterKey, isPaused)
@@ -197,7 +175,7 @@ end
 local target, paused = getTargetQueueList(KEYS[9], waitKey, KEYS[8])
 -- Check if there are delayed jobs that we can move to wait.
 local markerKey = KEYS[11]
-promoteDelayedJobs(delayedKey, markerKey, target, KEYS[3], KEYS[4], ARGV[1],
+promoteDelayedJobs(delayedKey, markerKey, target, KEYS[3], eventStreamKey, ARGV[1],
                    ARGV[2], KEYS[10], paused)
 local maxJobs = tonumber(opts['limiter'] and opts['limiter']['max'])
 local expireTime = getRateLimitTTL(maxJobs, rateLimiterKey)
@@ -213,13 +191,13 @@ if jobId and string.sub(jobId, 1, 2) == "0:" then
     jobId = rcall("RPOPLPUSH", waitKey, activeKey)
 end
 if jobId then
-    return prepareJobForProcessing(KEYS, ARGV[1], target, jobId, ARGV[2],
-                                   maxJobs, expireTime, opts)
+    return prepareJobForProcessing(ARGV[1], rateLimiterKey, eventStreamKey, jobId, ARGV[2],
+                                   maxJobs, opts)
 else
     jobId = moveJobFromPriorityToActive(KEYS[3], activeKey, KEYS[10])
     if jobId then
-        return prepareJobForProcessing(KEYS, ARGV[1], target, jobId, ARGV[2],
-                                       maxJobs, expireTime, opts)
+        return prepareJobForProcessing(ARGV[1], rateLimiterKey, eventStreamKey, jobId, ARGV[2],
+                                       maxJobs, opts)
     end
 end
 -- Return the timestamp for the next delayed job if any.

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

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

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

@@ -26,7 +26,7 @@ local rcall = redis.call
 -- Includes
 --[[
   Add delay marker if needed.
-]] 
+]]
 -- Includes
 --[[
   Function to return the next delayed job timestamp.

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

@@ -113,6 +113,17 @@ local function getNextDelayedTimestamp(delayedKey)
     return nextTimestamp
   end
 end
+--[[
+  Function to check for the meta.paused key to decide if we are paused or not
+  (since an empty list and !EXISTS are not really the same).
+]]
+local function getTargetQueueList(queueMetaKey, waitKey, pausedKey)
+  if rcall("HEXISTS", queueMetaKey, "paused") ~= 1 then
+    return waitKey, false
+  else
+    return pausedKey, true
+  end
+end
 --[[
   Function to move job from prioritized state to active.
 ]]
@@ -128,50 +139,15 @@ end
 --[[
   Function to move job from wait state to active.
   Input:
-    keys[1] wait key
-    keys[2] active key
-    keys[3] prioritized key
-    keys[4] stream events key
-    keys[5] stalled key
-    -- Rate limiting
-    keys[6] rate limiter key
-    keys[7] delayed key
-    keys[8] paused key
-    keys[9] meta key
-    keys[10] pc priority counter
     opts - token - lock token
     opts - lockDuration
     opts - limiter
 ]]
--- Includes
---[[
-  Function to push back job considering priority in front of same prioritized jobs.
-]]
-local function pushBackJobWithPriority(prioritizedKey, priority, jobId)
-  -- in order to put it at front of same prioritized jobs
-  -- we consider prioritized counter as 0
-  local score = priority * 0x100000000
-  rcall("ZADD", prioritizedKey, score, jobId)
-end
-local function prepareJobForProcessing(keys, keyPrefix, targetKey, jobId, processedOn,
-    maxJobs, expireTime, opts)
+local function prepareJobForProcessing(keyPrefix, rateLimiterKey, eventStreamKey,
+    jobId, processedOn, maxJobs, opts)
   local jobKey = keyPrefix .. jobId
   -- Check if we need to perform rate limiting.
   if maxJobs then
-    local rateLimiterKey = keys[6];
-    -- check if we exceeded rate limit, we need to remove the job and return expireTime
-    if expireTime > 0 then
-      -- remove from active queue and add back to the wait list
-      rcall("LREM", keys[2], 1, jobId)
-      local priority = tonumber(rcall("HGET", jobKey, "priority")) or 0
-      if priority == 0 then
-        rcall("RPUSH", targetKey, jobId)
-      else
-        pushBackJobWithPriority(keys[3], priority, jobId)
-      end
-      -- Return when we can process more jobs
-      return {0, 0, expireTime, 0}
-    end
     local jobCounter = tonumber(rcall("INCR", rateLimiterKey))
     if jobCounter == 1 then
       local limiterDuration = opts['limiter'] and opts['limiter']['duration']
@@ -184,7 +160,7 @@ local function prepareJobForProcessing(keys, keyPrefix, targetKey, jobId, proces
   if opts['token'] ~= "0" then
     rcall("SET", lockKey, opts['token'], "PX", opts['lockDuration'])
   end
-  rcall("XADD", keys[4], "*", "event", "active", "jobId", jobId, "prev", "waiting")
+  rcall("XADD", eventStreamKey, "*", "event", "active", "jobId", jobId, "prev", "waiting")
   rcall("HSET", jobKey, "processedOn", processedOn)
   rcall("HINCRBY", jobKey, "ats", 1)
   return {rcall("HGETALL", jobKey), jobId, 0, 0} -- get job data
@@ -199,7 +175,7 @@ end
 -- Includes
 --[[
   Add delay marker if needed.
-]] 
+]]
 -- Includes
 local function addDelayMarkerIfNeeded(markerKey, delayedKey)
     local nextTimestamp = getNextDelayedTimestamp(delayedKey)
@@ -210,33 +186,37 @@ local function addDelayMarkerIfNeeded(markerKey, delayedKey)
     end
 end
 --[[
-  Function to check for the meta.paused key to decide if we are paused or not
-  (since an empty list and !EXISTS are not really the same).
+  Function to add job in target list and add marker if needed.
 ]]
-local function isQueuePaused(queueMetaKey)
-    return rcall("HEXISTS", queueMetaKey, "paused") == 1
+-- Includes
+--[[
+  Add marker if needed when a job is available.
+]]
+local function addBaseMarkerIfNeeded(markerKey, isPaused)
+  if not isPaused then
+    rcall("ZADD", markerKey, 0, "0")
+  end  
+end
+local function addJobInTargetList(targetKey, markerKey, pushCmd, isPaused, jobId)
+  rcall(pushCmd, targetKey, jobId)
+  addBaseMarkerIfNeeded(markerKey, isPaused)
 end
 --[[
   Function to add job considering priority.
 ]]
+-- Includes
 local function addJobWithPriority(markerKey, prioritizedKey, priority, jobId, priorityCounterKey, isPaused)
   local prioCounter = rcall("INCR", priorityCounterKey)
   local score = priority * 0x100000000 + bit.band(prioCounter, 0xffffffffffff)
   rcall("ZADD", prioritizedKey, score, jobId)
-  if not isPaused then
-    rcall("ZADD", markerKey, 0, "0")
-  end
+  addBaseMarkerIfNeeded(markerKey, isPaused)
 end
 --[[
   Function to check for the meta.paused key to decide if we are paused or not
   (since an empty list and !EXISTS are not really the same).
 ]]
-local function getTargetQueueList(queueMetaKey, waitKey, pausedKey)
-  if rcall("HEXISTS", queueMetaKey, "paused") ~= 1 then
-    return waitKey, false
-  else
-    return pausedKey, true
-  end
+local function isQueuePaused(queueMetaKey)
+    return rcall("HEXISTS", queueMetaKey, "paused") == 1
 end
 local function moveParentToWaitIfNeeded(parentQueueKey, parentDependenciesKey,
                                         parentKey, parentId, timestamp)
@@ -261,11 +241,10 @@ local function moveParentToWaitIfNeeded(parentQueueKey, parentDependenciesKey,
             addDelayMarkerIfNeeded(parentMarkerKey, parentDelayedKey)
         else
             if priority == 0 then
-                local parentTarget, _paused =
+                local parentTarget, isParentPaused =
                     getTargetQueueList(parentMetaKey, parentWaitKey,
                                        parentPausedKey)
-                rcall("RPUSH", parentTarget, parentId)
-                rcall("ZADD", parentMarkerKey, 0, "0")
+                addJobInTargetList(parentTarget, parentMarkerKey, "RPUSH", isParentPaused, parentId)
             else
                 local isPaused = isQueuePaused(parentMetaKey)
                 addJobWithPriority(parentMarkerKey,
@@ -325,10 +304,7 @@ local function promoteDelayedJobs(delayedKey, markerKey, targetKey, prioritizedK
                 tonumber(rcall("HGET", jobKey, "priority")) or 0
             if priority == 0 then
                 -- LIFO or FIFO
-                rcall("LPUSH", targetKey, jobId)
-                if not isPaused then
-                    rcall("ZADD", markerKey, 0, "0")
-                end
+                addJobInTargetList(targetKey, markerKey, "LPUSH", isPaused, jobId)
             else
                 addJobWithPriority(markerKey, prioritizedKey, priority,
                   jobId, priorityCounterKey, isPaused)
@@ -540,9 +516,10 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
     -- Remove from active list (if not active we shall return error)
     local numRemovedElements = rcall("LREM", KEYS[2], -1, jobId)
     if (numRemovedElements < 1) then return -3 end
+    local eventStreamKey = KEYS[4]
     local metaKey = KEYS[9]
     -- Trim events before emiting them to avoid trimming events emitted in this script
-    trimEvents(metaKey, KEYS[4])
+    trimEvents(metaKey, eventStreamKey)
     -- If job has a parent we need to
     -- 1) remove this job id from parents dependencies
     -- 2) move the job Id to parent "processed" set
@@ -596,11 +573,11 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
             removeParentDependencyKey(jobIdKey, false, parentKey)
         end
     end
-    rcall("XADD", KEYS[4], "*", "event", ARGV[5], "jobId", jobId, ARGV[3],
+    rcall("XADD", eventStreamKey, "*", "event", ARGV[5], "jobId", jobId, ARGV[3],
           ARGV[4])
     if ARGV[5] == "failed" then
         if tonumber(attemptsMade) >= tonumber(attempts) then
-            rcall("XADD", KEYS[4], "*", "event", "retries-exhausted", "jobId",
+            rcall("XADD", eventStreamKey, "*", "event", "retries-exhausted", "jobId",
                   jobId, "attemptsMade", attemptsMade)
         end
     end
@@ -613,7 +590,7 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
     if (ARGV[6] == "1") then
         local target, paused = getTargetQueueList(metaKey, KEYS[1], KEYS[8])
         -- Check if there are delayed jobs that can be promoted
-        promoteDelayedJobs(KEYS[7], KEYS[14], target, KEYS[3], KEYS[4], ARGV[7],
+        promoteDelayedJobs(KEYS[7], KEYS[14], target, KEYS[3], eventStreamKey, ARGV[7],
                            timestamp, KEYS[10], paused)
         local maxJobs = tonumber(opts['limiter'] and opts['limiter']['max'])
         -- Check if we are rate limited first.
@@ -631,20 +608,20 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
                 if jobId == "0:0" then
                     jobId = moveJobFromPriorityToActive(KEYS[3], KEYS[2],
                                                         KEYS[10])
-                    return prepareJobForProcessing(KEYS, ARGV[7], target, jobId,
+                    return prepareJobForProcessing(ARGV[7], KEYS[6], eventStreamKey, jobId,
                                                    timestamp, maxJobs,
-                                                   expireTime, opts)
+                                                   opts)
                 end
             else
-                return prepareJobForProcessing(KEYS, ARGV[7], target, jobId,
-                                               timestamp, maxJobs, expireTime,
+                return prepareJobForProcessing(ARGV[7], KEYS[6], eventStreamKey, jobId,
+                                               timestamp, maxJobs,
                                                opts)
             end
         else
             jobId = moveJobFromPriorityToActive(KEYS[3], KEYS[2], KEYS[10])
             if jobId then
-                return prepareJobForProcessing(KEYS, ARGV[7], target, jobId,
-                                               timestamp, maxJobs, expireTime,
+                return prepareJobForProcessing(ARGV[7], KEYS[6], eventStreamKey, jobId,
+                                               timestamp, maxJobs,
                                                opts)
             end
         end
@@ -662,7 +639,7 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
         if activeLen == 0 then
             local prioritizedLen = rcall("ZCARD", KEYS[3])
             if prioritizedLen == 0 then
-                rcall("XADD", KEYS[4], "*", "event", "drained")
+                rcall("XADD", eventStreamKey, "*", "event", "drained")
             end
         end
     end

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

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

package/dist/esm/scripts/pause-7.js

@@ -16,7 +16,7 @@ local rcall = redis.call
 -- Includes
 --[[
   Add delay marker if needed.
-]] 
+]]
 -- Includes
 --[[
   Function to return the next delayed job timestamp.
@@ -41,6 +41,7 @@ local function addDelayMarkerIfNeeded(markerKey, delayedKey)
 end
 local markerKey = KEYS[7]
 local hasJobs = rcall("EXISTS", KEYS[1]) == 1
+--TODO: check this logic to be reused when changing a delay
 if hasJobs then rcall("RENAME", KEYS[1], KEYS[2]) end
 if ARGV[1] == "paused" then
     rcall("HSET", KEYS[3], "paused", 1)

package/dist/esm/scripts/pause-7.js.map

@@ -1 +1 @@
-{"version":3,"file":"pause-7.js","sourceRoot":"","sources":["../../../src/scripts/pause-7.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyDf,CAAC;AACF,MAAM,CAAC,MAAM,KAAK,GAAG;IACnB,IAAI,EAAE,OAAO;IACb,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}
+{"version":3,"file":"pause-7.js","sourceRoot":"","sources":["../../../src/scripts/pause-7.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0Df,CAAC;AACF,MAAM,CAAC,MAAM,KAAK,GAAG;IACnB,IAAI,EAAE,OAAO;IACb,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

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

@@ -20,16 +20,31 @@ const content = `--[[
 local rcall = redis.call
 local jobId = ARGV[2]
 -- Includes
+--[[
+  Function to add job in target list and add marker if needed.
+]]
+-- Includes
+--[[
+  Add marker if needed when a job is available.
+]]
+local function addBaseMarkerIfNeeded(markerKey, isPaused)
+  if not isPaused then
+    rcall("ZADD", markerKey, 0, "0")
+  end  
+end
+local function addJobInTargetList(targetKey, markerKey, pushCmd, isPaused, jobId)
+  rcall(pushCmd, targetKey, jobId)
+  addBaseMarkerIfNeeded(markerKey, isPaused)
+end
 --[[
   Function to add job considering priority.
 ]]
+-- Includes
 local function addJobWithPriority(markerKey, prioritizedKey, priority, jobId, priorityCounterKey, isPaused)
   local prioCounter = rcall("INCR", priorityCounterKey)
   local score = priority * 0x100000000 + bit.band(prioCounter, 0xffffffffffff)
   rcall("ZADD", prioritizedKey, score, jobId)
-  if not isPaused then
-    rcall("ZADD", markerKey, 0, "0")
-  end
+  addBaseMarkerIfNeeded(markerKey, isPaused)
 end
 --[[
   Function to check for the meta.paused key to decide if we are paused or not
@@ -54,8 +69,7 @@ if rcall("ZREM", KEYS[1], jobId) == 1 then
     if marker and string.sub(marker, 1, 2) == "0:" then rcall("LPOP", target) end
     if priority == 0 then
         -- LIFO or FIFO
-        rcall("LPUSH", target, jobId)
-        if not paused then rcall("ZADD", KEYS[8], 0, "0") end
+        addJobInTargetList(target, KEYS[8], "LPUSH", paused, jobId)
     else
         addJobWithPriority(KEYS[8], KEYS[5], priority, jobId, KEYS[6], paused)
     end

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

@@ -1 +1 @@
-{"version":3,"file":"promote-8.js","sourceRoot":"","sources":["../../../src/scripts/promote-8.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqEf,CAAC;AACF,MAAM,CAAC,MAAM,OAAO,GAAG;IACrB,IAAI,EAAE,SAAS;IACf,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}
+{"version":3,"file":"promote-8.js","sourceRoot":"","sources":["../../../src/scripts/promote-8.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmFf,CAAC;AACF,MAAM,CAAC,MAAM,OAAO,GAAG;IACrB,IAAI,EAAE,SAAS;IACf,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

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

@@ -28,13 +28,20 @@ local rcall = redis.call
 --[[
   Function to add job considering priority.
 ]]
+-- Includes
+--[[
+  Add marker if needed when a job is available.
+]]
+local function addBaseMarkerIfNeeded(markerKey, isPaused)
+  if not isPaused then
+    rcall("ZADD", markerKey, 0, "0")
+  end  
+end
 local function addJobWithPriority(markerKey, prioritizedKey, priority, jobId, priorityCounterKey, isPaused)
   local prioCounter = rcall("INCR", priorityCounterKey)
   local score = priority * 0x100000000 + bit.band(prioCounter, 0xffffffffffff)
   rcall("ZADD", prioritizedKey, score, jobId)
-  if not isPaused then
-    rcall("ZADD", markerKey, 0, "0")
-  end
+  addBaseMarkerIfNeeded(markerKey, isPaused)
 end
 --[[
   Function to get max events value or set by default 10000.
@@ -65,6 +72,14 @@ end
       'waiting'
 ]]
 -- Includes
+--[[
+  Function to add job in target list and add marker if needed.
+]]
+-- Includes
+local function addJobInTargetList(targetKey, markerKey, pushCmd, isPaused, jobId)
+  rcall(pushCmd, targetKey, jobId)
+  addBaseMarkerIfNeeded(markerKey, isPaused)
+end
 -- Try to get as much as 1000 jobs at once
 local function promoteDelayedJobs(delayedKey, markerKey, targetKey, prioritizedKey,
                                   eventStreamKey, prefix, timestamp, priorityCounterKey, isPaused)
@@ -77,10 +92,7 @@ local function promoteDelayedJobs(delayedKey, markerKey, targetKey, prioritizedK
                 tonumber(rcall("HGET", jobKey, "priority")) or 0
             if priority == 0 then
                 -- LIFO or FIFO
-                rcall("LPUSH", targetKey, jobId)
-                if not isPaused then
-                    rcall("ZADD", markerKey, 0, "0")
-                end
+                addJobInTargetList(targetKey, markerKey, "LPUSH", isPaused, jobId)
             else
                 addJobWithPriority(markerKey, prioritizedKey, priority,
                   jobId, priorityCounterKey, isPaused)
@@ -111,6 +123,7 @@ if rcall("EXISTS", KEYS[4]) == 1 then
   -- Standard or priority add
   if priority == 0 then
     rcall(ARGV[3], target, ARGV[4])
+    -- TODO: check if we need to add marker in this case too
   else
     addJobWithPriority(markerKey, KEYS[8], priority, ARGV[4], KEYS[9], paused)
   end

package/dist/esm/scripts/retryJob-10.js.map

@@ -1 +1 @@
-{"version":3,"file":"retryJob-10.js","sourceRoot":"","sources":["../../../src/scripts/retryJob-10.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6Hf,CAAC;AACF,MAAM,CAAC,MAAM,QAAQ,GAAG;IACtB,IAAI,EAAE,UAAU;IAChB,OAAO;IACP,IAAI,EAAE,EAAE;CACT,CAAC"}
+{"version":3,"file":"retryJob-10.js","sourceRoot":"","sources":["../../../src/scripts/retryJob-10.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0If,CAAC;AACF,MAAM,CAAC,MAAM,QAAQ,GAAG;IACtB,IAAI,EAAE,UAAU;IAChB,OAAO;IACP,IAAI,EAAE,EAAE;CACT,CAAC"}