bullmq 4.16.0 → 5.0.0

package/dist/esm/commands/{moveToFinished-13.lua → moveToFinished-14.lua}

@@ -22,22 +22,21 @@
       KEYS[11] completed/failed key
       KEYS[12] jobId key
       KEYS[13] metrics key
+      KEYS[14] marker key
 
       ARGV[1]  jobId
       ARGV[2]  timestamp
       ARGV[3]  msg property returnvalue / failedReason
       ARGV[4]  return value / failed reason
       ARGV[5]  target (completed/failed)
-      ARGV[6]  event data (? maybe just send jobid).
-      ARGV[7]  fetch next?
-      ARGV[8]  keys prefix
-      ARGV[9]  opts
+      ARGV[6]  fetch next?
+      ARGV[7]  keys prefix
+      ARGV[8]  opts
 
       opts - token - lock token
       opts - keepJobs
       opts - lockDuration - lock duration in milliseconds
       opts - attempts max attempts
-      opts - attemptsMade
       opts - maxMetricsSize
       opts - fpof - fail parent on fail
       opts - rdof - remove dependency on fail
@@ -72,11 +71,10 @@ local rcall = redis.call
 
 local jobIdKey = KEYS[12]
 if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
-    local opts = cmsgpack.unpack(ARGV[9])
+    local opts = cmsgpack.unpack(ARGV[8])
 
     local token = opts['token']
     local attempts = opts['attempts']
-    local attemptsMade = opts['attemptsMade']
     local maxMetricsSize = opts['maxMetricsSize']
     local maxCount = opts['keepJobs']['count']
     local maxAge = opts['keepJobs']['age']
@@ -120,8 +118,9 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
 
     if (numRemovedElements < 1) then return -3 end
 
+    local metaKey = KEYS[9]
     -- Trim events before emiting them to avoid trimming events emitted in this script
-    trimEvents(KEYS[9], KEYS[4])
+    trimEvents(metaKey, KEYS[4])
 
     -- If job has a parent we need to
     -- 1) remove this job id from parents dependencies
@@ -144,17 +143,20 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
         else
             if opts['fpof'] then
                 moveParentFromWaitingChildrenToFailed(parentQueueKey, parentKey,
-                                            parentId, jobIdKey, timestamp)
+                                                      parentId, jobIdKey,
+                                                      timestamp)
             elseif opts['rdof'] then
                 local dependenciesSet = parentKey .. ":dependencies"
                 if rcall("SREM", dependenciesSet, jobIdKey) == 1 then
                     moveParentToWaitIfNeeded(parentQueueKey, dependenciesSet,
-                        parentKey, parentId, timestamp)
+                                             parentKey, parentId, timestamp)
                 end
             end
         end
     end
 
+    local attemptsMade = rcall("HINCRBY", jobIdKey, "atm", 1)
+
     -- Remove job?
     if maxCount ~= 0 then
         local targetSet = KEYS[11]
@@ -164,7 +166,7 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
         -- "returnvalue" / "failedReason" and "finishedOn"
 
         -- Remove old jobs?
-        local prefix = ARGV[8]
+        local prefix = ARGV[7]
 
         if maxAge ~= nil then
             removeJobsByMaxAge(timestamp, maxAge, targetSet, prefix)
@@ -197,13 +199,13 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
 
     -- Try to get next job to avoid an extra roundtrip if the queue is not closing,
     -- and not rate limited.
-    if (ARGV[7] == "1") then
+    if (ARGV[6] == "1") then
 
-        local target, paused = getTargetQueueList(KEYS[9], KEYS[1], KEYS[8])
+        local target, paused = getTargetQueueList(metaKey, KEYS[1], KEYS[8])
 
         -- Check if there are delayed jobs that can be promoted
-        promoteDelayedJobs(KEYS[7], KEYS[1], target, KEYS[3],
-                           KEYS[4], ARGV[8], timestamp, paused, KEYS[10])
+        promoteDelayedJobs(KEYS[7], KEYS[14], target, KEYS[3], KEYS[4], ARGV[7],
+                           timestamp, KEYS[10], paused)
 
         local maxJobs = tonumber(opts['limiter'] and opts['limiter']['max'])
         -- Check if we are rate limited first.
