bullmq 4.0.0-beta.1 → 4.0.0

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

@@ -0,0 +1,67 @@
+const content = `--[[
+  Function to move job from active state to wait.
+  Input:
+    KEYS[1] active key
+    KEYS[2] wait key
+    KEYS[3] stalled key
+    KEYS[4] job lock key
+    KEYS[5] paused key
+    KEYS[6] meta key
+    KEYS[7] limiter key
+    KEYS[8] prioritized key
+    KEYS[9] event key
+    ARGV[1] job id
+    ARGV[2] lock token
+    ARGV[3] job id key
+]]
+local rcall = redis.call
+-- 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
+--[[
+  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 jobId = ARGV[1]
+local token = ARGV[2]
+local lockKey = KEYS[4]
+local lockToken = rcall("GET", lockKey)
+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, paused = getTargetQueueList(KEYS[6], KEYS[2], KEYS[5])
+    rcall("SREM", KEYS[3], jobId)
+    local priority = tonumber(rcall("HGET", ARGV[3], "priority")) or 0
+    if priority > 0 then
+      pushBackJobWithPriority(KEYS[8], priority, jobId)
+    else
+      rcall("RPUSH", target, jobId)
+    end
+    rcall("DEL", lockKey)
+    -- Emit waiting event
+    rcall("XADD", KEYS[9], "*", "event", "waiting", "jobId", jobId)
+  end
+end
+return pttl
+`;
+export const moveJobFromActiveToWait = {
+    name: 'moveJobFromActiveToWait',
+    content,
+    keys: 9,
+};
+//# sourceMappingURL=moveJobFromActiveToWait-9.js.map

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

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

package/dist/esm/scripts/moveStalledJobsToWait-8.d.ts

@@ -0,0 +1,5 @@
+export declare const moveStalledJobsToWait: {
+    name: string;
+    content: string;
+    keys: number;
+};

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

