bullmq 3.0.0 → 3.1.0

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

@@ -0,0 +1,113 @@
+const content = `--[[
+  Moves job from active to delayed set.
+  Input:
+    KEYS[1] wait key
+    KEYS[2] active key
+    KEYS[3] priority 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
+  Output:
+    0 - OK
+   -1 - Missing job.
+   -3 - Job not in active set.
+  Events:
+    - delayed key.
+]]
+local rcall = redis.call
+-- Includes
+--[[
+  Updates the delay set, by moving delayed jobs that should
+  be processed now to "wait".
+     Events:
+      'waiting'
+]]
+local rcall = redis.call
+-- Includes
+--[[
+  Function to add job considering priority.
+]]
+local function addJobWithPriority(priorityKey, priority, targetKey, jobId)
+  rcall("ZADD", priorityKey, priority, jobId)
+  local count = rcall("ZCOUNT", priorityKey, 0, priority)
+  local len = rcall("LLEN", targetKey)
+  local id = rcall("LINDEX", targetKey, len - (count - 1))
+  if id then
+    rcall("LINSERT", targetKey, "BEFORE", id, jobId)
+  else
+    rcall("RPUSH", targetKey, jobId)
+  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
+  else
+    return pausedKey
+  end
+end
+-- Try to get as much as 1000 jobs at once, and returns the nextTimestamp if
+-- there are more delayed jobs to process.
+local function promoteDelayedJobs(delayedKey, waitKey, priorityKey, pausedKey,
+                                  metaKey, eventStreamKey, prefix, timestamp)
+    local jobs = rcall("ZRANGEBYSCORE", delayedKey, 0, (timestamp + 1) * 0x1000, "LIMIT", 0, 1000)
+    if (#jobs > 0) then
+        rcall("ZREM", delayedKey, unpack(jobs))
+        -- check if we need to use push in paused instead of waiting
+        local target = getTargetQueueList(metaKey, waitKey, pausedKey)
+        for _, jobId in ipairs(jobs) do
+            local priority =
+                tonumber(rcall("HGET", prefix .. jobId, "priority")) or 0
+            if priority == 0 then
+                -- LIFO or FIFO
+                rcall("LPUSH", target, jobId)
+            else
+                addJobWithPriority(priorityKey, priority, target, jobId)
+            end
+            -- Emit waiting event
+            rcall("XADD", eventStreamKey, "*", "event", "waiting", "jobId",
+                  jobId, "prev", "delayed")
+            rcall("HSET", prefix .. jobId, "delay", 0)
+        end
+    end
+end
+promoteDelayedJobs(KEYS[4], KEYS[1], KEYS[3], KEYS[7], KEYS[8], KEYS[6], ARGV[1], ARGV[2])
+if rcall("EXISTS", KEYS[5]) == 1 then
+  if ARGV[5] ~= "0" then
+    local lockKey = KEYS[5] .. ':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("ZADD", KEYS[4], score, jobId)
+  rcall("XADD", KEYS[6], "*", "event", "delayed", "jobId", jobId, "delay", delayedTimestamp);
+  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

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

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

@@ -41,6 +41,7 @@ const content = `--[[
       -2 Missing lock.
       -3 Job not in active set
       -4 Job has pending dependencies
+      -6 Lock is not owned by this client
     Events:
       'completed/failed'
 ]]
@@ -424,11 +425,19 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
     local maxAge = opts['keepJobs']['age']
     if token ~= "0" then
         local lockKey = jobIdKey .. ':lock'
-        if rcall("GET", lockKey) == token then
+        local lockToken = rcall("GET", lockKey)
+        if lockToken == token then
             rcall("DEL", lockKey)
             rcall("SREM", KEYS[5], ARGV[1])
         else
-            return -2
+            if lockToken then
+                rcall("SET", "DEBUG", lockToken)
+                -- Lock exists but token does not match
+                return -6
+            else 
+                -- Lock is missing completely
+                return -2
+            end
         end
     end
     if rcall("SCARD", jobIdKey .. ":dependencies") ~= 0 then -- // Make sure it does not have pending dependencies