@@ -217,25 +219,30 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
         jobId = rcall("RPOPLPUSH", KEYS[1], KEYS[2])
 
         if jobId then
+            -- Markers in waitlist DEPRECATED in v5: Remove in v6.
             if string.sub(jobId, 1, 2) == "0:" then
                 rcall("LREM", KEYS[2], 1, jobId)
 
                 -- If jobId is special ID 0:delay (delay greater than 0), then there is no job to process
                 -- but if ID is 0:0, then there is at least 1 prioritized job to process
                 if jobId == "0:0" then
-                    jobId = moveJobFromPriorityToActive(KEYS[3], KEYS[2], KEYS[10])
-                    return prepareJobForProcessing(KEYS, ARGV[8], target, jobId, timestamp,
-                        maxJobs, expireTime, opts)
+                    jobId = moveJobFromPriorityToActive(KEYS[3], KEYS[2],
+                                                        KEYS[10])
+                    return prepareJobForProcessing(KEYS, ARGV[7], target, jobId,
+                                                   timestamp, maxJobs,
+                                                   expireTime, opts)
                 end
             else
-                return prepareJobForProcessing(KEYS, ARGV[8], target, jobId, timestamp, maxJobs,
-                    expireTime, opts)
+                return prepareJobForProcessing(KEYS, ARGV[7], target, jobId,
+                                               timestamp, maxJobs, expireTime,
+                                               opts)
             end
         else
             jobId = moveJobFromPriorityToActive(KEYS[3], KEYS[2], KEYS[10])
             if jobId then
-                return prepareJobForProcessing(KEYS, ARGV[8], target, jobId, timestamp, maxJobs,
-                    expireTime, opts)
+                return prepareJobForProcessing(KEYS, ARGV[7], target, jobId,
+                                               timestamp, maxJobs, expireTime,
+                                               opts)
             end
         end
 

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

@@ -11,7 +11,7 @@
     ARGV[2] child key
     ARGV[3] timestamp
     ARGV[4] the id of the job
-    
+
   Output:
     0 - OK
     1 - There are not pending dependencies.
@@ -21,7 +21,8 @@
 ]]
 local rcall = redis.call
 
-local function moveToWaitingChildren (activeKey, waitingChildrenKey, jobId, timestamp, lockKey, token)
+local function moveToWaitingChildren (activeKey, waitingChildrenKey, jobId, timestamp,
+    lockKey, jobKey, token)
   if token ~= "0" then
     if rcall("GET", lockKey) == token then
       rcall("DEL", lockKey)
@@ -46,13 +47,15 @@ end
 if rcall("EXISTS", KEYS[4]) == 1 then
   if ARGV[2] ~= "" then
     if rcall("SISMEMBER", KEYS[4] .. ":dependencies", ARGV[2]) ~= 0 then
-      return moveToWaitingChildren(KEYS[2], KEYS[3], ARGV[4], ARGV[3], KEYS[1], ARGV[1])
+      return moveToWaitingChildren(KEYS[2], KEYS[3], ARGV[4], ARGV[3], KEYS[1], KEYS[4],
+        ARGV[1])
     end
 
     return 1
   else
     if rcall("SCARD", KEYS[4] .. ":dependencies") ~= 0 then 
-      return moveToWaitingChildren(KEYS[2], KEYS[3], ARGV[4], ARGV[3], KEYS[1], ARGV[1])
+      return moveToWaitingChildren(KEYS[2], KEYS[3], ARGV[4], ARGV[3], KEYS[1], KEYS[4],
+        ARGV[1])
     end
 
     return 1

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