@@ -0,0 +1,286 @@
+const content = `--[[
+  Move stalled jobs to wait.
+    Input:
+      KEYS[1] 'stalled' (SET)
+      KEYS[2] 'wait',   (LIST)
+      KEYS[3] 'active', (LIST)
+      KEYS[4] 'failed', (ZSET)
+      KEYS[5] 'stalled-check', (KEY)
+      KEYS[6] 'meta', (KEY)
+      KEYS[7] 'paused', (LIST)
+      KEYS[8] 'event stream' (STREAM)
+      ARGV[1]  Max stalled job count
+      ARGV[2]  queue.toKey('')
+      ARGV[3]  timestamp
+      ARGV[4]  max check time
+    Events:
+      'stalled' with stalled job id.
+]] -- Includes
+--[[
+  Move stalled jobs to wait.
+    Input:
+      stalledKey 'stalled' (SET)
+      waitKey 'wait',   (LIST)
+      activeKey 'active', (LIST)
+      failedKey 'failed', (ZSET)
+      stalledCheckKey 'stalled-check', (KEY)
+      metaKey 'meta', (KEY)
+      pausedKey 'paused', (LIST)
+      eventStreamKey 'event stream' (STREAM)
+      maxStalledJobCount  Max stalled job count
+      queueKeyPrefix  queue.toKey('')
+      timestamp  timestamp
+      maxCheckTime  max check time
+    Events:
+      'stalled' with stalled job id.
+]]
+local rcall = redis.call
+-- Includes
+--[[
+  Function to loop in batches.
+  Just a bit of warning, some commands as ZREM
+  could receive a maximum of 7000 parameters per call.
+]]
+local function batches(n, batchSize)
+  local i = 0
+  return function()
+    local from = i * batchSize + 1
+    i = i + 1
+    if (from <= n) then
+      local to = math.min(from + batchSize - 1, n)
+      return from, to
+    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
+end
+--[[
+  Function to remove job.
+]]
+-- Includes
+--[[
+  Check if this job has a parent. If so we will just remove it from
+  the parent child list, but if it is the last child we should move the parent to "wait/paused"
+  which requires code from "moveToFinished"
+]]
+--[[
+  Functions to destructure job key.
+  Just a bit of warning, these functions may be a bit slow and affect performance significantly.
+]]
+local getJobIdFromKey = function (jobKey)
+  return string.match(jobKey, ".*:(.*)")
+end
+local getJobKeyPrefix = function (jobKey, jobId)
+  return string.sub(jobKey, 0, #jobKey - #jobId)
+end
+local function moveParentToWait(parentPrefix, parentId, emitEvent)
+  local parentTarget = getTargetQueueList(parentPrefix .. "meta", parentPrefix .. "wait", parentPrefix .. "paused")
+  rcall("RPUSH", parentTarget, parentId)
+  if emitEvent then
+    local parentEventStream = parentPrefix .. "events"
+    rcall("XADD", parentEventStream, "*", "event", "waiting", "jobId", parentId, "prev", "waiting-children")
+  end
+end
+local function removeParentDependencyKey(jobKey, hard, parentKey, baseKey)
+  if parentKey then
+    local parentDependenciesKey = parentKey .. ":dependencies"
+    local result = rcall("SREM", parentDependenciesKey, jobKey)
+    if result > 0 then
+      local pendingDependencies = rcall("SCARD", parentDependenciesKey)
+      if pendingDependencies == 0 then
+        local parentId = getJobIdFromKey(parentKey)
+        local parentPrefix = getJobKeyPrefix(parentKey, parentId)
+        local numRemovedElements = rcall("ZREM", parentPrefix .. "waiting-children", parentId)
+        if numRemovedElements == 1 then
+          if hard then
+            if parentPrefix == baseKey then
+              removeParentDependencyKey(parentKey, hard, nil, baseKey)
+              rcall("DEL", parentKey, parentKey .. ':logs',
+                parentKey .. ':dependencies', parentKey .. ':processed')
+            else
+              moveParentToWait(parentPrefix, parentId)
+            end
+          else
+            moveParentToWait(parentPrefix, parentId, true)
+          end
+        end
+      end
+    end
+  else
+    local missedParentKey = rcall("HGET", jobKey, "parentKey")
+    if( (type(missedParentKey) == "string") and missedParentKey ~= "" and (rcall("EXISTS", missedParentKey) == 1)) then
+      local parentDependenciesKey = missedParentKey .. ":dependencies"
+      local result = rcall("SREM", parentDependenciesKey, jobKey)
+      if result > 0 then
+        local pendingDependencies = rcall("SCARD", parentDependenciesKey)
+        if pendingDependencies == 0 then
+          local parentId = getJobIdFromKey(missedParentKey)
+          local parentPrefix = getJobKeyPrefix(missedParentKey, parentId)
+          local numRemovedElements = rcall("ZREM", parentPrefix .. "waiting-children", parentId)
+          if numRemovedElements == 1 then
+            if hard then
+              if parentPrefix == baseKey then
+                removeParentDependencyKey(missedParentKey, hard, nil, baseKey)
+                rcall("DEL", missedParentKey, missedParentKey .. ':logs',
+                  missedParentKey .. ':dependencies', missedParentKey .. ':processed')
+              else
+                moveParentToWait(parentPrefix, parentId)
+              end
+            else
+              moveParentToWait(parentPrefix, parentId, true)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+local function removeJob(jobId, hard, baseKey)
+  local jobKey = baseKey .. jobId
+  removeParentDependencyKey(jobKey, hard, nil, baseKey)
+  rcall("DEL", jobKey, jobKey .. ':logs',
+    jobKey .. ':dependencies', jobKey .. ':processed')
+end
+--[[
+  Functions to remove jobs by max age.
+]]
+-- Includes
+local function removeJobsByMaxAge(timestamp, maxAge, targetSet, prefix)
+  local start = timestamp - maxAge * 1000
+  local jobIds = rcall("ZREVRANGEBYSCORE", targetSet, start, "-inf")
+  for i, jobId in ipairs(jobIds) do
+    removeJob(jobId, false, prefix)
+  end
+  rcall("ZREMRANGEBYSCORE", targetSet, "-inf", start)
+end
+--[[
+  Functions to remove jobs by max count.
+]]
+-- Includes
+local function removeJobsByMaxCount(maxCount, targetSet, prefix)
+  local start = maxCount
+  local jobIds = rcall("ZREVRANGE", targetSet, start, -1)
+  for i, jobId in ipairs(jobIds) do
+    removeJob(jobId, false, prefix)
+  end
+  rcall("ZREMRANGEBYRANK", targetSet, 0, -(maxCount + 1))
+end
+--[[
+  Function to trim events, default 10000.
+]]
+local function trimEvents(metaKey, eventStreamKey)
+  local maxEvents = rcall("HGET", metaKey, "opts.maxLenEvents")
+  if maxEvents ~= false then
+    rcall("XTRIM", eventStreamKey, "MAXLEN", "~", maxEvents)
+  else
+    rcall("XTRIM", eventStreamKey, "MAXLEN", "~", 10000)
+  end
+end
+-- Check if we need to check for stalled jobs now.
+local function checkStalledJobs(stalledKey, waitKey, activeKey, failedKey,
+                                stalledCheckKey, metaKey, pausedKey,
+                                eventStreamKey, maxStalledJobCount,
+                                queueKeyPrefix, timestamp, maxCheckTime)
+    if rcall("EXISTS", stalledCheckKey) == 1 then return {{}, {}} end
+    rcall("SET", stalledCheckKey, timestamp, "PX", maxCheckTime)
+    -- Trim events before emiting them to avoid trimming events emitted in this script
+    trimEvents(metaKey, eventStreamKey)
+    -- Move all stalled jobs to wait
+    local stalling = rcall('SMEMBERS', stalledKey)
+    local stalled = {}
+    local failed = {}
+    if (#stalling > 0) then
+        rcall('DEL', stalledKey)
+        local MAX_STALLED_JOB_COUNT = tonumber(maxStalledJobCount)
+        -- Remove from active list
+        for i, jobId in ipairs(stalling) do
+            if string.sub(jobId, 1, 2) == "0:" then
+                -- If the jobId is a delay marker ID we just remove it.
+                rcall("LREM", activeKey, 1, jobId)
+            else
+                local jobKey = queueKeyPrefix .. jobId
+                -- Check that the lock is also missing, then we can handle this job as really stalled.
+                if (rcall("EXISTS", jobKey .. ":lock") == 0) then
+                    --  Remove from the active queue.
+                    local removed = rcall("LREM", activeKey, 1, jobId)
+                    if (removed > 0) then
+                        -- If this job has been stalled too many times, such as if it crashes the worker, then fail it.
+                        local stalledCount =
+                            rcall("HINCRBY", jobKey, "stalledCounter", 1)
+                        if (stalledCount > MAX_STALLED_JOB_COUNT) then
+                            local rawOpts = rcall("HGET", jobKey, "opts")
+                            local opts = cjson.decode(rawOpts)
+                            local removeOnFailType = type(opts["removeOnFail"])
+                            rcall("ZADD", failedKey, timestamp, jobId)
+                            local failedReason =
+                                "job stalled more than allowable limit"
+                            rcall("HMSET", jobKey, "failedReason", failedReason,
+                                  "finishedOn", timestamp)
+                            rcall("XADD", eventStreamKey, "*", "event",
+                                  "failed", "jobId", jobId, 'prev', 'active',
+                                  'failedReason', failedReason)
+                            if removeOnFailType == "number" then
+                                removeJobsByMaxCount(opts["removeOnFail"],
+                                                     failedKey, queueKeyPrefix)
+                            elseif removeOnFailType == "boolean" then
+                                if opts["removeOnFail"] then
+                                    removeJob(jobId, false, queueKeyPrefix)
+                                    rcall("ZREM", failedKey, jobId)
+                                end
+                            elseif removeOnFailType ~= "nil" then
+                                local maxAge = opts["removeOnFail"]["age"]
+                                local maxCount = opts["removeOnFail"]["count"]
+                                if maxAge ~= nil then
+                                    removeJobsByMaxAge(timestamp, maxAge,
+                                                       failedKey, queueKeyPrefix)
+                                end
+                                if maxCount ~= nil and maxCount > 0 then
+                                    removeJobsByMaxCount(maxCount, failedKey,
+                                                         queueKeyPrefix)
+                                end
+                            end
+                            table.insert(failed, jobId)
+                        else
+                            local target =
+                                getTargetQueueList(metaKey, waitKey, pausedKey)
+                            -- Move the job back to the wait queue, to immediately be picked up by a waiting worker.
+                            rcall("RPUSH", target, jobId)
+                            rcall("XADD", eventStreamKey, "*", "event",
+                                  "waiting", "jobId", jobId, 'prev', 'active')
+                            -- Emit the stalled event
+                            rcall("XADD", eventStreamKey, "*", "event",
+                                  "stalled", "jobId", jobId)
+                            table.insert(stalled, jobId)
+                        end
+                    end
+                end
+            end
+        end
+    end
+    -- Mark potentially stalled jobs
+    local active = rcall('LRANGE', activeKey, 0, -1)
+    if (#active > 0) then
+        for from, to in batches(#active, 7000) do
+            rcall('SADD', stalledKey, unpack(active, from, to))
+        end
+    end
+    return {failed, stalled}
+end
+return checkStalledJobs(KEYS[1], KEYS[2], KEYS[3], KEYS[4], KEYS[5], KEYS[6],
+                        KEYS[7], KEYS[8], ARGV[1], ARGV[2], ARGV[3], ARGV[4])
+`;
+export const moveStalledJobsToWait = {
+    name: 'moveStalledJobsToWait',
+    content,
+    keys: 8,
+};
+//# sourceMappingURL=moveStalledJobsToWait-8.js.map

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

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

