bullmq 2.4.0 → 3.0.1

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

@@ -0,0 +1,63 @@
+--[[
+  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
+--- @include "includes/promoteDelayedJobs"
+
+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

package/dist/cjs/commands/moveToFinished-12.lua

@@ -64,6 +64,7 @@ local rcall = redis.call
 --- @include "includes/removeJobsByMaxCount"
 --- @include "includes/trimEvents"
 --- @include "includes/updateParentDepsIfNeeded"
+--- @include "includes/getRateLimitTTL"
 
 local jobIdKey = KEYS[10]
 if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
@@ -169,6 +170,12 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
         -- 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)
 
+        -- Check if we are rate limited first.
+        local pttl = getRateLimitTTL(opts, KEYS[6])
+        if pttl > 0 then
+            return { 0, 0, pttl }
+        end
+
         jobId = rcall("RPOPLPUSH", KEYS[1], KEYS[2])
 
         if jobId == "0" then
@@ -182,7 +189,7 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
         if (nextTimestamp ~= nil) then
             -- The result is guaranteed to be positive, since the
             -- ZRANGEBYSCORE command would have return a job otherwise.
-            return nextTimestamp - timestamp
+            return {0, 0, 0, nextTimestamp - timestamp}
         end
     end
 

package/dist/{esm/commands/retryJob-6.lua → cjs/commands/retryJob-8.lua}

@@ -8,10 +8,14 @@
       KEYS[4] job key
       KEYS[5] 'meta'
       KEYS[6] events stream
+      KEYS[7] delayed key
+      KEYS[8] priority key
 
-      ARGV[1]  pushCmd
-      ARGV[2]  jobId
-      ARGV[3]  token
+      ARGV[1]  key prefix
+      ARGV[2]  timestamp
+      ARGV[3]  pushCmd
+      ARGV[4]  jobId
+      ARGV[5]  token
 
     Events:
       'waiting'
@@ -25,12 +29,15 @@ local rcall = redis.call
 
 -- Includes
 --- @include "includes/getTargetQueueList"
+--- @include "includes/promoteDelayedJobs"
+
+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[3] ~= "0" then
+  if ARGV[5] ~= "0" then
     local lockKey = KEYS[4] .. ':lock'
-    if rcall("GET", lockKey) == ARGV[3] then
+    if rcall("GET", lockKey) == ARGV[5] then
       rcall("DEL", lockKey)
     else
       return -2
@@ -39,11 +46,11 @@ if rcall("EXISTS", KEYS[4]) == 1 then
 
   local target = getTargetQueueList(KEYS[5], KEYS[2], KEYS[3])
 
-  rcall("LREM", KEYS[1], 0, ARGV[2])
-  rcall(ARGV[1], target, ARGV[2])
+  rcall("LREM", KEYS[1], 0, ARGV[4])
+  rcall(ARGV[3], target, ARGV[4])
 
   -- Emit waiting event
-  rcall("XADD", KEYS[6], "*", "event", "waiting", "jobId", ARGV[2], "prev", "failed");
+  rcall("XADD", KEYS[6], "*", "event", "waiting", "jobId", ARGV[4], "prev", "failed");
   
   return 0
 else

package/dist/cjs/interfaces/advanced-options.d.ts

@@ -1,13 +1,13 @@
-import { RepeatStrategy } from '../types';
+import { BackoffStrategy, RepeatStrategy } from '../types';
 export interface AdvancedRepeatOptions {
     /**
-     * A set of custom cron strategies keyed by name.
+     * A custom cron strategy.
      */
     repeatStrategy?: RepeatStrategy;
 }
 export interface AdvancedOptions extends AdvancedRepeatOptions {
     /**
-     * A set of custom backoff strategies keyed by name.
+     * A custom backoff strategy.
      */
-    backoffStrategies?: {};
+    backoffStrategy?: BackoffStrategy;
 }

package/dist/cjs/interfaces/base-job-options.d.ts

@@ -23,12 +23,6 @@ export interface DefaultJobOptions {
      * @defaultValue 0
      */
     attempts?: number;
-    /**
-     * Rate limiter key to use if rate limiter enabled.
-     *
-     * @see {@link https://docs.bullmq.io/guide/rate-limiting}
-     */
-    rateLimiterKey?: string;
     /**
      * Backoff setting for automatic retries if the job fails
      */

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

@@ -31,16 +31,6 @@ export interface QueueBaseOptions {
  */
 export interface QueueOptions extends QueueBaseOptions {
     defaultJobOptions?: DefaultJobOptions;
-    /**
-     * Options for the rate limiter.
-     */
-    limiter?: {
-        /**
-         * Group key to be used by the limiter when
-         * limiting by group keys.
-         */
-        groupKey: string;
-    };
     /**
      * Options for the streams used internally in BullMQ.
      */

package/dist/cjs/interfaces/rate-limiter-options.d.ts

@@ -9,22 +9,4 @@ export interface RateLimiterOptions {
      * of `max` jobs will be processed.
      */
     duration: number;
-    /**
-     * It is possible to define a rate limiter based on group keys,
-     * for example you may want to have a rate limiter per customer
-     * instead of a global rate limiter for all customers
-     *
-     * @see {@link https://docs.bullmq.io/guide/rate-limiting}
-     */
-    groupKey?: string;
-    /**
-     * This option enables a heuristic so that when a queue is heavily
-     * rete limited, it delays the workers so that they do not try
-     * to pick jobs when there is no point in doing so.
-     * Note: It is not recommended to use this option when using
-     * groupKeys unless you have a big amount of workers since
-     * you may be delaying workers that could pick jobs in groups that
-     * have not been rate limited.
-     */
-    workerDelay?: boolean;
 }

package/dist/cjs/interfaces/repeat-options.d.ts

@@ -5,11 +5,6 @@ import { ParserOptions } from 'cron-parser';
  * @see {@link https://docs.bullmq.io/guide/jobs/repeatable}
  */
 export interface RepeatOptions extends Omit<ParserOptions, 'iterator'> {
-    /**
-     * @deprecated Use pattern option instead.
-     * A cron pattern
-     */
-    cron?: string;
     /**
      * A repeat pattern
      */
@@ -20,7 +15,7 @@ export interface RepeatOptions extends Omit<ParserOptions, 'iterator'> {
     limit?: number;
     /**
      * Repeat after this amount of milliseconds
-     * (`cron` setting cannot be used together with this setting.)
+     * (`pattern` setting cannot be used together with this setting.)
      */
     every?: number;
     /**

package/dist/cjs/scripts/index.d.ts

@@ -9,7 +9,7 @@ export * from './isFinished-3';
 export * from './isJobInList-1';
 export * from './moveStalledJobsToWait-8';
 export * from './moveToActive-9';
-export * from './moveToDelayed-5';
+export * from './moveToDelayed-8';
 export * from './moveToFinished-12';
 export * from './moveToWaitingChildren-4';
 export * from './obliterate-2';
@@ -19,7 +19,7 @@ export * from './releaseLock-1';
 export * from './removeJob-1';
 export * from './removeRepeatable-2';
 export * from './reprocessJob-4';
-export * from './retryJob-6';
+export * from './retryJob-8';
 export * from './retryJobs-6';
 export * from './takeLock-1';
 export * from './updateData-1';

package/dist/cjs/scripts/index.js

@@ -12,7 +12,7 @@ tslib_1.__exportStar(require("./isFinished-3"), exports);
 tslib_1.__exportStar(require("./isJobInList-1"), exports);
 tslib_1.__exportStar(require("./moveStalledJobsToWait-8"), exports);
 tslib_1.__exportStar(require("./moveToActive-9"), exports);
-tslib_1.__exportStar(require("./moveToDelayed-5"), exports);
+tslib_1.__exportStar(require("./moveToDelayed-8"), exports);
 tslib_1.__exportStar(require("./moveToFinished-12"), exports);
 tslib_1.__exportStar(require("./moveToWaitingChildren-4"), exports);
 tslib_1.__exportStar(require("./obliterate-2"), exports);
@@ -22,7 +22,7 @@ tslib_1.__exportStar(require("./releaseLock-1"), exports);
 tslib_1.__exportStar(require("./removeJob-1"), exports);
 tslib_1.__exportStar(require("./removeRepeatable-2"), exports);
 tslib_1.__exportStar(require("./reprocessJob-4"), exports);
-tslib_1.__exportStar(require("./retryJob-6"), exports);
+tslib_1.__exportStar(require("./retryJob-8"), exports);
 tslib_1.__exportStar(require("./retryJobs-6"), exports);
 tslib_1.__exportStar(require("./takeLock-1"), exports);
 tslib_1.__exportStar(require("./updateData-1"), exports);

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

@@ -49,41 +49,25 @@ local rcall = redis.call
 local function moveJobFromWaitToActive(keys, keyPrefix, jobId, processedOn, opts)
   -- Check if we need to perform rate limiting.
   local maxJobs = tonumber(opts['limiter'] and opts['limiter']['max'])
+  local expireTime
   if(maxJobs) then
     local rateLimiterKey = keys[6];
-    local groupKey
-    local groupKeyOpt = opts['limiter'] and opts['limiter']['groupKey'] or ""
-    if groupKeyOpt ~= "" then
-      groupKey = string.match(jobId, "[^:]+$")
-      if groupKey ~= jobId then
-        rateLimiterKey = rateLimiterKey .. ":" .. groupKey
-      end
+    local jobCounter = tonumber(rcall("INCR", rateLimiterKey))
+    if jobCounter == 1 then
+      local limiterDuration = opts['limiter'] and opts['limiter']['duration']
+      rcall("PEXPIRE", rateLimiterKey, limiterDuration)
     end
-    local jobCounter
-    if groupKey ~= nil then
-      if rateLimiterKey ~= keys[6] then
-        jobCounter = tonumber(rcall("INCR", rateLimiterKey))
-      end
-    else
-      jobCounter = tonumber(rcall("INCR", rateLimiterKey))
-    end
-    local limiterDuration = opts['limiter'] and opts['limiter']['duration']
-    -- check if rate limit hit
-    if jobCounter ~= nil and jobCounter > maxJobs then
-      local exceedingJobs = jobCounter - maxJobs
-      local expireTime = tonumber(rcall("PTTL", rateLimiterKey))
-      local delay = expireTime + ((exceedingJobs - 1) * limiterDuration) / maxJobs;
-      local timestamp = delay + tonumber(processedOn)
-      -- put job into delayed queue
-      rcall("ZADD", keys[7], timestamp * 0x1000 + bit.band(jobCounter, 0xfff), jobId);
-      rcall("XADD", keys[4], "*", "event", "delayed", "jobId", jobId, "delay", timestamp);
-      -- remove from active queue
+    -- check if we passed rate limit, we need to remove the job and return expireTime
+    if jobCounter > maxJobs then
+      expireTime = rcall("PTTL", rateLimiterKey)
+      -- remove from active queue and add back to the wait list
       rcall("LREM", keys[2], 1, jobId)
+      rcall("RPUSH", keys[1], jobId)
       -- Return when we can process more jobs
-      return expireTime
+      return {0, 0, expireTime}
     else
-      if jobCounter == 1 then
-        rcall("PEXPIRE", rateLimiterKey, limiterDuration)
+      if jobCounter == maxJobs then
+        expireTime = rcall("PTTL", rateLimiterKey)
       end
     end
   end
@@ -97,7 +81,7 @@ local function moveJobFromWaitToActive(keys, keyPrefix, jobId, processedOn, opts
   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} -- get job data
+  return {rcall("HGETALL", jobKey), jobId, expireTime} -- get job data
 end
 --[[
   Function to return the next delayed job timestamp.
@@ -169,19 +153,34 @@ local function promoteDelayedJobs(delayedKey, waitKey, priorityKey, pausedKey,
             rcall("HSET", prefix .. jobId, "delay", 0)
         end
     end
-    local nextTimestamp = rcall("ZRANGE", delayedKey, 0, 0, "WITHSCORES")[2]
-    if (nextTimestamp ~= nil) then
-        nextTimestamp = nextTimestamp / 0x1000
+end
+local function getRateLimitTTL(opts, limiterKey)
+    local maxJobs = tonumber(opts['limiter'] and opts['limiter']['max'])
+    if maxJobs then
+        local jobCounter = tonumber(rcall("GET", limiterKey))
+        if jobCounter ~= nil and jobCounter >= maxJobs then
+            local pttl = rcall("PTTL", KEYS[6])
+            if pttl > 0 then 
+                return pttl 
+            end
+        end
     end
-    return nextTimestamp
+    return 0
 end
 -- Check if there are delayed jobs that we can move to wait.
 promoteDelayedJobs(KEYS[7], KEYS[1], KEYS[3], KEYS[8], KEYS[9], KEYS[4], ARGV[1], ARGV[2])
+local opts
 if (ARGV[3] ~= "") then
     jobId = ARGV[3]
     -- clean stalled key
     rcall("SREM", KEYS[5], jobId)
 else
+    -- Check if we are rate limited first.
+    opts = cmsgpack.unpack(ARGV[4])
+    local pttl = getRateLimitTTL(opts, KEYS[6])
+    if pttl > 0 then
+        return { 0, 0, pttl }
+    end
     -- no job ID, try non-blocking move from wait to active
     jobId = rcall("RPOPLPUSH", KEYS[1], KEYS[2])
 end
@@ -189,14 +188,14 @@ end
 if jobId == "0" then
     rcall("LREM", KEYS[2], 1, 0)
 elseif jobId then
-    local opts = cmsgpack.unpack(ARGV[4])
+    opts = opts or cmsgpack.unpack(ARGV[4])
     -- this script is not really moving, it is preparing the job for processing
     return moveJobFromWaitToActive(KEYS, ARGV[1], jobId, ARGV[2], opts)
 end
 -- Return the timestamp for the next delayed job if any.
 local nextTimestamp = getNextDelayedTimestamp(KEYS[7])
 if (nextTimestamp ~= nil) then
-    return nextTimestamp - tonumber(ARGV[2])
+    return { 0, 0, 0, nextTimestamp - tonumber(ARGV[2])}
 end
 `;
 exports.moveToActive = {

package/dist/cjs/scripts/moveToActive-9.js.map

@@ -1 +1 @@
-{"version":3,"file":"moveToActive-9.js","sourceRoot":"","sources":["../../../src/scripts/moveToActive-9.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqMf,CAAC;AACW,QAAA,YAAY,GAAG;IAC1B,IAAI,EAAE,cAAc;IACpB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}
+{"version":3,"file":"moveToActive-9.js","sourceRoot":"","sources":["../../../src/scripts/moveToActive-9.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoMf,CAAC;AACW,QAAA,YAAY,GAAG;IAC1B,IAAI,EAAE,cAAc;IACpB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

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

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.moveToDelayed = void 0;
+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
+`;
+exports.moveToDelayed = {
+    name: 'moveToDelayed',
+    content,
+    keys: 8,
+};
+//# sourceMappingURL=moveToDelayed-8.js.map

package/dist/cjs/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;AACW,QAAA,aAAa,GAAG;IAC3B,IAAI,EAAE,eAAe;IACrB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

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

@@ -134,41 +134,25 @@ end
 local function moveJobFromWaitToActive(keys, keyPrefix, jobId, processedOn, opts)
   -- Check if we need to perform rate limiting.
   local maxJobs = tonumber(opts['limiter'] and opts['limiter']['max'])
+  local expireTime
   if(maxJobs) then
     local rateLimiterKey = keys[6];
-    local groupKey
-    local groupKeyOpt = opts['limiter'] and opts['limiter']['groupKey'] or ""
-    if groupKeyOpt ~= "" then
-      groupKey = string.match(jobId, "[^:]+$")
-      if groupKey ~= jobId then
-        rateLimiterKey = rateLimiterKey .. ":" .. groupKey
-      end
-    end
-    local jobCounter
-    if groupKey ~= nil then
-      if rateLimiterKey ~= keys[6] then
-        jobCounter = tonumber(rcall("INCR", rateLimiterKey))
-      end
-    else
-      jobCounter = tonumber(rcall("INCR", rateLimiterKey))
+    local jobCounter = tonumber(rcall("INCR", rateLimiterKey))
+    if jobCounter == 1 then
+      local limiterDuration = opts['limiter'] and opts['limiter']['duration']
+      rcall("PEXPIRE", rateLimiterKey, limiterDuration)
     end
-    local limiterDuration = opts['limiter'] and opts['limiter']['duration']
-    -- check if rate limit hit
-    if jobCounter ~= nil and jobCounter > maxJobs then
-      local exceedingJobs = jobCounter - maxJobs
-      local expireTime = tonumber(rcall("PTTL", rateLimiterKey))
-      local delay = expireTime + ((exceedingJobs - 1) * limiterDuration) / maxJobs;
-      local timestamp = delay + tonumber(processedOn)
-      -- put job into delayed queue
-      rcall("ZADD", keys[7], timestamp * 0x1000 + bit.band(jobCounter, 0xfff), jobId);
-      rcall("XADD", keys[4], "*", "event", "delayed", "jobId", jobId, "delay", timestamp);
-      -- remove from active queue
+    -- check if we passed rate limit, we need to remove the job and return expireTime
+    if jobCounter > maxJobs then
+      expireTime = rcall("PTTL", rateLimiterKey)
+      -- remove from active queue and add back to the wait list
       rcall("LREM", keys[2], 1, jobId)
+      rcall("RPUSH", keys[1], jobId)
       -- Return when we can process more jobs
-      return expireTime
+      return {0, 0, expireTime}
     else
-      if jobCounter == 1 then
-        rcall("PEXPIRE", rateLimiterKey, limiterDuration)
+      if jobCounter == maxJobs then
+        expireTime = rcall("PTTL", rateLimiterKey)
       end
     end
   end
@@ -182,7 +166,7 @@ local function moveJobFromWaitToActive(keys, keyPrefix, jobId, processedOn, opts
   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} -- get job data
+  return {rcall("HGETALL", jobKey), jobId, expireTime} -- get job data
 end
 --[[
   Function to recursively move from waitingChildren to failed.
@@ -266,11 +250,6 @@ local function promoteDelayedJobs(delayedKey, waitKey, priorityKey, pausedKey,
             rcall("HSET", prefix .. jobId, "delay", 0)
         end
     end
-    local nextTimestamp = rcall("ZRANGE", delayedKey, 0, 0, "WITHSCORES")[2]
-    if (nextTimestamp ~= nil) then
-        nextTimestamp = nextTimestamp / 0x1000
-    end
-    return nextTimestamp
 end
 --[[
   Functions to remove jobs by max age.
@@ -421,6 +400,19 @@ local function updateParentDepsIfNeeded(parentKey, parentQueueKey, parentDepende
     rcall("XADD", parentQueueKey .. ":events", "*", "event", "waiting", "jobId", parentId, "prev", "waiting-children")
   end
 end
+local function getRateLimitTTL(opts, limiterKey)
+    local maxJobs = tonumber(opts['limiter'] and opts['limiter']['max'])
+    if maxJobs then
+        local jobCounter = tonumber(rcall("GET", limiterKey))
+        if jobCounter ~= nil and jobCounter >= maxJobs then
+            local pttl = rcall("PTTL", KEYS[6])
+            if pttl > 0 then 
+                return pttl 
+            end
+        end
+    end
+    return 0
+end
 local jobIdKey = KEYS[10]
 if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
     local opts = cmsgpack.unpack(ARGV[9])
@@ -507,6 +499,11 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
     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)
+        -- Check if we are rate limited first.
+        local pttl = getRateLimitTTL(opts, KEYS[6])
+        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)
@@ -518,7 +515,7 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
         if (nextTimestamp ~= nil) then
             -- The result is guaranteed to be positive, since the
             -- ZRANGEBYSCORE command would have return a job otherwise.
-            return nextTimestamp - timestamp
+            return {0, 0, 0, nextTimestamp - timestamp}
         end
     end
     local waitLen = rcall("LLEN", KEYS[1])

package/dist/cjs/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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmhBf,CAAC;AACW,QAAA,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAghBf,CAAC;AACW,QAAA,cAAc,GAAG;IAC5B,IAAI,EAAE,gBAAgB;IACtB,OAAO;IACP,IAAI,EAAE,EAAE;CACT,CAAC"}