bullmq 5.80.0 → 5.80.2

package/dist/cjs/classes/job.js

@@ -9,7 +9,7 @@ const backoffs_1 = require("./backoffs");
 const unrecoverable_error_1 = require("./errors/unrecoverable-error");
 const enums_1 = require("../enums");
 const logger = (0, util_1.debuglog)('bull');
-exports.PRIORITY_LIMIT = 2 ** 21;
+exports.PRIORITY_LIMIT = 2 ** 21 - 1;
 /**
  * Job
  *
@@ -59,9 +59,11 @@ class Job {
          */
         this.delay = 0;
         /**
-         * Ranges from 0 (highest priority) to 2 097 152 (lowest priority). Note that
-         * using priorities has a slight impact on performance,
-         * so do not use it if not required.
+         * Ranges from 0 to 2 097 151. `0` means no explicit priority, and jobs with
+         * no explicit priority are processed before prioritized jobs. For prioritized
+         * jobs, lower numbers are processed before higher numbers. Note that using
+         * priorities has a slight impact on performance, so do not use it if not
+         * required.
          * @defaultValue 0
          */
         this.priority = 0;

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

@@ -9,25 +9,32 @@ local function getJobSchedulerEveryNextMillis(prevMillis, every, now, offset, st
             nextMillis = tonumber(startDate)
             nextMillis = nextMillis > now and nextMillis or now
         else
-            nextMillis = now
-            -- For the first iteration with no startDate and an explicit
-            -- offset, align nextMillis to the next offset slot strictly
-            -- after now. Without this the user-supplied offset is
-            -- recorded but ignored, and the first job fires at now
-            -- instead of the next aligned timestamp (issue #3705).
             if offset and offset > 0 then
-                local aligned = math.floor(nextMillis / every) * every + offset
-                if aligned <= nextMillis then
-                    aligned = aligned + every
+                -- Align to the next slot that respects the offset
+                nextMillis = math.floor(now / every) * every + offset
+                if nextMillis <= now then
+                    nextMillis = nextMillis + every
                 end
-                nextMillis = aligned
+            else
+                nextMillis = now
             end
         end
     else
         nextMillis = prevMillis + every
         -- check if we may have missed some iterations
         if nextMillis < now then
-            nextMillis = math.floor(now / every) * every + every + (offset or 0)
+            -- Use the same offset-aware alignment as the initial branch
+            -- above so a non-zero offset is preserved across catch-ups
+            -- instead of being flattened to (slot + every). When the
+            -- aligned slot is itself still in the past, advance by one
+            -- full interval; otherwise the aligned slot is the next
+            -- iteration.
+            local aligned = math.floor(now / every) * every + (offset or 0)
+            if aligned <= now then
+                nextMillis = aligned + every
+            else
+                nextMillis = aligned
+            end
         end
     end
 

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

@@ -443,25 +443,32 @@ local function getJobSchedulerEveryNextMillis(prevMillis, every, now, offset, st
             nextMillis = tonumber(startDate)
             nextMillis = nextMillis > now and nextMillis or now
         else
-            nextMillis = now
-            -- For the first iteration with no startDate and an explicit
-            -- offset, align nextMillis to the next offset slot strictly
-            -- after now. Without this the user-supplied offset is
-            -- recorded but ignored, and the first job fires at now
-            -- instead of the next aligned timestamp (issue #3705).
             if offset and offset > 0 then
-                local aligned = math.floor(nextMillis / every) * every + offset
-                if aligned <= nextMillis then
-                    aligned = aligned + every
+                -- Align to the next slot that respects the offset
+                nextMillis = math.floor(now / every) * every + offset
+                if nextMillis <= now then
+                    nextMillis = nextMillis + every
                 end
-                nextMillis = aligned
+            else
+                nextMillis = now
             end
         end
     else
         nextMillis = prevMillis + every
         -- check if we may have missed some iterations
         if nextMillis < now then
-            nextMillis = math.floor(now / every) * every + every + (offset or 0)
+            -- Use the same offset-aware alignment as the initial branch
+            -- above so a non-zero offset is preserved across catch-ups
+            -- instead of being flattened to (slot + every). When the
+            -- aligned slot is itself still in the past, advance by one
+            -- full interval; otherwise the aligned slot is the next
+            -- iteration.
+            local aligned = math.floor(now / every) * every + (offset or 0)
+            if aligned <= now then
+                nextMillis = aligned + every
+            else
+                nextMillis = aligned
+            end
         end
     end
     if not offset or offset == 0 then

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

@@ -249,25 +249,32 @@ local function getJobSchedulerEveryNextMillis(prevMillis, every, now, offset, st
             nextMillis = tonumber(startDate)
             nextMillis = nextMillis > now and nextMillis or now
         else
-            nextMillis = now
-            -- For the first iteration with no startDate and an explicit
-            -- offset, align nextMillis to the next offset slot strictly
-            -- after now. Without this the user-supplied offset is
-            -- recorded but ignored, and the first job fires at now
-            -- instead of the next aligned timestamp (issue #3705).
             if offset and offset > 0 then
-                local aligned = math.floor(nextMillis / every) * every + offset
-                if aligned <= nextMillis then
-                    aligned = aligned + every
+                -- Align to the next slot that respects the offset
+                nextMillis = math.floor(now / every) * every + offset
+                if nextMillis <= now then
+                    nextMillis = nextMillis + every
                 end
-                nextMillis = aligned
+            else
+                nextMillis = now
             end
         end
     else
         nextMillis = prevMillis + every
         -- check if we may have missed some iterations
         if nextMillis < now then
-            nextMillis = math.floor(now / every) * every + every + (offset or 0)
+            -- Use the same offset-aware alignment as the initial branch
+            -- above so a non-zero offset is preserved across catch-ups
+            -- instead of being flattened to (slot + every). When the
+            -- aligned slot is itself still in the past, advance by one
+            -- full interval; otherwise the aligned slot is the next
+            -- iteration.
+            local aligned = math.floor(now / every) * every + (offset or 0)
+            if aligned <= now then
+                nextMillis = aligned + every
+            else
+                nextMillis = aligned
+            end
         end
     end
     if not offset or offset == 0 then