bullmq 5.41.7 → 5.41.9

package/dist/cjs/commands/includes/addJobFromScheduler.lua

@@ -0,0 +1,41 @@
+--[[
+  Add delay marker if needed.
+]]
+
+-- Includes
+--- @include "addDelayedJob"
+--- @include "addJobWithPriority"
+--- @include "isQueuePaused"
+--- @include "storeJob"
+
+local function addJobFromScheduler(jobKey, jobId, rawOpts, waitKey, pausedKey, metaKey, prioritizedKey,
+  priorityCounter, delayedKey, markerKey, eventsKey, name, maxEvents, timestamp, data, jobSchedulerId)
+  local opts = cmsgpack.unpack(rawOpts)
+
+  local delay, priority = storeJob(eventsKey, jobKey, jobId, name, data,
+    opts, timestamp, nil, nil, jobSchedulerId)
+
+  if delay ~= 0 then
+    addDelayedJob(jobId, delayedKey, eventsKey, timestamp, maxEvents, markerKey, delay)
+  else
+    local isPaused = isQueuePaused(metaKey)
+  
+    -- Standard or priority add
+    if priority == 0 then
+      if isPaused then
+        -- LIFO or FIFO
+        local pushCmd = opts['lifo'] and 'RPUSH' or 'LPUSH'
+        rcall(pushCmd, pausedKey, jobId)
+      else
+        -- LIFO or FIFO
+        local pushCmd = opts['lifo'] and 'RPUSH' or 'LPUSH'
+        rcall(pushCmd, waitKey, jobId)
+      end
+    else
+      -- Priority add
+      addJobWithPriority(markerKey, prioritizedKey, priority, jobId, priorityCounter, isPaused)
+    end
+    -- Emit waiting event
+    rcall("XADD", eventsKey, "MAXLEN", "~", maxEvents,  "*", "event", "waiting", "jobId", jobId)
+  end
+end

package/dist/cjs/commands/includes/isJobSchedulerJob.lua

@@ -6,7 +6,7 @@ local function isJobSchedulerJob(jobId, jobKey, jobSchedulersKey)
   local repeatJobKey = rcall("HGET", jobKey, "rjk")
   if repeatJobKey  then
     local prevMillis = rcall("ZSCORE", jobSchedulersKey, repeatJobKey)
-    if prevMillis ~= false then
+    if prevMillis then
       local currentDelayedJobId = "repeat:" .. repeatJobKey .. ":" .. prevMillis
       return jobId == currentDelayedJobId
     end

package/dist/cjs/commands/includes/trimEvents.lua

@@ -7,7 +7,7 @@
 
 local function trimEvents(metaKey, eventStreamKey)
   local maxEvents = getOrSetMaxEvents(metaKey)
-  if maxEvents ~= false then
+  if maxEvents then
     rcall("XTRIM", eventStreamKey, "MAXLEN", "~", maxEvents)
   else
     rcall("XTRIM", eventStreamKey, "MAXLEN", "~", 10000)

package/dist/cjs/commands/includes/updateExistingJobsParent.lua

@@ -12,7 +12,7 @@ local function updateExistingJobsParent(parentKey, parent, parentData,
                                         parentDependenciesKey, completedKey,
                                         jobIdKey, jobId, timestamp)
     if parentKey ~= nil then