@@ -454,11 +463,13 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
         if ARGV[5] == "completed" then
             local dependenciesSet = parentKey .. ":dependencies"
             if rcall("SREM", dependenciesSet, jobIdKey) == 1 then
-                updateParentDepsIfNeeded(parentKey, parentQueueKey, dependenciesSet,
-                                        parentId, jobIdKey, ARGV[4])
+                updateParentDepsIfNeeded(parentKey, parentQueueKey,
+                                         dependenciesSet, parentId, jobIdKey,
+                                         ARGV[4])
             end
         elseif opts['fpof'] then
-            moveParentFromWaitingChildrenToFailed(parentQueueKey, parentKey, parentId, jobIdKey, timestamp)
+            moveParentFromWaitingChildrenToFailed(parentQueueKey, parentKey,
+                                                  parentId, jobIdKey, timestamp)
         end
     end
     -- Remove job?
@@ -489,23 +500,23 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
     end
     -- Collect metrics
     if maxMetricsSize ~= "" then
-        collectMetrics(KEYS[12], KEYS[12]..':data', maxMetricsSize, timestamp)
+        collectMetrics(KEYS[12], KEYS[12] .. ':data', maxMetricsSize, timestamp)
     end
     -- 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
         -- Check if there are delayed jobs that can be promoted
-        promoteDelayedJobs(KEYS[7], KEYS[1], KEYS[3], KEYS[8], KEYS[11], KEYS[4], ARGV[8], timestamp)
+        promoteDelayedJobs(KEYS[7], KEYS[1], KEYS[3], KEYS[8], KEYS[11],
+                           KEYS[4], ARGV[8], timestamp)
         -- Check if we are rate limited first.
         local pttl = getRateLimitTTL(opts, KEYS[6])
-        if pttl > 0 then
-            return { 0, 0, pttl }
-        end
+        if pttl > 0 then return {0, 0, pttl} end
         jobId = rcall("RPOPLPUSH", KEYS[1], KEYS[2])
         if jobId == "0" then
             rcall("LREM", KEYS[2], 1, 0)
         elseif jobId then
-            return moveJobFromWaitToActive(KEYS, ARGV[8], jobId, timestamp, opts)
+            return
+                moveJobFromWaitToActive(KEYS, ARGV[8], jobId, timestamp, opts)
         end
         -- Return the timestamp for the next delayed job if any.
         local nextTimestamp = getNextDelayedTimestamp(KEYS[7])
@@ -521,7 +532,7 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
         if activeLen == 0 then
             rcall("XADD", KEYS[4], "*", "event", "drained")
         end
-    end  
+    end
     return 0
 else
     return -1

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

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

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