@@ -0,0 +1,41 @@
+--[[
+  Pauses or resumes a queue globably.
+
+  Input:
+    KEYS[1] 'wait' or 'paused''
+    KEYS[2] 'paused' or 'wait'
+    KEYS[3] 'meta'
+    KEYS[4] 'prioritized'
+    KEYS[5] events stream key
+    KEYS[6] 'delayed'
+    KEYS|7] 'marker'
+
+    ARGV[1] 'paused' or 'resumed'
+
+  Event:
+    publish paused or resumed event.
+]]
+local rcall = redis.call
+
+-- Includes
+--- @include "includes/addDelayMarkerIfNeeded"
+
+local markerKey = KEYS[7]
+local hasJobs = rcall("EXISTS", KEYS[1]) == 1
+if hasJobs then rcall("RENAME", KEYS[1], KEYS[2]) end
+
+if ARGV[1] == "paused" then
+    rcall("HSET", KEYS[3], "paused", 1)
+    rcall("DEL", markerKey)
+else
+    rcall("HDEL", KEYS[3], "paused")
+
+    if hasJobs or rcall("ZCARD", KEYS[4]) > 0 then
+        -- Add marker if there are waiting or priority jobs
+        rcall("ZADD", markerKey, 0, "0")
+    else
+        addDelayMarkerIfNeeded(markerKey, KEYS[6])
+    end
+end
+
+rcall("XADD", KEYS[5], "*", "event", ARGV[1]);

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

@@ -0,0 +1,60 @@
+--[[
+  Promotes a job that is currently "delayed" to the "waiting" state
+
+    Input:
+      KEYS[1] 'delayed'
+      KEYS[2] 'wait'
+      KEYS[3] 'paused'
+      KEYS[4] 'meta'
+      KEYS[5] 'prioritized'
+      KEYS[6] 'pc' priority counter
+      KEYS[7] 'event stream'
+      KEYS[8] 'marker'
+
+      ARGV[1]  queue.toKey('')
+      ARGV[2]  jobId
+
+    Output:
+       0 - OK
+      -3 - Job not in delayed zset.
+
+    Events:
+      'waiting'
+]]
+local rcall = redis.call
+local jobId = ARGV[2]
+
+-- Includes
+--- @include "includes/addJobWithPriority"
+--- @include "includes/getTargetQueueList"
+
+if rcall("ZREM", KEYS[1], jobId) == 1 then
+    local jobKey = ARGV[1] .. jobId
+    local priority = tonumber(rcall("HGET", jobKey, "priority")) or 0
+    local metaKey = KEYS[4]
+
+    -- Remove delayed "marker" from the wait list if there is any.
+    -- Since we are adding a job we do not need the marker anymore.
+    -- Markers in waitlist DEPRECATED in v5: Remove in v6.
+    local target, paused = getTargetQueueList(metaKey, KEYS[2], KEYS[3])
+    local marker = rcall("LINDEX", target, 0)
+    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
+    else
+        addJobWithPriority(KEYS[8], KEYS[5], priority, jobId, KEYS[6], paused)
+    end
+
+    -- Emit waiting event (wait..ing@token)
+    rcall("XADD", KEYS[7], "*", "event", "waiting", "jobId", jobId, "prev",
+          "delayed");
+
+    rcall("HSET", jobKey, "delay", 0)
+
+    return 0
+else
+    return -3
+end

package/dist/esm/commands/{retryJob-9.lua → retryJob-10.lua}

@@ -2,15 +2,16 @@
   Retries a failed job by moving it back to the wait queue.
 
     Input:
-      KEYS[1] 'active',
-      KEYS[2] 'wait'
-      KEYS[3] 'paused'
-      KEYS[4] job key
-      KEYS[5] 'meta'
-      KEYS[6] events stream
-      KEYS[7] delayed key
-      KEYS[8] prioritized key
-      KEYS[9] 'pc' priority counter
+      KEYS[1]  'active',
+      KEYS[2]  'wait'
+      KEYS[3]  'paused'
+      KEYS[4]  job key
+      KEYS[5]  'meta'
+      KEYS[6]  events stream
+      KEYS[7]  delayed key
+      KEYS[8]  prioritized key
+      KEYS[9]  'pc' priority counter
+      KEYS[10] 'marker'
 
       ARGV[1]  key prefix
       ARGV[2]  timestamp
@@ -34,9 +35,11 @@ local rcall = redis.call
 --- @include "includes/promoteDelayedJobs"
 
 local target, paused = getTargetQueueList(KEYS[5], 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], KEYS[2], target, KEYS[8], KEYS[6], ARGV[1], ARGV[2], paused, KEYS[9])
+promoteDelayedJobs(KEYS[7], markerKey, target, KEYS[8], KEYS[6], ARGV[1], ARGV[2], KEYS[9], paused)
 
 if rcall("EXISTS", KEYS[4]) == 1 then
 