-        if rcall("ZSCORE", completedKey, jobId) ~= false then
+        if rcall("ZSCORE", completedKey, jobId) then
             local returnvalue = rcall("HGET", jobIdKey, "returnvalue")
             updateParentDepsIfNeeded(parentKey, parent['queueKey'],
                                      parentDependenciesKey, parent['id'],

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

@@ -23,7 +23,7 @@ if rcall("EXISTS", KEYS[3]) ~= 1 then
   return -1
 end
 
-if rcall("ZSCORE", KEYS[1], ARGV[1]) ~= false then
+if rcall("ZSCORE", KEYS[1], ARGV[1]) then
   if ARGV[2] == "1" then
     local returnValue = rcall("HGET", KEYS[3], "returnvalue")
 
@@ -32,7 +32,7 @@ if rcall("ZSCORE", KEYS[1], ARGV[1]) ~= false then
   return 1
 end
 
-if rcall("ZSCORE", KEYS[2], ARGV[1]) ~= false then
+if rcall("ZSCORE", KEYS[2], ARGV[1]) then
   if ARGV[2] == "1" then
     local failedReason = rcall("HGET", KEYS[3], "failedReason")
 

package/dist/cjs/commands/{updateJobScheduler-7.lua → updateJobScheduler-11.lua}

@@ -2,13 +2,17 @@
   Updates a job scheduler and adds next delayed job
 
   Input:
-    KEYS[1] 'marker',
-    KEYS[2] 'meta'
-    KEYS[3] 'id'
-    KEYS[4] 'delayed'
-    KEYS[5] events stream key
-    KEYS[6] 'repeat' key
-    KEYS[7] producer key
+    KEYS[1]  'repeat' key
+    KEYS[2]  'delayed'
+    KEYS[3]  'wait' key
+    KEYS[4]  'paused' key
+    KEYS[5]  'meta'
+    KEYS[6]  'prioritized' key
+    KEYS[7]  'marker',
+    KEYS[8]  'id'
+    KEYS[9]  events stream key
+    KEYS[10] 'pc' priority counter
+    KEYS[11] producer key
 
     ARGV[1] next milliseconds
     ARGV[2] jobs scheduler id
@@ -22,8 +26,12 @@
       next delayed job id  - OK
 ]]
 local rcall = redis.call
-local repeatKey = KEYS[6]
-local delayedKey = KEYS[4]
+local repeatKey = KEYS[1]
+local delayedKey = KEYS[2]
+local waitKey = KEYS[3]
+local pausedKey = KEYS[4]
+local metaKey = KEYS[5]
+local prioritizedKey = KEYS[6]
 local nextMillis = ARGV[1]
 local jobSchedulerId = ARGV[2]
 local timestamp = ARGV[5]
@@ -31,7 +39,7 @@ local prefixKey = ARGV[6]
 local producerId = ARGV[7]
 
 -- Includes
---- @include "includes/addDelayedJob"
+--- @include "includes/addJobFromScheduler"
 --- @include "includes/getOrSetMaxEvents"
 
 local schedulerKey = repeatKey .. ":" .. jobSchedulerId
@@ -43,19 +51,16 @@ local prevMillis = rcall("ZSCORE", repeatKey, jobSchedulerId)
 if prevMillis ~= false then
   local currentDelayedJobId =  "repeat:" .. jobSchedulerId .. ":" .. prevMillis
 
-  if producerId == currentDelayedJobId then
+  if producerId == currentDelayedJobId and rcall("EXISTS", nextDelayedJobKey) ~= 1 then
     local schedulerAttributes = rcall("HMGET", schedulerKey, "name", "data")
 
     rcall("ZADD", repeatKey, nextMillis, jobSchedulerId)
     rcall("HINCRBY", schedulerKey, "ic", 1)
 
-    local eventsKey = KEYS[5]
-    local metaKey = KEYS[2]
+    local eventsKey = KEYS[9]
     local maxEvents = getOrSetMaxEvents(metaKey)
 
-    rcall("INCR", KEYS[3])
-
-    local delayedOpts = cmsgpack.unpack(ARGV[4])
+    rcall("INCR", KEYS[8])
 
     -- TODO: remove this workaround in next breaking change,
     -- all job-schedulers must save job data
@@ -65,11 +70,13 @@ if prevMillis ~= false then
       rcall("HSET", schedulerKey, "data", templateData)
     end
 
-    addDelayedJob(nextDelayedJobKey, nextDelayedJobId, delayedKey, eventsKey, schedulerAttributes[1],
-      templateData or '{}', delayedOpts, timestamp, jobSchedulerId, maxEvents, KEYS[1], nil, nil)
-  
-    if KEYS[7] ~= "" then
-      rcall("HSET", KEYS[7], "nrjid", nextDelayedJobId)
+    addJobFromScheduler(nextDelayedJobKey, nextDelayedJobId, ARGV[4], waitKey, pausedKey, metaKey, prioritizedKey,
+      KEYS[10], delayedKey, KEYS[7], eventsKey, schedulerAttributes[1], maxEvents, ARGV[5],
+      templateData or '{}', jobSchedulerId)
+
+    -- TODO: remove this workaround in next breaking change
+    if KEYS[11] ~= "" then
+      rcall("HSET", KEYS[11], "nrjid", nextDelayedJobId)
     end
 
     return nextDelayedJobId .. "" -- convert to string