@@ -0,0 +1,109 @@
+const content = `--[[
+  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] priority key
+      ARGV[1]  key prefix
+      ARGV[2]  timestamp
+      ARGV[3]  pushCmd
+      ARGV[4]  jobId
+      ARGV[5]  token
+    Events:
+      'waiting'
+    Output:
+     0  - OK
+     -1 - Missing key
+     -2 - Missing lock
+]]
+local rcall = redis.call
+-- Includes
+--[[
+  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
+  else
+    return pausedKey
+  end
+end
+--[[
+  Updates the delay set, by moving delayed jobs that should
+  be processed now to "wait".
+     Events:
+      'waiting'
+]]
+local rcall = redis.call
+-- Includes
+--[[
+  Function to add job considering priority.
+]]
+local function addJobWithPriority(priorityKey, priority, targetKey, jobId)
+  rcall("ZADD", priorityKey, priority, jobId)
+  local count = rcall("ZCOUNT", priorityKey, 0, priority)
+  local len = rcall("LLEN", targetKey)
+  local id = rcall("LINDEX", targetKey, len - (count - 1))
+  if id then
+    rcall("LINSERT", targetKey, "BEFORE", id, jobId)
+  else
+    rcall("RPUSH", targetKey, jobId)
+  end
+end
+-- Try to get as much as 1000 jobs at once, and returns the nextTimestamp if
+-- there are more delayed jobs to process.
+local function promoteDelayedJobs(delayedKey, waitKey, priorityKey, pausedKey,
+                                  metaKey, eventStreamKey, prefix, timestamp)
+    local jobs = rcall("ZRANGEBYSCORE", delayedKey, 0, (timestamp + 1) * 0x1000, "LIMIT", 0, 1000)
+    if (#jobs > 0) then
+        rcall("ZREM", delayedKey, unpack(jobs))
+        -- check if we need to use push in paused instead of waiting
+        local target = getTargetQueueList(metaKey, waitKey, pausedKey)
+        for _, jobId in ipairs(jobs) do
+            local priority =
+                tonumber(rcall("HGET", prefix .. jobId, "priority")) or 0
+            if priority == 0 then
+                -- LIFO or FIFO
+                rcall("LPUSH", target, jobId)
+            else
+                addJobWithPriority(priorityKey, priority, target, jobId)
+            end
+            -- Emit waiting event
+            rcall("XADD", eventStreamKey, "*", "event", "waiting", "jobId",
+                  jobId, "prev", "delayed")
+            rcall("HSET", prefix .. jobId, "delay", 0)
+        end
+    end
+end
+promoteDelayedJobs(KEYS[7], KEYS[2], KEYS[8], KEYS[3], KEYS[5], KEYS[6], ARGV[1], ARGV[2])
+if rcall("EXISTS", KEYS[4]) == 1 then
+  if ARGV[5] ~= "0" then
+    local lockKey = KEYS[4] .. ':lock'
+    if rcall("GET", lockKey) == ARGV[5] then
+      rcall("DEL", lockKey)
+    else
+      return -2
+    end
+  end
+  local target = getTargetQueueList(KEYS[5], KEYS[2], KEYS[3])
+  rcall("LREM", KEYS[1], 0, ARGV[4])
+  rcall(ARGV[3], target, ARGV[4])
+  -- Emit waiting event
+  rcall("XADD", KEYS[6], "*", "event", "waiting", "jobId", ARGV[4], "prev", "failed");
+  return 0
+else
+  return -1
+end
+`;
+export const retryJob = {
+    name: 'retryJob',
+    content,
+    keys: 8,
+};
+//# sourceMappingURL=retryJob-8.js.map

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bullmq",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "description": "Queue for messages and jobs based on Redis",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",

package/dist/cjs/commands/moveToDelayed-5.lua

@@ -1,54 +0,0 @@
---[[
-  Moves job from active to delayed set.
-
-  Input: 
-    KEYS[1] active key
-    KEYS[2] delayed key
-    KEYS[3] job key
-    KEYS[4] events stream
-    KEYS[5] delayed stream
-
-    ARGV[1] delayedTimestamp
-    ARGV[2] the id of the job
-    ARGV[3] queue token
-
-  Output:
-    0 - OK
-   -1 - Missing job.
-   -3 - Job not in active set.
-
-  Events:
-    - delayed key.
-]]
-local rcall = redis.call
-
-if rcall("EXISTS", KEYS[3]) == 1 then
-
-  if ARGV[3] ~= "0" then
-    local lockKey = KEYS[3] .. ':lock'
-    if rcall("GET", lockKey) == ARGV[3] then
-      rcall("DEL", lockKey)
-    else
-      return -2
-    end
-  end
-
-  local jobId = ARGV[2]
-  local score = tonumber(ARGV[1])
-  local delayedTimestamp = (score / 0x1000)
-  
-  local numRemovedElements = rcall("LREM", KEYS[1], -1, jobId)
-
-  if(numRemovedElements < 1) then
-    return -3
-  end
-
-  rcall("ZADD", KEYS[2], score, jobId)
-
-  rcall("XADD", KEYS[4], "*", "event", "delayed", "jobId", jobId, "delay", delayedTimestamp);
-  rcall("XADD", KEYS[5], "*", "nextTimestamp", delayedTimestamp);
-
-  return 0
-else
-  return -1
-end

