bullmq 4.16.0 → 5.0.0

package/dist/esm/scripts/changePriority-5.js

@@ -1,84 +0,0 @@
-const content = `--[[
-  Change job priority
-  Input:
-    KEYS[1] 'wait',
-    KEYS[2] 'paused'
-    KEYS[3] 'meta'
-    KEYS[4] 'prioritized'
-    KEYS[5] 'pc' priority counter
-    ARGV[1] priority value
-    ARGV[2] job key
-    ARGV[3] job id
-    ARGV[4] lifo
-    Output:
-       0  - OK
-      -1  - Missing job
-]]
-local jobKey = ARGV[2]
-local jobId = ARGV[3]
-local priority = tonumber(ARGV[1])
-local rcall = redis.call
--- 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 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
-if rcall("EXISTS", jobKey) == 1 then
-  local target, paused = getTargetQueueList(KEYS[3], KEYS[1], KEYS[2])
-  if rcall("ZREM", KEYS[4], jobId) > 0 then
-    addJobWithPriority(KEYS[1], KEYS[4], priority, paused, jobId, KEYS[5])
-  else
-    local numRemovedElements = rcall("LREM", target, -1, jobId)
-    if numRemovedElements > 0 then
-      -- Standard or priority add
-      if priority == 0 then
-        -- LIFO or FIFO
-        local pushCmd = ARGV[4] == '1' and 'RPUSH' or 'LPUSH';
-        rcall(pushCmd, target, jobId)
-      else
-        addJobWithPriority(KEYS[1], KEYS[4], priority, paused, jobId, KEYS[5])
-      end
-    end
-  end
-  rcall("HSET", jobKey, "priority", priority)
-  return 0
-else
-  return -1
-end
-`;
-export const changePriority = {
-    name: 'changePriority',
-    content,
-    keys: 5,
-};
-//# sourceMappingURL=changePriority-5.js.map

package/dist/esm/scripts/changePriority-5.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"changePriority-5.js","sourceRoot":"","sources":["../../../src/scripts/changePriority-5.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6Ef,CAAC;AACF,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,IAAI,EAAE,gBAAgB;IACtB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

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

@@ -1,165 +0,0 @@
-const content = `--[[
-  Moves job from active to delayed set.
-  Input:
-    KEYS[1] wait key
-    KEYS[2] active key
-    KEYS[3] prioritized key
-    KEYS[4] delayed key
-    KEYS[5] job key
-    KEYS[6] events stream
-    KEYS[7] paused key
-    KEYS[8] meta key
-    ARGV[1] key prefix
-    ARGV[2] timestamp
-    ARGV[3] delayedTimestamp
-    ARGV[4] the id of the job
-    ARGV[5] queue token
-    ARGV[6] delay value
-  Output:
-    0 - OK
-   -1 - Missing job.
-   -3 - Job not in active set.
-  Events:
-    - delayed key.
-]]
-local rcall = redis.call
--- Includes
---[[
-  Add delay marker if needed.
-]]
--- 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 addDelayMarkerIfNeeded(targetKey, delayedKey)
-  local waitLen = rcall("LLEN", targetKey)
-  if waitLen <= 1 then
-    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
-    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
---[[
-  Updates the delay set, by moving delayed jobs that should
-  be processed now to "wait".
-     Events:
-      'waiting'
-]]
--- 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
--- 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 jobKey = KEYS[5]
-if rcall("EXISTS", jobKey) == 1 then
-  local delayedKey = KEYS[4]
-  if ARGV[5] ~= "0" then
-    local lockKey = jobKey .. ':lock'
-    if rcall("GET", lockKey) == ARGV[5] then
-      rcall("DEL", lockKey)
-    else
-      return -2
-    end
-  end
-  local jobId = ARGV[4]
-  local score = tonumber(ARGV[3])
-  local delayedTimestamp = (score / 0x1000)
-  local numRemovedElements = rcall("LREM", KEYS[2], -1, jobId)
-  if numRemovedElements < 1 then
-    return -3
-  end
-  rcall("HSET", jobKey, "delay", ARGV[6])
-  local maxEvents = rcall("HGET", KEYS[8], "opts.maxLenEvents") or 10000
-  rcall("ZADD", delayedKey, score, jobId)
-  rcall("XADD", KEYS[6], "MAXLEN", "~", maxEvents, "*", "event", "delayed",
-    "jobId", jobId, "delay", delayedTimestamp)
-  -- Check if we need to push a marker job to wake up sleeping workers.
-  local target = getTargetQueueList(KEYS[8], KEYS[1], KEYS[7])
-  addDelayMarkerIfNeeded(target, delayedKey)
-  return 0
-else
-  return -1
-end
-`;
-export const moveToDelayed = {
-    name: 'moveToDelayed',
-    content,
-    keys: 8,
-};
-//# sourceMappingURL=moveToDelayed-8.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"moveToDelayed-8.js","sourceRoot":"","sources":["../../../src/scripts/moveToDelayed-8.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8Jf,CAAC;AACF,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,IAAI,EAAE,eAAe;IACrB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

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

@@ -1,45 +0,0 @@
-const content = `--[[
-  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
-    ARGV[1] 'paused' or 'resumed'
-  Event:
-    publish paused or resumed event.
-]]
-local rcall = redis.call
--- 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
-if rcall("EXISTS", KEYS[1]) == 1 then
-  rcall("RENAME", KEYS[1], KEYS[2])
-end
-if ARGV[1] == "paused" then
-  rcall("HSET", KEYS[3], "paused", 1)
-else
-  rcall("HDEL", KEYS[3], "paused")
-  local priorityCount = rcall("ZCARD", KEYS[4])
-  if priorityCount > 0 then
-    addPriorityMarkerIfNeeded(KEYS[2])
-  end
-end
-rcall("XADD", KEYS[5], "*", "event", ARGV[1]);
-`;
-export const pause = {
-    name: 'pause',
-    content,
-    keys: 5,
-};
-//# sourceMappingURL=pause-5.js.map

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

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

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

@@ -1,84 +0,0 @@
-const content = `--[[
-  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'
-      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
---[[
-  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 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
-if rcall("ZREM", KEYS[1], jobId) == 1 then
-  local jobKey = ARGV[1] .. jobId
-  local priority = tonumber(rcall("HGET", jobKey, "priority")) or 0
-  local target, paused = getTargetQueueList(KEYS[4], KEYS[2], KEYS[3])
-  -- Remove delayed "marker" from the wait list if there is any.
-  -- Since we are adding a job we do not need the marker anymore.
-  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)
-  else
-    addJobWithPriority(KEYS[2], KEYS[5], priority, paused, jobId, KEYS[6])
-  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`;
-export const promote = {
-    name: 'promote',
-    content,
-    keys: 7,
-};
-//# sourceMappingURL=promote-7.js.map

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

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

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

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