package/dist/esm/scripts/moveToActive-10.d.ts

@@ -0,0 +1,5 @@
+export declare const moveToActive: {
+    name: string;
+    content: string;
+    keys: number;
+};

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

@@ -0,0 +1,266 @@
+const content = `--[[
+  Move next job to be processed to active, lock it and fetch its data. The job
+  may be delayed, in that case we need to move it to the delayed set instead.
+  This operation guarantees that the worker owns the job during the lock
+  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] prioritized 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
+    KEYS[10] pc priority counter
+    -- 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
+-- Includes
+--[[
+  Function to return the next delayed job timestamp.
+]] 
+local function getNextDelayedTimestamp(delayedKey)
+  local result = rcall("ZRANGE", delayedKey, 0, 0, "WITHSCORES")
+  if #result then
+    local nextTimestamp = tonumber(result[2])
+    if (nextTimestamp ~= nil) then 
+      nextTimestamp = nextTimestamp / 0x1000
+    end
+    return nextTimestamp
+  end
+end
+local function getRateLimitTTL(maxJobs, rateLimiterKey)
+  if maxJobs then
+    local pttl = rcall("PTTL", rateLimiterKey)
+    if pttl == 0 then
+      rcall("DEL", rateLimiterKey)
+    end
+    local jobCounter = tonumber(rcall("GET", rateLimiterKey) or 0)
+    if jobCounter >= maxJobs then
+      if pttl > 0 then
+        return pttl
+      end
+    end
+  end
+  return 0
+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.
+]]
+local function moveJobFromPriorityToActive(priorityKey, activeKey, priorityCounterKey)
+  local prioritizedJob = rcall("ZPOPMIN", priorityKey)
+  if #prioritizedJob > 0 then
+    rcall("LPUSH", activeKey, prioritizedJob[1])
+    return prioritizedJob[1]
+  else
+    rcall("DEL", priorityCounterKey)
+  end
+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 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 prioCounter = rcall("INCR", priorityCounterKey)
+  local score = priority * 0x100000000 + bit.band(prioCounter, 0xffffffffffff)
+  rcall("ZADD", prioritizedKey, score, jobId)
+  if not paused then
+    addPriorityMarkerIfNeeded(waitKey)
+  end
+end
+--[[
+  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, paused, 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']
+      local integerDuration = math.floor(math.abs(limiterDuration))
+      rcall("PEXPIRE", rateLimiterKey, integerDuration)
+    end
+  end
+  local lockKey = jobKey .. ':lock'
+  -- get a lock
+  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("HSET", jobKey, "processedOn", processedOn)
+  rcall("HINCRBY", jobKey, "attemptsMade", 1)
+  return {rcall("HGETALL", jobKey), jobId, 0, 0} -- get job data
+end
+--[[
+  Updates the delay set, by moving delayed jobs that should
+  be processed now to "wait".
+     Events:
+      'waiting'
+]]
+-- Includes
+-- Try to get as much as 1000 jobs at once
+local function promoteDelayedJobs(delayedKey, waitKey, targetKey, prioritizedKey,
+                                  eventStreamKey, prefix, timestamp, paused, priorityCounterKey)
+    local jobs = rcall("ZRANGEBYSCORE", delayedKey, 0, (timestamp + 1) * 0x1000, "LIMIT", 0, 1000)
+    if (#jobs > 0) then
+        rcall("ZREM", delayedKey, unpack(jobs))
+        for _, jobId in ipairs(jobs) do
+            local jobKey = prefix .. jobId
+            local priority =
+                tonumber(rcall("HGET", jobKey, "priority")) or 0
+            if priority == 0 then
+                -- LIFO or FIFO
+                rcall("LPUSH", targetKey, jobId)
+            else
+                addJobWithPriority(waitKey, prioritizedKey, priority, paused,
+                  jobId, priorityCounterKey)
+            end
+            -- Emit waiting event
+            rcall("XADD", eventStreamKey, "*", "event", "waiting", "jobId",
+                  jobId, "prev", "delayed")
+            rcall("HSET", jobKey, "delay", 0)
+        end
+    end
+end
+local target, paused = getTargetQueueList(KEYS[9], KEYS[1], KEYS[8])
+-- Check if there are delayed jobs that we can move to wait.
+promoteDelayedJobs(KEYS[7], KEYS[1], target, KEYS[3], KEYS[4], ARGV[1], ARGV[2], paused, KEYS[10])
+local opts = cmsgpack.unpack(ARGV[4])
+local maxJobs = tonumber(opts['limiter'] and opts['limiter']['max'])
+local expireTime = getRateLimitTTL(maxJobs, KEYS[6])
+if (ARGV[3] ~= "") then
+  jobId = ARGV[3]
+  -- clean stalled key
+  rcall("SREM", KEYS[5], jobId)
+else
+  -- Check if we are rate limited first.
+  if expireTime > 0 then
+    return { 0, 0, expireTime, 0 }
+  end
+  -- paused queue
+  if paused then return {0, 0, 0, 0} 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)
+    if expireTime > 0 then
+      return { 0, 0, expireTime, 0 }
+    end
+    -- paused queue
+    if paused then return {0, 0, 0, 0} end
+    -- Move again since we just got the marker job.
+    jobId = rcall("RPOPLPUSH", KEYS[1], KEYS[2])
+    -- Since it is possible that between a call to BRPOPLPUSH and moveToActive
+    -- 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
+    -- this script is not really moving, it is preparing the job for processing
+    return prepareJobForProcessing(KEYS, ARGV[1], target, jobId, ARGV[2], maxJobs, expireTime, paused, opts)
+  else
+    jobId = moveJobFromPriorityToActive(KEYS[3], KEYS[2], KEYS[10])
+    if jobId then
+      return prepareJobForProcessing(KEYS, ARGV[1], target, jobId, ARGV[2], maxJobs, expireTime, paused, opts)
+    end
+  end
+else
+  jobId = moveJobFromPriorityToActive(KEYS[3], KEYS[2], KEYS[10])
+  if jobId then
+    return prepareJobForProcessing(KEYS, ARGV[1], target, jobId, ARGV[2], maxJobs, expireTime, paused, opts)
+  end
+end
+-- Return the timestamp for the next delayed job if any.
+local nextTimestamp = getNextDelayedTimestamp(KEYS[7])
+if (nextTimestamp ~= nil) then
+  return { 0, 0, 0, nextTimestamp }
+end
+return { 0, 0, 0, 0}
+`;
+export const moveToActive = {
+    name: 'moveToActive',
+    content,
+    keys: 10,
+};
+//# sourceMappingURL=moveToActive-10.js.map

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

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

package/dist/esm/scripts/moveToDelayed-8.d.ts

@@ -0,0 +1,5 @@
+export declare const moveToDelayed: {
+    name: string;
+    content: string;
+    keys: number;
+};