package/dist/cjs/scripts/moveToDelayed-5.js

@@ -1,52 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.moveToDelayed = void 0;
-const content = `--[[
-  Moves job from active to delayed set.
-  Input: 
-    KEYS[1] active key
-    KEYS[2] delayed key
-    KEYS[3] job key
-    KEYS[4] events stream
-    KEYS[5] delayed stream
-    ARGV[1] delayedTimestamp
-    ARGV[2] the id of the job
-    ARGV[3] queue token
-  Output:
-    0 - OK
-   -1 - Missing job.
-   -3 - Job not in active set.
-  Events:
-    - delayed key.
-]]
-local rcall = redis.call
-if rcall("EXISTS", KEYS[3]) == 1 then
-  if ARGV[3] ~= "0" then
-    local lockKey = KEYS[3] .. ':lock'
-    if rcall("GET", lockKey) == ARGV[3] then
-      rcall("DEL", lockKey)
-    else
-      return -2
-    end
-  end
-  local jobId = ARGV[2]
-  local score = tonumber(ARGV[1])
-  local delayedTimestamp = (score / 0x1000)
-  local numRemovedElements = rcall("LREM", KEYS[1], -1, jobId)
-  if(numRemovedElements < 1) then
-    return -3
-  end
-  rcall("ZADD", KEYS[2], score, jobId)
-  rcall("XADD", KEYS[4], "*", "event", "delayed", "jobId", jobId, "delay", delayedTimestamp);
-  rcall("XADD", KEYS[5], "*", "nextTimestamp", delayedTimestamp);
-  return 0
-else
-  return -1
-end
-`;
-exports.moveToDelayed = {
-    name: 'moveToDelayed',
-    content,
-    keys: 5,
-};
-//# sourceMappingURL=moveToDelayed-5.js.map

package/dist/cjs/scripts/moveToDelayed-5.js.map

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

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

@@ -1,60 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.retryJob = void 0;
-const content = `--[[
-  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
-      ARGV[1]  pushCmd
-      ARGV[2]  jobId
-      ARGV[3]  token
-    Events:
-      'waiting'
-    Output:
-     0  - OK
-     -1 - Missing key
-     -2 - Missing lock
-]]
-local rcall = redis.call
--- Includes
---[[
-  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
-  else
-    return pausedKey
-  end
-end
-if rcall("EXISTS", KEYS[4]) == 1 then
-  if ARGV[3] ~= "0" then
-    local lockKey = KEYS[4] .. ':lock'
-    if rcall("GET", lockKey) == ARGV[3] then
-      rcall("DEL", lockKey)
-    else
-      return -2
-    end
-  end
-  local target = getTargetQueueList(KEYS[5], KEYS[2], KEYS[3])
-  rcall("LREM", KEYS[1], 0, ARGV[2])
-  rcall(ARGV[1], target, ARGV[2])
-  -- Emit waiting event
-  rcall("XADD", KEYS[6], "*", "event", "waiting", "jobId", ARGV[2], "prev", "failed");
-  return 0
-else
-  return -1
-end
-`;
-exports.retryJob = {
-    name: 'retryJob',
-    content,
-    keys: 6,
-};
-//# sourceMappingURL=retryJob-6.js.map

package/dist/cjs/scripts/retryJob-6.js.map

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

package/dist/esm/commands/moveToDelayed-5.lua