package/dist/cjs/commands/updateRepeatableJobMillis-1.lua

@@ -17,7 +17,7 @@ local nextMillis = ARGV[1]
 local customKey = ARGV[2]
 local legacyCustomKey = ARGV[3]
 
-if rcall("ZSCORE", repeatKey, customKey) ~= false then
+if rcall("ZSCORE", repeatKey, customKey) then
     rcall("ZADD", repeatKey, nextMillis, customKey)
     return customKey
 elseif rcall("ZSCORE", repeatKey, legacyCustomKey) ~= false then

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

@@ -284,7 +284,7 @@ local function updateExistingJobsParent(parentKey, parent, parentData,
                                         parentDependenciesKey, completedKey,
                                         jobIdKey, jobId, timestamp)
     if parentKey ~= nil then
-        if rcall("ZSCORE", completedKey, jobId) ~= false then
+        if rcall("ZSCORE", completedKey, jobId) then
             local returnvalue = rcall("HGET", jobIdKey, "returnvalue")
             updateParentDepsIfNeeded(parentKey, parent['queueKey'],
                                      parentDependenciesKey, parent['id'],

package/dist/cjs/scripts/addJobScheduler-10.js

@@ -34,12 +34,19 @@ const content = `--[[
 local rcall = redis.call
 local repeatKey = KEYS[1]
 local delayedKey = KEYS[2]
+local waitKey = KEYS[3]
+local pausedKey = KEYS[4]
+local metaKey = KEYS[5]
 local prioritizedKey = KEYS[6]
 local nextMillis = ARGV[1]
 local jobSchedulerId = ARGV[3]
 local templateOpts = cmsgpack.unpack(ARGV[5])
 local prefixKey = ARGV[8]
 -- Includes
+--[[
+  Add delay marker if needed.
+]]
+-- Includes
 --[[
   Adds a delayed job to the queue by doing the following:
     - Creates a new job key with the job data.
@@ -130,42 +137,80 @@ local function addJobWithPriority(markerKey, prioritizedKey, priority, jobId, pr
   addBaseMarkerIfNeeded(markerKey, isPausedOrMaxed)
 end
 --[[
-  Function to get max events value or set by default 10000.
+  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 getOrSetMaxEvents(metaKey)
-  local maxEvents = rcall("HGET", metaKey, "opts.maxLenEvents")
-  if not maxEvents then
-    maxEvents = 10000
-    rcall("HSET", metaKey, "opts.maxLenEvents", maxEvents)
-  end
-  return maxEvents
+local function isQueuePaused(queueMetaKey)
+  return rcall("HEXISTS", queueMetaKey, "paused") == 1
 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 store a job
 ]]
-local function getTargetQueueList(queueMetaKey, activeKey, waitKey, pausedKey)
-  local queueAttributes = rcall("HMGET", queueMetaKey, "paused", "concurrency")
-  if queueAttributes[1] then
-    return pausedKey, true
+local function storeJob(eventsKey, jobIdKey, jobId, name, data, opts, timestamp,
+                        parentKey, parentData, repeatJobKey)
+    local jsonOpts = cjson.encode(opts)
+    local delay = opts['delay'] or 0
+    local priority = opts['priority'] or 0
+    local debounceId = opts['de'] and opts['de']['id']
+    local optionalValues = {}
+    if parentKey ~= nil then
+        table.insert(optionalValues, "parentKey")
+        table.insert(optionalValues, parentKey)
+        table.insert(optionalValues, "parent")
+        table.insert(optionalValues, parentData)
+    end
+    if repeatJobKey ~= nil then
+        table.insert(optionalValues, "rjk")
+        table.insert(optionalValues, repeatJobKey)
+    end
+    if debounceId then
+        table.insert(optionalValues, "deid")
+        table.insert(optionalValues, debounceId)
+    end
+    rcall("HMSET", jobIdKey, "name", name, "data", data, "opts", jsonOpts,
+          "timestamp", timestamp, "delay", delay, "priority", priority,
+          unpack(optionalValues))
+    rcall("XADD", eventsKey, "*", "event", "added", "jobId", jobId, "name", name)
+    return delay, priority
+end
+local function addJobFromScheduler(jobKey, jobId, rawOpts, waitKey, pausedKey, metaKey, prioritizedKey,
+  priorityCounter, delayedKey, markerKey, eventsKey, name, maxEvents, timestamp, data, jobSchedulerId)
+  local opts = cmsgpack.unpack(rawOpts)
+  local delay, priority = storeJob(eventsKey, jobKey, jobId, name, data,
+    opts, timestamp, nil, nil, jobSchedulerId)
+  if delay ~= 0 then
+    addDelayedJob(jobId, delayedKey, eventsKey, timestamp, maxEvents, markerKey, delay)
   else
-    if queueAttributes[2] then
-      local activeCount = rcall("LLEN", activeKey)
-      if activeCount >= tonumber(queueAttributes[2]) then
-        return waitKey, true
+    local isPaused = isQueuePaused(metaKey)
+    -- Standard or priority add
+    if priority == 0 then
+      if isPaused then
+        -- LIFO or FIFO
+        local pushCmd = opts['lifo'] and 'RPUSH' or 'LPUSH'
+        rcall(pushCmd, pausedKey, jobId)
       else
-        return waitKey, false
+        -- LIFO or FIFO
+        local pushCmd = opts['lifo'] and 'RPUSH' or 'LPUSH'
+        rcall(pushCmd, waitKey, jobId)
       end
+    else
+      -- Priority add
+      addJobWithPriority(markerKey, prioritizedKey, priority, jobId, priorityCounter, isPaused)
     end
+    -- Emit waiting event
+    rcall("XADD", eventsKey, "MAXLEN", "~", maxEvents,  "*", "event", "waiting", "jobId", jobId)
   end
-  return waitKey, 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).
+  Function to get max events value or set by default 10000.
 ]]
-local function isQueuePaused(queueMetaKey)
-  return rcall("HEXISTS", queueMetaKey, "paused") == 1
+local function getOrSetMaxEvents(metaKey)
+  local maxEvents = rcall("HGET", metaKey, "opts.maxLenEvents")
+  if not maxEvents then
+    maxEvents = 10000
+    rcall("HSET", metaKey, "opts.maxLenEvents", maxEvents)
+  end
+  return maxEvents
 end
 --[[
   Function to remove job.
@@ -212,6 +257,26 @@ end
 local getJobKeyPrefix = function (jobKey, jobId)
   return string.sub(jobKey, 0, #jobKey - #jobId)
 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, 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 moveParentToWait(parentPrefix, parentId, emitEvent)
   local parentTarget, isPausedOrMaxed = getTargetQueueList(parentPrefix .. "meta", parentPrefix .. "active",
     parentPrefix .. "wait", parentPrefix .. "paused")
@@ -292,36 +357,6 @@ local function removeJob(jobId, hard, baseKey, shouldRemoveDeduplicationKey)
   end
   removeJobKeys(jobKey)
 end
---[[
-  Function to store a job
-]]
-local function storeJob(eventsKey, jobIdKey, jobId, name, data, opts, timestamp,
-                        parentKey, parentData, repeatJobKey)
-    local jsonOpts = cjson.encode(opts)
-    local delay = opts['delay'] or 0
-    local priority = opts['priority'] or 0
-    local debounceId = opts['de'] and opts['de']['id']
-    local optionalValues = {}
-    if parentKey ~= nil then
-        table.insert(optionalValues, "parentKey")
-        table.insert(optionalValues, parentKey)
-        table.insert(optionalValues, "parent")
-        table.insert(optionalValues, parentData)
-    end
-    if repeatJobKey ~= nil then
-        table.insert(optionalValues, "rjk")
-        table.insert(optionalValues, repeatJobKey)
-    end
-    if debounceId then
-        table.insert(optionalValues, "deid")
-        table.insert(optionalValues, debounceId)
-    end
-    rcall("HMSET", jobIdKey, "name", name, "data", data, "opts", jsonOpts,
-          "timestamp", timestamp, "delay", delay, "priority", priority,
-          unpack(optionalValues))
-    rcall("XADD", eventsKey, "*", "event", "added", "jobId", jobId, "name", name)
-    return delay, priority
-end
 --[[
   Function to store a job scheduler
 ]]
@@ -376,12 +411,12 @@ if prevMillis ~= false then
             removeJob(currentJobId, true, prefixKey, true --[[remove debounce key]] )
             rcall("ZREM", prioritizedKey, currentJobId)
         else
-            if isQueuePaused(KEYS[5]) then
-                if rcall("LREM", KEYS[4], 1, currentJobId) > 0 then
+            if isQueuePaused(metaKey) then
+                if rcall("LREM", pausedKey, 1, currentJobId) > 0 then
                     removeJob(currentJobId, true, prefixKey, true --[[remove debounce key]] )
                 end
             else
-                if rcall("LREM", KEYS[3], 1, currentJobId) > 0 then
+                if rcall("LREM", waitKey, 1, currentJobId) > 0 then
                     removeJob(currentJobId, true, prefixKey, true --[[remove debounce key]] )
                 end
             end
@@ -392,35 +427,10 @@ local schedulerOpts = cmsgpack.unpack(ARGV[2])
 storeJobScheduler(jobSchedulerId, schedulerKey, repeatKey, nextMillis, schedulerOpts, ARGV[4], templateOpts)
 if rcall("EXISTS", nextDelayedJobKey) ~= 1 then
     local eventsKey = KEYS[9]
-    local metaKey = KEYS[5]
     local maxEvents = getOrSetMaxEvents(metaKey)
     rcall("INCR", KEYS[8])
-    local delayedOpts = cmsgpack.unpack(ARGV[6])
-    local delay, priority = storeJob(eventsKey, nextDelayedJobKey, nextDelayedJobId, schedulerOpts['name'], ARGV[4],
-        delayedOpts, ARGV[7], nil, nil, jobSchedulerId)
-    if delay ~= 0 then
-        addDelayedJob(nextDelayedJobId, delayedKey, eventsKey,
-            ARGV[7], maxEvents, KEYS[7], delay)
-    else
-        local isPaused = isQueuePaused(KEYS[5])
-        -- Standard or priority add
-        if priority == 0 then
-            if isPaused then
-                -- LIFO or FIFO
-                local pushCmd = delayedOpts['lifo'] and 'RPUSH' or 'LPUSH'
-                rcall(pushCmd, KEYS[4], nextDelayedJobId)
-            else
-                -- LIFO or FIFO
-                local pushCmd = delayedOpts['lifo'] and 'RPUSH' or 'LPUSH'
-                rcall(pushCmd, KEYS[3], nextDelayedJobId)
-            end
-        else
-            -- Priority add
-            addJobWithPriority(KEYS[7], KEYS[6], priority, nextDelayedJobId, KEYS[10], isPaused)
-        end
-        -- Emit waiting event
-        rcall("XADD", eventsKey, "MAXLEN", "~", maxEvents,  "*", "event", "waiting", "jobId", nextDelayedJobId)
-    end
+    addJobFromScheduler(nextDelayedJobKey, nextDelayedJobId, ARGV[6], waitKey, pausedKey, metaKey, prioritizedKey,
+      KEYS[10], delayedKey, KEYS[7], eventsKey, schedulerOpts['name'], maxEvents, ARGV[7], ARGV[4], jobSchedulerId)
     if ARGV[9] ~= "" then
         rcall("HSET", ARGV[9], "nrjid", nextDelayedJobId)
     end

package/dist/cjs/scripts/addJobScheduler-10.js.map

@@ -1 +1 @@
-{"version":3,"file":"addJobScheduler-10.js","sourceRoot":"","sources":["../../../src/scripts/addJobScheduler-10.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyaf,CAAC;AACW,QAAA,eAAe,GAAG;IAC7B,IAAI,EAAE,iBAAiB;IACvB,OAAO;IACP,IAAI,EAAE,EAAE;CACT,CAAC"}
+{"version":3,"file":"addJobScheduler-10.js","sourceRoot":"","sources":["../../../src/scripts/addJobScheduler-10.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmbf,CAAC;AACW,QAAA,eAAe,GAAG;IAC7B,IAAI,EAAE,iBAAiB;IACvB,OAAO;IACP,IAAI,EAAE,EAAE;CACT,CAAC"}

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

@@ -240,7 +240,7 @@ local function updateExistingJobsParent(parentKey, parent, parentData,
                                         parentDependenciesKey, completedKey,
                                         jobIdKey, jobId, timestamp)
     if parentKey ~= nil then
-        if rcall("ZSCORE", completedKey, jobId) ~= false then
+        if rcall("ZSCORE", completedKey, jobId) then
             local returnvalue = rcall("HGET", jobIdKey, "returnvalue")
             updateParentDepsIfNeeded(parentKey, parent['queueKey'],
                                      parentDependenciesKey, parent['id'],

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

@@ -277,7 +277,7 @@ local function updateExistingJobsParent(parentKey, parent, parentData,
                                         parentDependenciesKey, completedKey,
                                         jobIdKey, jobId, timestamp)
     if parentKey ~= nil then
-        if rcall("ZSCORE", completedKey, jobId) ~= false then
+        if rcall("ZSCORE", completedKey, jobId) then
             local returnvalue = rcall("HGET", jobIdKey, "returnvalue")
             updateParentDepsIfNeeded(parentKey, parent['queueKey'],
                                      parentDependenciesKey, parent['id'],

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

@@ -207,10 +207,10 @@ end
 -- If we are overriding a repeatable job we must delete the delayed job for
 -- the next iteration.
 local prevMillis = rcall("ZSCORE", repeatKey, customKey)
-if prevMillis ~= false then
+if prevMillis then
   local delayedJobId =  "repeat:" .. customKey .. ":" .. prevMillis
   local nextDelayedJobId =  repeatKey .. ":" .. customKey .. ":" .. nextMillis
-  if rcall("ZSCORE", delayedKey, delayedJobId) ~= false
+  if rcall("ZSCORE", delayedKey, delayedJobId)
    and rcall("EXISTS", nextDelayedJobId) ~= 1 then
     removeJob(delayedJobId, true, prefixKey, true --[[remove debounce key]])
     rcall("ZREM", delayedKey, delayedJobId)

package/dist/cjs/scripts/addStandardJob-8.js

@@ -250,7 +250,7 @@ local function updateExistingJobsParent(parentKey, parent, parentData,
                                         parentDependenciesKey, completedKey,
                                         jobIdKey, jobId, timestamp)
     if parentKey ~= nil then
-        if rcall("ZSCORE", completedKey, jobId) ~= false then
+        if rcall("ZSCORE", completedKey, jobId) then
             local returnvalue = rcall("HGET", jobIdKey, "returnvalue")
             updateParentDepsIfNeeded(parentKey, parent['queueKey'],
                                      parentDependenciesKey, parent['id'],

package/dist/cjs/scripts/cleanJobsInSet-3.js

@@ -56,7 +56,7 @@ local function isJobSchedulerJob(jobId, jobKey, jobSchedulersKey)
   local repeatJobKey = rcall("HGET", jobKey, "rjk")
   if repeatJobKey  then
     local prevMillis = rcall("ZSCORE", jobSchedulersKey, repeatJobKey)
-    if prevMillis ~= false then
+    if prevMillis then
       local currentDelayedJobId = "repeat:" .. repeatJobKey .. ":" .. prevMillis
       return jobId == currentDelayedJobId
     end

package/dist/cjs/scripts/getState-8.js

@@ -24,16 +24,16 @@ const content = `--[[
     'unknown'
 ]]
 local rcall = redis.call
-if rcall("ZSCORE", KEYS[1], ARGV[1]) ~= false then
+if rcall("ZSCORE", KEYS[1], ARGV[1]) then
   return "completed"
 end
-if rcall("ZSCORE", KEYS[2], ARGV[1]) ~= false then
+if rcall("ZSCORE", KEYS[2], ARGV[1]) then
   return "failed"
 end
-if rcall("ZSCORE", KEYS[3], ARGV[1]) ~= false then
+if rcall("ZSCORE", KEYS[3], ARGV[1]) then
   return "delayed"
 end
-if rcall("ZSCORE", KEYS[8], ARGV[1]) ~= false then
+if rcall("ZSCORE", KEYS[8], ARGV[1]) then
   return "prioritized"
 end
 -- Includes
@@ -60,7 +60,7 @@ local paused_items = rcall("LRANGE", KEYS[6] , 0, -1)
 if checkItemInList(paused_items, ARGV[1]) ~= nil then
   return "waiting"
 end
-if rcall("ZSCORE", KEYS[7], ARGV[1]) ~= false then
+if rcall("ZSCORE", KEYS[7], ARGV[1]) then
   return "waiting-children"
 end
 return "unknown"

package/dist/cjs/scripts/getStateV2-8.js

@@ -23,28 +23,28 @@ const content = `--[[
     'unknown'
 ]]
 local rcall = redis.call
-if rcall("ZSCORE", KEYS[1], ARGV[1]) ~= false then
+if rcall("ZSCORE", KEYS[1], ARGV[1]) then
   return "completed"
 end
-if rcall("ZSCORE", KEYS[2], ARGV[1]) ~= false then
+if rcall("ZSCORE", KEYS[2], ARGV[1]) then
   return "failed"
 end
-if rcall("ZSCORE", KEYS[3], ARGV[1]) ~= false then
+if rcall("ZSCORE", KEYS[3], ARGV[1]) then
   return "delayed"
 end
-if rcall("ZSCORE", KEYS[8], ARGV[1]) ~= false then
+if rcall("ZSCORE", KEYS[8], ARGV[1]) then
   return "prioritized"
 end
-if rcall("LPOS", KEYS[4] , ARGV[1]) ~= false then
+if rcall("LPOS", KEYS[4] , ARGV[1]) then
   return "active"
 end
-if rcall("LPOS", KEYS[5] , ARGV[1]) ~= false then
+if rcall("LPOS", KEYS[5] , ARGV[1]) then
   return "waiting"
 end
-if rcall("LPOS", KEYS[6] , ARGV[1]) ~= false then
+if rcall("LPOS", KEYS[6] , ARGV[1]) then
   return "waiting"
 end
-if rcall("ZSCORE", KEYS[7] , ARGV[1]) ~= false then
+if rcall("ZSCORE", KEYS[7] , ARGV[1]) then
   return "waiting-children"
 end
 return "unknown"

package/dist/cjs/scripts/index.js

@@ -44,7 +44,7 @@ tslib_1.__exportStar(require("./reprocessJob-8"), exports);
 tslib_1.__exportStar(require("./retryJob-11"), exports);
 tslib_1.__exportStar(require("./saveStacktrace-1"), exports);
 tslib_1.__exportStar(require("./updateData-1"), exports);
-tslib_1.__exportStar(require("./updateJobScheduler-7"), exports);
+tslib_1.__exportStar(require("./updateJobScheduler-11"), exports);
 tslib_1.__exportStar(require("./updateProgress-3"), exports);
 tslib_1.__exportStar(require("./updateRepeatableJobMillis-1"), exports);
 //# sourceMappingURL=index.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/scripts/index.ts"],"names":[],"mappings":";;;AAAA,4DAAkC;AAClC,+DAAqC;AACrC,qDAA2B;AAC3B,2DAAiC;AACjC,gEAAsC;AACtC,+DAAqC;AACrC,6DAAmC;AACnC,0DAAgC;AAChC,6DAAmC;AACnC,6DAAmC;AACnC,oDAA0B;AAC1B,yDAA+B;AAC/B,0DAAgC;AAChC,wDAA8B;AAC9B,mEAAyC;AACzC,8DAAoC;AACpC,wDAA8B;AAC9B,8DAAoC;AACpC,uDAA6B;AAC7B,yDAA+B;AAC/B,yDAA+B;AAC/B,0DAAgC;AAChC,sDAA4B;AAC5B,sEAA4C;AAC5C,6DAAmC;AACnC,oEAA0C;AAC1C,4DAAkC;AAClC,4DAAkC;AAClC,8DAAoC;AACpC,oEAA0C;AAC1C,yDAA+B;AAC/B,uDAA6B;AAC7B,oDAA0B;AAC1B,sDAA4B;AAC5B,0DAAgC;AAChC,oEAA0C;AAC1C,wDAA8B;AAC9B,iEAAuC;AACvC,+DAAqC;AACrC,2DAAiC;AACjC,wDAA8B;AAC9B,6DAAmC;AACnC,yDAA+B;AAC/B,iEAAuC;AACvC,6DAAmC;AACnC,wEAA8C"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/scripts/index.ts"],"names":[],"mappings":";;;AAAA,4DAAkC;AAClC,+DAAqC;AACrC,qDAA2B;AAC3B,2DAAiC;AACjC,gEAAsC;AACtC,+DAAqC;AACrC,6DAAmC;AACnC,0DAAgC;AAChC,6DAAmC;AACnC,6DAAmC;AACnC,oDAA0B;AAC1B,yDAA+B;AAC/B,0DAAgC;AAChC,wDAA8B;AAC9B,mEAAyC;AACzC,8DAAoC;AACpC,wDAA8B;AAC9B,8DAAoC;AACpC,uDAA6B;AAC7B,yDAA+B;AAC/B,yDAA+B;AAC/B,0DAAgC;AAChC,sDAA4B;AAC5B,sEAA4C;AAC5C,6DAAmC;AACnC,oEAA0C;AAC1C,4DAAkC;AAClC,4DAAkC;AAClC,8DAAoC;AACpC,oEAA0C;AAC1C,yDAA+B;AAC/B,uDAA6B;AAC7B,oDAA0B;AAC1B,sDAA4B;AAC5B,0DAAgC;AAChC,oEAA0C;AAC1C,wDAA8B;AAC9B,iEAAuC;AACvC,+DAAqC;AACrC,2DAAiC;AACjC,wDAA8B;AAC9B,6DAAmC;AACnC,yDAA+B;AAC/B,kEAAwC;AACxC,6DAAmC;AACnC,wEAA8C"}

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

@@ -22,14 +22,14 @@ if rcall("EXISTS", KEYS[3]) ~= 1 then
   end  
   return -1
 end
-if rcall("ZSCORE", KEYS[1], ARGV[1]) ~= false then
+if rcall("ZSCORE", KEYS[1], ARGV[1]) then
   if ARGV[2] == "1" then
     local returnValue = rcall("HGET", KEYS[3], "returnvalue")
     return {1,returnValue}
   end
   return 1
 end
-if rcall("ZSCORE", KEYS[2], ARGV[1]) ~= false then
+if rcall("ZSCORE", KEYS[2], ARGV[1]) then
   if ARGV[2] == "1" then
     local failedReason = rcall("HGET", KEYS[3], "failedReason")
     return {2,failedReason}

package/dist/cjs/scripts/moveStalledJobsToWait-9.js

@@ -457,7 +457,7 @@ local function getOrSetMaxEvents(metaKey)
 end
 local function trimEvents(metaKey, eventStreamKey)
   local maxEvents = getOrSetMaxEvents(metaKey)
-  if maxEvents ~= false then
+  if maxEvents then
     rcall("XTRIM", eventStreamKey, "MAXLEN", "~", maxEvents)
   else
     rcall("XTRIM", eventStreamKey, "MAXLEN", "~", 10000)

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

@@ -640,7 +640,7 @@ local function getOrSetMaxEvents(metaKey)
 end
 local function trimEvents(metaKey, eventStreamKey)
   local maxEvents = getOrSetMaxEvents(metaKey)
-  if maxEvents ~= false then
+  if maxEvents then
     rcall("XTRIM", eventStreamKey, "MAXLEN", "~", maxEvents)
   else
     rcall("XTRIM", eventStreamKey, "MAXLEN", "~", 10000)

package/dist/cjs/scripts/removeJob-3.js

@@ -44,7 +44,7 @@ local function isJobSchedulerJob(jobId, jobKey, jobSchedulersKey)
   local repeatJobKey = rcall("HGET", jobKey, "rjk")
   if repeatJobKey  then
     local prevMillis = rcall("ZSCORE", jobSchedulersKey, repeatJobKey)
-    if prevMillis ~= false then
+    if prevMillis then
       local currentDelayedJobId = "repeat:" .. repeatJobKey .. ":" .. prevMillis
       return jobId == currentDelayedJobId
     end