@@ -57,9 +60,11 @@ if rcall("EXISTS", KEYS[4]) == 1 then
   if priority == 0 then
     rcall(ARGV[3], target, ARGV[4])
   else
-    addJobWithPriority(KEYS[2], KEYS[8], priority, paused, ARGV[4], KEYS[9])
+    addJobWithPriority(markerKey, KEYS[8], priority, ARGV[4], KEYS[9], paused)
   end
 
+  rcall("HINCRBY", KEYS[4], "atm", 1)
+
   local maxEvents = rcall("HGET", KEYS[5], "opts.maxLenEvents") or 10000
 
   -- Emit waiting event

package/dist/esm/interfaces/job-json.d.ts

@@ -7,6 +7,7 @@ export interface JobJson {
     opts: RedisJobOptions;
     progress: number | object;
     attemptsMade: number;
+    attemptsStarted: number;
     finishedOn?: number;
     processedOn?: number;
     timestamp: number;
@@ -24,7 +25,7 @@ export interface JobJsonRaw {
     delay: string;
     opts: string;
     progress: string;
-    attemptsMade: string;
+    attemptsMade?: string;
     finishedOn?: string;
     processedOn?: string;
     timestamp: string;
@@ -34,4 +35,6 @@ export interface JobJsonRaw {
     parentKey?: string;
     parent?: string;
     rjk?: string;
+    atm?: string;
+    ats?: string;
 }

package/dist/esm/interfaces/minimal-job.d.ts

@@ -2,6 +2,9 @@ import { JobsOptions, JobJsonSandbox } from '../types';
 import { JobJson } from './job-json';
 import { ParentKeys } from './parent';
 export type BulkJobOptions = Omit<JobsOptions, 'repeat'>;
+export interface MoveToDelayedOpts {
+    skipAttempt?: boolean;
+}
 export interface MoveToWaitingChildrenOpts {
     child?: {
         id: string;

package/dist/esm/interfaces/queue-options.d.ts

@@ -12,7 +12,7 @@ export interface QueueBaseOptions {
     /**
      * Options for connecting to a Redis instance.
      */
-    connection?: ConnectionOptions;
+    connection: ConnectionOptions;
     /**
      * Denotes commands should retry indefinitely.
      */

package/dist/esm/scripts/{addDelayedJob-7.js → addDelayedJob-6.js}

@@ -6,13 +6,12 @@ const content = `--[[
     - adds to delayed zset.
     - Emits a global event 'delayed' if the job is delayed.
     Input:
-      KEYS[1] 'wait',
-      KEYS[2] 'paused'
-      KEYS[3] 'meta'
-      KEYS[4] 'id'
-      KEYS[5] 'delayed'
-      KEYS[6] 'completed'
-      KEYS[7] events stream key
+      KEYS[1] 'marker',
+      KEYS[2] 'meta'
+      KEYS[3] 'id'
+      KEYS[4] 'delayed'
+      KEYS[5] 'completed'
+      KEYS[6] events stream key
       ARGV[1] msgpacked arguments array
             [1]  key prefix,
             [2]  custom id (use custom instead of one generated automatically)
@@ -29,13 +28,11 @@ const content = `--[[
         jobId  - OK
         -5     - Missing parent key
 ]]
-local waitKey = KEYS[1]
-local pausedKey = KEYS[2]
-local metaKey = KEYS[3]
-local idKey = KEYS[4]
-local delayedKey = KEYS[5]
-local completedKey = KEYS[6]
-local eventsKey = KEYS[7]
+local metaKey = KEYS[2]
+local idKey = KEYS[3]
+local delayedKey = KEYS[4]
+local completedKey = KEYS[5]
+local eventsKey = KEYS[6]
 local jobId
 local jobIdKey
 local rcall = redis.call
@@ -74,7 +71,7 @@ local function storeJob(eventsKey, jobIdKey, jobId, name, data, opts, timestamp,
 end
 --[[
   Add delay marker if needed.
-]]
+]] 
 -- Includes
 --[[
   Function to return the next delayed job timestamp.
@@ -89,36 +86,20 @@ local function getNextDelayedTimestamp(delayedKey)
     return nextTimestamp
   end
 end
-local function addDelayMarkerIfNeeded(targetKey, delayedKey)
-  local waitLen = rcall("LLEN", targetKey)
-  if waitLen <= 1 then
+local function addDelayMarkerIfNeeded(markerKey, delayedKey)
     local nextTimestamp = getNextDelayedTimestamp(delayedKey)
     if nextTimestamp ~= nil then
-      -- Check if there is already a marker with older timestamp
-      -- if there is, we need to replace it.
-      if waitLen == 1 then
-        local marker = rcall("LINDEX", targetKey, 0)
-        local oldTimestamp = tonumber(marker:sub(3))
-        if oldTimestamp and oldTimestamp > nextTimestamp then
-          rcall("LSET", targetKey, 0, "0:" .. nextTimestamp)
-        end
-      else
-        -- if there is no marker, then we need to add one
-        rcall("LPUSH", targetKey, "0:" .. nextTimestamp)
-      end
+        -- Replace the score of the marker with the newest known
+        -- next timestamp.
+        rcall("ZADD", markerKey, nextTimestamp, "0")
     end
-  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
+local function isQueuePaused(queueMetaKey)
+    return rcall("HEXISTS", queueMetaKey, "paused") == 1
 end
 --[[
   Validate and move or add dependencies to parent.
@@ -131,56 +112,64 @@ end
 --[[
   Function to add job considering priority.
 ]]
--- Includes
---[[
-  Function priority marker to wait if needed
-  in order to wake up our workers and to respect priority
-  order as much as possible
-]]
-local function addPriorityMarkerIfNeeded(waitKey)
-  local waitLen = rcall("LLEN", waitKey)
-  if waitLen == 0 then
-    rcall("LPUSH", waitKey, "0:0")
-  end
-end
-local function addJobWithPriority(waitKey, prioritizedKey, priority, paused, jobId, priorityCounterKey)
+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 paused then
-    addPriorityMarkerIfNeeded(waitKey)
+  if not isPaused then
+    rcall("ZADD", markerKey, 0, "0")
   end
 end
-local function moveParentToWaitIfNeeded(parentQueueKey, parentDependenciesKey, parentKey, parentId, timestamp)
-  local isParentActive = rcall("ZSCORE", parentQueueKey .. ":waiting-children", parentId)
-  if rcall("SCARD", parentDependenciesKey) == 0 and isParentActive then 
-    rcall("ZREM", parentQueueKey .. ":waiting-children", parentId)
-    local parentWaitKey = parentQueueKey .. ":wait"
-    local parentTarget, paused = getTargetQueueList(parentQueueKey .. ":meta", parentWaitKey,
-      parentQueueKey .. ":paused")
-    local jobAttributes = rcall("HMGET", parentKey, "priority", "delay")
-    local priority = tonumber(jobAttributes[1]) or 0
-    local delay = tonumber(jobAttributes[2]) or 0
-    if delay > 0 then
-      local delayedTimestamp = tonumber(timestamp) + delay 
-      local score = delayedTimestamp * 0x1000
-      local parentDelayedKey = parentQueueKey .. ":delayed" 
-      rcall("ZADD", parentDelayedKey, score, parentId)
-      rcall("XADD", parentQueueKey .. ":events", "*", "event", "delayed", "jobId", parentId,
-        "delay", delayedTimestamp)
-      addDelayMarkerIfNeeded(parentTarget, parentDelayedKey)
-    else
-      if priority == 0 then
-        rcall("RPUSH", parentTarget, parentId)
-      else
-        addJobWithPriority(parentWaitKey, parentQueueKey .. ":prioritized", priority, paused,
-          parentId, parentQueueKey .. ":pc")
-      end
-      rcall("XADD", parentQueueKey .. ":events", "*", "event", "waiting", "jobId", parentId,
-        "prev", "waiting-children")
-    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
+local function moveParentToWaitIfNeeded(parentQueueKey, parentDependenciesKey,
+                                        parentKey, parentId, timestamp)
+    local isParentActive = rcall("ZSCORE",
+                                 parentQueueKey .. ":waiting-children", parentId)
+    if rcall("SCARD", parentDependenciesKey) == 0 and isParentActive then
+        rcall("ZREM", parentQueueKey .. ":waiting-children", parentId)
+        local parentWaitKey = parentQueueKey .. ":wait"
+        local parentPausedKey = parentQueueKey .. ":paused"
+        local parentMetaKey = parentQueueKey .. ":meta"
+        local parentMarkerKey = parentQueueKey .. ":marker"
+        local jobAttributes = rcall("HMGET", parentKey, "priority", "delay")
+        local priority = tonumber(jobAttributes[1]) or 0
+        local delay = tonumber(jobAttributes[2]) or 0
+        if delay > 0 then
+            local delayedTimestamp = tonumber(timestamp) + delay
+            local score = delayedTimestamp * 0x1000
+            local parentDelayedKey = parentQueueKey .. ":delayed"
+            rcall("ZADD", parentDelayedKey, score, parentId)
+            rcall("XADD", parentQueueKey .. ":events", "*", "event", "delayed",
+                  "jobId", parentId, "delay", delayedTimestamp)
+            addDelayMarkerIfNeeded(parentMarkerKey, parentDelayedKey)
+        else
+            if priority == 0 then
+                local parentTarget, _paused =
+                    getTargetQueueList(parentMetaKey, parentWaitKey,
+                                       parentPausedKey)
+                rcall("RPUSH", parentTarget, parentId)
+                rcall("ZADD", parentMarkerKey, 0, "0")
+            else
+                local isPaused = isQueuePaused(parentMetaKey)
+                addJobWithPriority(parentMarkerKey,
+                                   parentQueueKey .. ":prioritized", priority,
+                                   parentId, parentQueueKey .. ":pc", isPaused)
+            end
+            rcall("XADD", parentQueueKey .. ":events", "*", "event", "waiting",
+                  "jobId", parentId, "prev", "waiting-children")
+        end
+    end
+end
 local function updateParentDepsIfNeeded(parentKey, parentQueueKey, parentDependenciesKey,
   parentId, jobIdKey, returnvalue, timestamp )
   local processedSet = parentKey .. ":processed"
@@ -252,13 +241,13 @@ local score = delayedTimestamp * 0x1000 + bit.band(jobCounter, 0xfff)
 rcall("ZADD", delayedKey, score, jobId)
 rcall("XADD", eventsKey, "MAXLEN", "~", maxEvents, "*", "event", "delayed",
       "jobId", jobId, "delay", delayedTimestamp)
--- If wait list is empty, and this delayed job is the next one to be processed,
--- then we need to signal the workers by adding a dummy job (jobId 0:delay) to the wait list.
-local target = getTargetQueueList(metaKey, KEYS[1], KEYS[2])
-addDelayMarkerIfNeeded(target, delayedKey)
+-- mark that a delayed job is available
+local isPaused = isQueuePaused(metaKey)
+if not isPaused then
+    local markerKey = KEYS[1]
+    addDelayMarkerIfNeeded(markerKey, delayedKey)
+end
 -- Check if this job is a child of another job, if so add it to the parents dependencies
--- TODO: Should not be possible to add a child job to a parent that is not in the "waiting-children" status.
--- fail in this case.
 if parentDependenciesKey ~= nil then
     rcall("SADD", parentDependenciesKey, jobIdKey)
 end
@@ -267,6 +256,6 @@ return jobId .. "" -- convert to string
 export const addDelayedJob = {
     name: 'addDelayedJob',
     content,
-    keys: 7,
+    keys: 6,
 };
-//# sourceMappingURL=addDelayedJob-7.js.map
+//# sourceMappingURL=addDelayedJob-6.js.map

package/dist/esm/scripts/{moveToActive-10.js.map → addDelayedJob-6.js.map}

@@ -1 +1 @@
-{"version":3,"file":"moveToActive-10.js","sourceRoot":"","sources":["../../../src/scripts/moveToActive-10.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmPf,CAAC;AACF,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,IAAI,EAAE,cAAc;IACpB,OAAO;IACP,IAAI,EAAE,EAAE;CACT,CAAC"}
+{"version":3,"file":"addDelayedJob-6.js","sourceRoot":"","sources":["../../../src/scripts/addDelayedJob-6.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8Pf,CAAC;AACF,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,IAAI,EAAE,eAAe;IACrB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}