@@ -1,54 +0,0 @@
---[[
-  Moves job from active to delayed set.
-
-  Input: 
-    KEYS[1] active key
-    KEYS[2] delayed key
-    KEYS[3] job key
-    KEYS[4] events stream
-    KEYS[5] delayed stream
-
-    ARGV[1] delayedTimestamp
-    ARGV[2] the id of the job
-    ARGV[3] queue token
-
-  Output:
-    0 - OK
-   -1 - Missing job.
-   -3 - Job not in active set.
-
-  Events:
-    - delayed key.
-]]
-local rcall = redis.call
-
-if rcall("EXISTS", KEYS[3]) == 1 then
-
-  if ARGV[3] ~= "0" then
-    local lockKey = KEYS[3] .. ':lock'
-    if rcall("GET", lockKey) == ARGV[3] then
-      rcall("DEL", lockKey)
-    else
-      return -2
-    end
-  end
-
-  local jobId = ARGV[2]
-  local score = tonumber(ARGV[1])
-  local delayedTimestamp = (score / 0x1000)
-  
-  local numRemovedElements = rcall("LREM", KEYS[1], -1, jobId)
-
-  if(numRemovedElements < 1) then
-    return -3
-  end
-
-  rcall("ZADD", KEYS[2], score, jobId)
-
-  rcall("XADD", KEYS[4], "*", "event", "delayed", "jobId", jobId, "delay", delayedTimestamp);
-  rcall("XADD", KEYS[5], "*", "nextTimestamp", delayedTimestamp);
-
-  return 0
-else
-  return -1
-end

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

@@ -1,49 +0,0 @@
-const content = `--[[
-  Moves job from active to delayed set.
-  Input: 
-    KEYS[1] active key
-    KEYS[2] delayed key
-    KEYS[3] job key
-    KEYS[4] events stream
-    KEYS[5] delayed stream
-    ARGV[1] delayedTimestamp
-    ARGV[2] the id of the job
-    ARGV[3] queue token
-  Output:
-    0 - OK
-   -1 - Missing job.
-   -3 - Job not in active set.
-  Events:
-    - delayed key.
-]]
-local rcall = redis.call
-if rcall("EXISTS", KEYS[3]) == 1 then
-  if ARGV[3] ~= "0" then
-    local lockKey = KEYS[3] .. ':lock'
-    if rcall("GET", lockKey) == ARGV[3] then
-      rcall("DEL", lockKey)
-    else
-      return -2
-    end
-  end
-  local jobId = ARGV[2]
-  local score = tonumber(ARGV[1])
-  local delayedTimestamp = (score / 0x1000)
-  local numRemovedElements = rcall("LREM", KEYS[1], -1, jobId)
-  if(numRemovedElements < 1) then
-    return -3
-  end
-  rcall("ZADD", KEYS[2], score, jobId)
-  rcall("XADD", KEYS[4], "*", "event", "delayed", "jobId", jobId, "delay", delayedTimestamp);
-  rcall("XADD", KEYS[5], "*", "nextTimestamp", delayedTimestamp);
-  return 0
-else
-  return -1
-end
-`;
-export const moveToDelayed = {
-    name: 'moveToDelayed',
-    content,
-    keys: 5,
-};
-//# sourceMappingURL=moveToDelayed-5.js.map

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

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

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

@@ -1,57 +0,0 @@
-const content = `--[[
-  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
-      ARGV[1]  pushCmd
-      ARGV[2]  jobId
-      ARGV[3]  token
-    Events:
-      'waiting'
-    Output:
-     0  - OK
-     -1 - Missing key
-     -2 - Missing lock
-]]
-local rcall = redis.call
--- Includes
---[[
-  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
-  else
-    return pausedKey
-  end
-end
-if rcall("EXISTS", KEYS[4]) == 1 then
-  if ARGV[3] ~= "0" then
-    local lockKey = KEYS[4] .. ':lock'
-    if rcall("GET", lockKey) == ARGV[3] then
-      rcall("DEL", lockKey)
-    else
-      return -2
-    end
-  end
-  local target = getTargetQueueList(KEYS[5], KEYS[2], KEYS[3])
-  rcall("LREM", KEYS[1], 0, ARGV[2])
-  rcall(ARGV[1], target, ARGV[2])
-  -- Emit waiting event
-  rcall("XADD", KEYS[6], "*", "event", "waiting", "jobId", ARGV[2], "prev", "failed");
-  return 0
-else
-  return -1
-end
-`;
-export const retryJob = {
-    name: 'retryJob',
-    content,
-    keys: 6,
-};
-//# sourceMappingURL=retryJob-6.js.map

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

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