bullmq 5.58.6 → 5.58.8

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

@@ -0,0 +1,28 @@
+
+
+local function getJobSchedulerEveryNextMillis(prevMillis, every, now, offset, startDate)
+    local nextMillis
+    if not prevMillis then
+        if startDate then
+            -- Assuming startDate is passed as milliseconds from JavaScript
+            nextMillis = tonumber(startDate)
+            nextMillis = nextMillis > now and nextMillis or now
+        else
+            nextMillis = now
+        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)
+        end
+    end
+
+    if not offset or offset == 0 then
+        local timeSlot = math.floor(nextMillis / every) * every;
+        offset = nextMillis - timeSlot;
+    end
+
+    -- Return a tuple nextMillis, offset
+    return math.floor(nextMillis), math.floor(offset)
+end

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

@@ -21,6 +21,11 @@ local function storeJobScheduler(schedulerId, schedulerKey, repeatKey, nextMilli
     table.insert(optionalValues, opts['pattern'])
   end
 
+  if opts['startDate'] then
+    table.insert(optionalValues, "startDate")
+    table.insert(optionalValues, opts['startDate'])
+  end
+
   if opts['endDate'] then
     table.insert(optionalValues, "endDate")
     table.insert(optionalValues, opts['endDate'])
@@ -34,6 +39,12 @@ local function storeJobScheduler(schedulerId, schedulerKey, repeatKey, nextMilli
   if opts['offset'] then
     table.insert(optionalValues, "offset")
     table.insert(optionalValues, opts['offset'])
+  else
+    local offset = rcall("HGET", schedulerKey, "offset")
+    if offset then
+      table.insert(optionalValues, "offset")
+      table.insert(optionalValues, tonumber(offset))
+    end
   end
 
   local jsonTemplateOpts = cjson.encode(templateOpts)
@@ -47,6 +58,9 @@ local function storeJobScheduler(schedulerId, schedulerKey, repeatKey, nextMilli
     table.insert(optionalValues, templateData)
   end
 
+  table.insert(optionalValues, "ic")
+  table.insert(optionalValues, rcall("HGET", schedulerKey, "ic") or 1)
+
   rcall("DEL", schedulerKey) -- remove all attributes and then re-insert new ones
-  rcall("HMSET", schedulerKey, "name", opts['name'], "ic", 1, unpack(optionalValues))
+  rcall("HMSET", schedulerKey, "name", opts['name'], unpack(optionalValues))
 end

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

@@ -73,10 +73,23 @@ if (#stalling > 0) then
                 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, "stc", 1)
-                    if stalledCount > maxStalledJobCount then
+                    
+                    -- Check if this is a repeatable job by looking at job options
+                    local jobOpts = rcall("HGET", jobKey, "opts")
+                    local isRepeatableJob = false
+                    if jobOpts then
+                        local opts = cjson.decode(jobOpts)
+                        if opts and opts["repeat"] then
+                            isRepeatableJob = true
+                        end
+                    end
+                    
+                    -- Only fail job if it exceeds stall limit AND is not a repeatable job
+                    if stalledCount > maxStalledJobCount and not isRepeatableJob then
                         local failedReason = "job stalled more than allowable limit"
                         rcall("HSET", jobKey, "defa", failedReason)
                     end
+                    
                     moveJobToWait(metaKey, activeKey, waitKey, pausedKey, markerKey, eventStreamKey, jobId,
                         "RPUSH")
 

package/dist/cjs/commands/promote-9.lua

@@ -50,7 +50,6 @@ if rcall("ZREM", KEYS[1], jobId) == 1 then
         addJobWithPriority(markerKey, KEYS[5], priority, jobId, KEYS[7], isPausedOrMaxed)
     end
 
-    -- Emit waiting event (wait..ing@token)
     rcall("XADD", KEYS[8], "*", "event", "waiting", "jobId", jobId, "prev",
           "delayed");
 

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

@@ -25,31 +25,60 @@
 
     Output:
       next delayed job id  - OK
-]]
-local rcall = redis.call
+]] local rcall = redis.call
 local repeatKey = KEYS[1]
 local delayedKey = KEYS[2]
 local waitKey = KEYS[3]
 local pausedKey = KEYS[4]
 local metaKey = KEYS[5]
 local prioritizedKey = KEYS[6]
-local nextMillis = ARGV[1]
+local nextMillis = tonumber(ARGV[1])
 local jobSchedulerId = ARGV[2]
-local timestamp = ARGV[5]
+local timestamp = tonumber(ARGV[5])
 local prefixKey = ARGV[6]
 local producerId = ARGV[7]
+local jobOpts = cmsgpack.unpack(ARGV[4])
 
 -- Includes
 --- @include "includes/addJobFromScheduler"
 --- @include "includes/getOrSetMaxEvents"
+--- @include "includes/getJobSchedulerEveryNextMillis"
 
-local schedulerKey = repeatKey .. ":" .. jobSchedulerId
-local nextDelayedJobId = "repeat:" .. jobSchedulerId .. ":" .. nextMillis
-local nextDelayedJobKey = schedulerKey .. ":" .. nextMillis
+local prevMillis = rcall("ZSCORE", repeatKey, jobSchedulerId)
 
 -- Validate that scheduler exists.
-local prevMillis = rcall("ZSCORE", repeatKey, jobSchedulerId)
+-- If it does not exist we should not iterate anymore.
 if prevMillis then
+    prevMillis = tonumber(prevMillis)
+
+    local schedulerKey = repeatKey .. ":" .. jobSchedulerId
+    local schedulerAttributes = rcall("HMGET", schedulerKey, "name", "data", "every", "startDate", "offset")
+
+    local every = tonumber(schedulerAttributes[3])
+    local now = tonumber(timestamp)
+
+    -- If every is not found in scheduler attributes, try to get it from job options
+    if not every and jobOpts['repeat'] and jobOpts['repeat']['every'] then
+        every = tonumber(jobOpts['repeat']['every'])
+    end
+
+    if every then
+        local startDate = schedulerAttributes[4]
+        local jobOptsOffset = jobOpts['repeat'] and jobOpts['repeat']['offset'] or 0
+        local offset = schedulerAttributes[5] or jobOptsOffset or 0
+        local newOffset
+
+        nextMillis, newOffset = getJobSchedulerEveryNextMillis(prevMillis, every, now, offset, startDate)
+
+        if not offset then
+            rcall("HSET", schedulerKey, "offset", newOffset)
+            jobOpts['repeat']['offset'] = newOffset
+        end
+    end
+
+    local nextDelayedJobId = "repeat:" .. jobSchedulerId .. ":" .. nextMillis
+    local nextDelayedJobKey = schedulerKey .. ":" .. nextMillis
+
     local currentDelayedJobId = "repeat:" .. jobSchedulerId .. ":" .. prevMillis
 
     if producerId == currentDelayedJobId then
@@ -57,7 +86,6 @@ if prevMillis then
         local maxEvents = getOrSetMaxEvents(metaKey)
 
         if rcall("EXISTS", nextDelayedJobKey) ~= 1 then
-            local schedulerAttributes = rcall("HMGET", schedulerKey, "name", "data")
 
             rcall("ZADD", repeatKey, nextMillis, jobSchedulerId)
             rcall("HINCRBY", schedulerKey, "ic", 1)
@@ -72,9 +100,18 @@ if prevMillis then
                 rcall("HSET", schedulerKey, "data", templateData)
             end
 
-            addJobFromScheduler(nextDelayedJobKey, nextDelayedJobId, ARGV[4], waitKey, pausedKey, 
-                KEYS[12], metaKey, prioritizedKey, KEYS[10], delayedKey, KEYS[7], eventsKey, 
-                schedulerAttributes[1], maxEvents, ARGV[5], templateData or '{}', jobSchedulerId)
+            local delay = nextMillis - now
+
+            -- Fast Clamp delay to minimum of 0
+            if delay < 0 then
+                delay = 0
+            end
+
+            jobOpts["delay"] = delay
+
+            addJobFromScheduler(nextDelayedJobKey, nextDelayedJobId, jobOpts, waitKey, pausedKey, KEYS[12], metaKey,
+                prioritizedKey, KEYS[10], delayedKey, KEYS[7], eventsKey, schedulerAttributes[1], maxEvents, ARGV[5],
+                templateData or '{}', jobSchedulerId, delay)
 
             -- TODO: remove this workaround in next breaking change
             if KEYS[11] ~= "" then
@@ -83,8 +120,7 @@ if prevMillis then
 
             return nextDelayedJobId .. "" -- convert to string
         else
-            rcall("XADD", eventsKey, "MAXLEN", "~", maxEvents, "*", "event",
-                "duplicated", "jobId", nextDelayedJobId)
+            rcall("XADD", eventsKey, "MAXLEN", "~", maxEvents, "*", "event", "duplicated", "jobId", nextDelayedJobId)
         end
     end
 end

package/dist/cjs/enums/error-code.js

@@ -12,5 +12,7 @@ var ErrorCode;
     ErrorCode[ErrorCode["ParentJobCannotBeReplaced"] = -7] = "ParentJobCannotBeReplaced";
     ErrorCode[ErrorCode["JobBelongsToJobScheduler"] = -8] = "JobBelongsToJobScheduler";
     ErrorCode[ErrorCode["JobHasFailedChildren"] = -9] = "JobHasFailedChildren";
+    ErrorCode[ErrorCode["SchedulerJobIdCollision"] = -10] = "SchedulerJobIdCollision";
+    ErrorCode[ErrorCode["SchedulerJobSlotsBusy"] = -11] = "SchedulerJobSlotsBusy";
 })(ErrorCode || (exports.ErrorCode = ErrorCode = {}));
 //# sourceMappingURL=error-code.js.map

package/dist/cjs/enums/error-code.js.map

@@ -1 +1 @@
-{"version":3,"file":"error-code.js","sourceRoot":"","sources":["../../../src/enums/error-code.ts"],"names":[],"mappings":";;;AAAA,IAAY,SAUX;AAVD,WAAY,SAAS;IACnB,wDAAgB,CAAA;IAChB,gEAAoB,CAAA;IACpB,4DAAkB,CAAA;IAClB,sEAAuB,CAAA;IACvB,oEAAsB,CAAA;IACtB,gEAAoB,CAAA;IACpB,oFAA8B,CAAA;IAC9B,kFAA6B,CAAA;IAC7B,0EAAyB,CAAA;AAC3B,CAAC,EAVW,SAAS,yBAAT,SAAS,QAUpB"}
+{"version":3,"file":"error-code.js","sourceRoot":"","sources":["../../../src/enums/error-code.ts"],"names":[],"mappings":";;;AAAA,IAAY,SAYX;AAZD,WAAY,SAAS;IACnB,wDAAgB,CAAA;IAChB,gEAAoB,CAAA;IACpB,4DAAkB,CAAA;IAClB,sEAAuB,CAAA;IACvB,oEAAsB,CAAA;IACtB,gEAAoB,CAAA;IACpB,oFAA8B,CAAA;IAC9B,kFAA6B,CAAA;IAC7B,0EAAyB,CAAA;IACzB,iFAA6B,CAAA;IAC7B,6EAA2B,CAAA;AAC7B,CAAC,EAZW,SAAS,yBAAT,SAAS,QAYpB"}

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

@@ -19,7 +19,7 @@ const content = `--[[
       ARGV[2] msgpacked options
             [1]  name
             [2]  tz?
-            [3]  patten?
+            [3]  pattern?
             [4]  endDate?
             [5]  every?
       ARGV[3] jobs scheduler id
@@ -43,7 +43,9 @@ local eventsKey = KEYS[9]
 local nextMillis = ARGV[1]
 local jobSchedulerId = ARGV[3]
 local templateOpts = cmsgpack.unpack(ARGV[5])
+local now = tonumber(ARGV[7])
 local prefixKey = ARGV[8]
+local jobOpts = cmsgpack.unpack(ARGV[6])
 -- Includes
 --[[
   Add delay marker if needed.
@@ -203,10 +205,11 @@ local function addJobInTargetList(targetKey, markerKey, pushCmd, isPausedOrMaxed
   rcall(pushCmd, targetKey, jobId)
   addBaseMarkerIfNeeded(markerKey, isPausedOrMaxed)
 end
-local function addJobFromScheduler(jobKey, jobId, rawOpts, waitKey, pausedKey, activeKey, metaKey, 
+local function addJobFromScheduler(jobKey, jobId, opts, waitKey, pausedKey, activeKey, metaKey, 
   prioritizedKey, priorityCounter, delayedKey, markerKey, eventsKey, name, maxEvents, timestamp,
-  data, jobSchedulerId)
-  local opts = cmsgpack.unpack(rawOpts)
+  data, jobSchedulerId, repeatDelay)
+  opts['delay'] = repeatDelay
+  opts['jobId'] = jobId
   local delay, priority = storeJob(eventsKey, jobKey, jobId, name, data,
     opts, timestamp, nil, nil, jobSchedulerId)
   if delay ~= 0 then
@@ -377,6 +380,10 @@ local function storeJobScheduler(schedulerId, schedulerKey, repeatKey, nextMilli
     table.insert(optionalValues, "pattern")
     table.insert(optionalValues, opts['pattern'])
   end
+  if opts['startDate'] then
+    table.insert(optionalValues, "startDate")
+    table.insert(optionalValues, opts['startDate'])
+  end
   if opts['endDate'] then
     table.insert(optionalValues, "endDate")
     table.insert(optionalValues, opts['endDate'])
@@ -388,6 +395,12 @@ local function storeJobScheduler(schedulerId, schedulerKey, repeatKey, nextMilli
   if opts['offset'] then
     table.insert(optionalValues, "offset")
     table.insert(optionalValues, opts['offset'])
+  else
+    local offset = rcall("HGET", schedulerKey, "offset")
+    if offset then
+      table.insert(optionalValues, "offset")
+      table.insert(optionalValues, tonumber(offset))
+    end
   end
   local jsonTemplateOpts = cjson.encode(templateOpts)
   if jsonTemplateOpts and jsonTemplateOpts ~= '{}' then
@@ -398,15 +411,55 @@ local function storeJobScheduler(schedulerId, schedulerKey, repeatKey, nextMilli
     table.insert(optionalValues, "data")
     table.insert(optionalValues, templateData)
   end
+  table.insert(optionalValues, "ic")
+  table.insert(optionalValues, rcall("HGET", schedulerKey, "ic") or 1)
   rcall("DEL", schedulerKey) -- remove all attributes and then re-insert new ones
-  rcall("HMSET", schedulerKey, "name", opts['name'], "ic", 1, unpack(optionalValues))
+  rcall("HMSET", schedulerKey, "name", opts['name'], unpack(optionalValues))
+end
+local function getJobSchedulerEveryNextMillis(prevMillis, every, now, offset, startDate)
+    local nextMillis
+    if not prevMillis then
+        if startDate then
+            -- Assuming startDate is passed as milliseconds from JavaScript
+            nextMillis = tonumber(startDate)
+            nextMillis = nextMillis > now and nextMillis or now
+        else
+            nextMillis = now
+        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)
+        end
+    end
+    if not offset or offset == 0 then
+        local timeSlot = math.floor(nextMillis / every) * every;
+        offset = nextMillis - timeSlot;
+    end
+    -- Return a tuple nextMillis, offset
+    return math.floor(nextMillis), math.floor(offset)
 end
 -- If we are overriding a repeatable job we must delete the delayed job for
 -- the next iteration.
 local schedulerKey = repeatKey .. ":" .. jobSchedulerId
-local nextDelayedJobKey = schedulerKey .. ":" .. nextMillis
-local nextDelayedJobId = "repeat:" .. jobSchedulerId .. ":" .. nextMillis
 local maxEvents = getOrSetMaxEvents(metaKey)
+local templateData = ARGV[4]
+local prevMillis = rcall("ZSCORE", repeatKey, jobSchedulerId)
+if prevMillis then
+    prevMillis = tonumber(prevMillis)
+end
+local schedulerOpts = cmsgpack.unpack(ARGV[2])
+local every = schedulerOpts['every']
+-- For backwards compatibility we also check the offset from the job itself.
+-- could be removed in future major versions.
+local jobOffset = jobOpts['repeat'] and jobOpts['repeat']['offset'] or 0
+local offset = schedulerOpts['offset'] or jobOffset or 0
+local newOffset = offset
+if every then
+    local startDate = schedulerOpts['startDate']
+    nextMillis, newOffset = getJobSchedulerEveryNextMillis(prevMillis, every, now, offset, startDate)
+end
 local function removeJobFromScheduler(prefixKey, delayedKey, prioritizedKey, waitKey, pausedKey, jobId,
     metaKey, eventsKey)
     if rcall("ZSCORE", delayedKey, jobId) then
@@ -429,33 +482,63 @@ local function removeJobFromScheduler(prefixKey, delayedKey, prioritizedKey, wai
     end
     return false
 end
-if rcall("EXISTS", nextDelayedJobKey) == 1 then
-    if not removeJobFromScheduler(prefixKey, delayedKey, prioritizedKey, waitKey, pausedKey,
-        nextDelayedJobId, metaKey, eventsKey) then
-        rcall("XADD", eventsKey, "MAXLEN", "~", maxEvents, "*", "event",
-            "duplicated", "jobId", nextDelayedJobId)
-        return nextDelayedJobId .. "" -- convert to string
-    end
-end
-local prevMillis = rcall("ZSCORE", repeatKey, jobSchedulerId)
+local hadPrevJob = false
 if prevMillis then    
     local currentJobId = "repeat:" .. jobSchedulerId .. ":" .. prevMillis
-    local currentDelayedJobKey = schedulerKey .. ":" .. prevMillis
-    if currentJobId ~= nextDelayedJobId and rcall("EXISTS", currentDelayedJobKey) == 1 then
-        removeJobFromScheduler(prefixKey, delayedKey, prioritizedKey, waitKey, pausedKey,
+    local currentJobKey = schedulerKey .. ":" .. prevMillis
+    -- In theory it should always exist the currentJobKey if there is a prevMillis unless something has
+    -- gone really wrong.
+    if rcall("EXISTS", currentJobKey) == 1 then
+        hadPrevJob = removeJobFromScheduler(prefixKey, delayedKey, prioritizedKey, waitKey, pausedKey,
             currentJobId, metaKey, eventsKey)
     end
 end
-local schedulerOpts = cmsgpack.unpack(ARGV[2])
-storeJobScheduler(jobSchedulerId, schedulerKey, repeatKey, nextMillis, schedulerOpts, ARGV[4], templateOpts)
+if hadPrevJob then
+    -- The jobs has been removed and we want to replace it, so lets use the same millis.
+    nextMillis = prevMillis
+else 
+    -- Special case where no job was removed, and we need to add the next iteration.
+    schedulerOpts['offset'] = newOffset
+end
+-- Check for job ID collision with existing jobs (in any state)
+local jobId = "repeat:" .. jobSchedulerId .. ":" .. nextMillis
+local jobKey = prefixKey .. jobId
+-- If there's already a job with this ID, handle the collision
+if rcall("EXISTS", jobKey) == 1 then
+    if every then
+        -- For 'every' case: try next time slot to avoid collision
+        local nextSlotMillis = nextMillis + every
+        local nextSlotJobId = "repeat:" .. jobSchedulerId .. ":" .. nextSlotMillis
+        local nextSlotJobKey = prefixKey .. nextSlotJobId
+        if rcall("EXISTS", nextSlotJobKey) == 0 then
+            -- Next slot is free, use it
+            nextMillis = nextSlotMillis
+            jobId = nextSlotJobId
+        else
+            -- Next slot also has a job, return error code
+            return -11 -- SchedulerJobSlotsBusy
+        end
+    else
+        -- For 'pattern' case: return error code
+        return -10 -- SchedulerJobIdCollision
+    end
+end
+local delay = nextMillis - now
+-- Fast Clamp delay to minimum of 0
+if delay < 0 then
+    delay = 0
+end
+local nextJobKey = schedulerKey .. ":" .. nextMillis
+-- jobId already calculated above during collision check
+storeJobScheduler(jobSchedulerId, schedulerKey, repeatKey, nextMillis, schedulerOpts, templateData, templateOpts)
 rcall("INCR", KEYS[8])
-addJobFromScheduler(nextDelayedJobKey, nextDelayedJobId, ARGV[6], waitKey, pausedKey,
+addJobFromScheduler(nextJobKey, jobId, jobOpts, waitKey, pausedKey,
     KEYS[11], metaKey, prioritizedKey, KEYS[10], delayedKey, KEYS[7], eventsKey,
-    schedulerOpts['name'], maxEvents, ARGV[7], ARGV[4], jobSchedulerId)
+    schedulerOpts['name'], maxEvents, now, templateData, jobSchedulerId, delay)
 if ARGV[9] ~= "" then
-    rcall("HSET", ARGV[9], "nrjid", nextDelayedJobId)
+    rcall("HSET", ARGV[9], "nrjid", jobId)
 end
-return nextDelayedJobId .. "" -- convert to string
+return {jobId .. "", delay}
 `;
 exports.addJobScheduler = {
     name: 'addJobScheduler',

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

@@ -1 +1 @@
-{"version":3,"file":"addJobScheduler-11.js","sourceRoot":"","sources":["../../../src/scripts/addJobScheduler-11.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAucf,CAAC;AACW,QAAA,eAAe,GAAG;IAC7B,IAAI,EAAE,iBAAiB;IACvB,OAAO;IACP,IAAI,EAAE,EAAE;CACT,CAAC"}
+{"version":3,"file":"addJobScheduler-11.js","sourceRoot":"","sources":["../../../src/scripts/addJobScheduler-11.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0hBf,CAAC;AACW,QAAA,eAAe,GAAG;IAC7B,IAAI,EAAE,iBAAiB;IACvB,OAAO;IACP,IAAI,EAAE,EAAE;CACT,CAAC"}

package/dist/cjs/scripts/addRepeatableJob-2.js

@@ -10,7 +10,7 @@ const content = `--[[
       ARGV[2] msgpacked options
             [1]  name
             [2]  tz?
-            [3]  patten?
+            [3]  pattern?
             [4]  endDate?
             [5]  every?
       ARGV[3] legacy custom key TODO: remove this logic in next breaking change

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

@@ -144,7 +144,17 @@ if (#stalling > 0) then
                 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, "stc", 1)
-                    if stalledCount > maxStalledJobCount then
+                    -- Check if this is a repeatable job by looking at job options
+                    local jobOpts = rcall("HGET", jobKey, "opts")
+                    local isRepeatableJob = false
+                    if jobOpts then
+                        local opts = cjson.decode(jobOpts)
+                        if opts and opts["repeat"] then
+                            isRepeatableJob = true
+                        end
+                    end
+                    -- Only fail job if it exceeds stall limit AND is not a repeatable job
+                    if stalledCount > maxStalledJobCount and not isRepeatableJob then
                         local failedReason = "job stalled more than allowable limit"
                         rcall("HSET", jobKey, "defa", failedReason)
                     end

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

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

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

@@ -94,7 +94,6 @@ if rcall("ZREM", KEYS[1], jobId) == 1 then
     else
         addJobWithPriority(markerKey, KEYS[5], priority, jobId, KEYS[7], isPausedOrMaxed)
     end
-    -- Emit waiting event (wait..ing@token)
     rcall("XADD", KEYS[8], "*", "event", "waiting", "jobId", jobId, "prev",
           "delayed");
     rcall("HSET", jobKey, "delay", 0)

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

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

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

@@ -25,19 +25,19 @@ const content = `--[[
     ARGV[7] producer id
     Output:
       next delayed job id  - OK
-]]
-local rcall = redis.call
+]] local rcall = redis.call
 local repeatKey = KEYS[1]
 local delayedKey = KEYS[2]
 local waitKey = KEYS[3]
 local pausedKey = KEYS[4]
 local metaKey = KEYS[5]
 local prioritizedKey = KEYS[6]
-local nextMillis = ARGV[1]
+local nextMillis = tonumber(ARGV[1])
 local jobSchedulerId = ARGV[2]
-local timestamp = ARGV[5]
+local timestamp = tonumber(ARGV[5])
 local prefixKey = ARGV[6]
 local producerId = ARGV[7]
+local jobOpts = cmsgpack.unpack(ARGV[4])
 -- Includes
 --[[
   Add delay marker if needed.
@@ -197,10 +197,11 @@ local function addJobInTargetList(targetKey, markerKey, pushCmd, isPausedOrMaxed
   rcall(pushCmd, targetKey, jobId)
   addBaseMarkerIfNeeded(markerKey, isPausedOrMaxed)
 end
-local function addJobFromScheduler(jobKey, jobId, rawOpts, waitKey, pausedKey, activeKey, metaKey, 
+local function addJobFromScheduler(jobKey, jobId, opts, waitKey, pausedKey, activeKey, metaKey, 
   prioritizedKey, priorityCounter, delayedKey, markerKey, eventsKey, name, maxEvents, timestamp,
-  data, jobSchedulerId)
-  local opts = cmsgpack.unpack(rawOpts)
+  data, jobSchedulerId, repeatDelay)
+  opts['delay'] = repeatDelay
+  opts['jobId'] = jobId
   local delay, priority = storeJob(eventsKey, jobKey, jobId, name, data,
     opts, timestamp, nil, nil, jobSchedulerId)
   if delay ~= 0 then
@@ -230,18 +231,61 @@ local function getOrSetMaxEvents(metaKey)
   end
   return maxEvents
 end
-local schedulerKey = repeatKey .. ":" .. jobSchedulerId
-local nextDelayedJobId = "repeat:" .. jobSchedulerId .. ":" .. nextMillis
-local nextDelayedJobKey = schedulerKey .. ":" .. nextMillis
--- Validate that scheduler exists.
+local function getJobSchedulerEveryNextMillis(prevMillis, every, now, offset, startDate)
+    local nextMillis
+    if not prevMillis then
+        if startDate then
+            -- Assuming startDate is passed as milliseconds from JavaScript
+            nextMillis = tonumber(startDate)
+            nextMillis = nextMillis > now and nextMillis or now
+        else
+            nextMillis = now
+        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)
+        end
+    end
+    if not offset or offset == 0 then
+        local timeSlot = math.floor(nextMillis / every) * every;
+        offset = nextMillis - timeSlot;
+    end
+    -- Return a tuple nextMillis, offset
+    return math.floor(nextMillis), math.floor(offset)
+end
 local prevMillis = rcall("ZSCORE", repeatKey, jobSchedulerId)
+-- Validate that scheduler exists.
+-- If it does not exist we should not iterate anymore.
 if prevMillis then
+    prevMillis = tonumber(prevMillis)
+    local schedulerKey = repeatKey .. ":" .. jobSchedulerId
+    local schedulerAttributes = rcall("HMGET", schedulerKey, "name", "data", "every", "startDate", "offset")
+    local every = tonumber(schedulerAttributes[3])
+    local now = tonumber(timestamp)
+    -- If every is not found in scheduler attributes, try to get it from job options
+    if not every and jobOpts['repeat'] and jobOpts['repeat']['every'] then
+        every = tonumber(jobOpts['repeat']['every'])
+    end
+    if every then
+        local startDate = schedulerAttributes[4]
+        local jobOptsOffset = jobOpts['repeat'] and jobOpts['repeat']['offset'] or 0
+        local offset = schedulerAttributes[5] or jobOptsOffset or 0
+        local newOffset
+        nextMillis, newOffset = getJobSchedulerEveryNextMillis(prevMillis, every, now, offset, startDate)
+        if not offset then
+            rcall("HSET", schedulerKey, "offset", newOffset)
+            jobOpts['repeat']['offset'] = newOffset
+        end
+    end
+    local nextDelayedJobId = "repeat:" .. jobSchedulerId .. ":" .. nextMillis
+    local nextDelayedJobKey = schedulerKey .. ":" .. nextMillis
     local currentDelayedJobId = "repeat:" .. jobSchedulerId .. ":" .. prevMillis
     if producerId == currentDelayedJobId then
         local eventsKey = KEYS[9]
         local maxEvents = getOrSetMaxEvents(metaKey)
         if rcall("EXISTS", nextDelayedJobKey) ~= 1 then
-            local schedulerAttributes = rcall("HMGET", schedulerKey, "name", "data")
             rcall("ZADD", repeatKey, nextMillis, jobSchedulerId)
             rcall("HINCRBY", schedulerKey, "ic", 1)
             rcall("INCR", KEYS[8])
@@ -251,17 +295,22 @@ if prevMillis then
             if templateData and templateData ~= '{}' then
                 rcall("HSET", schedulerKey, "data", templateData)
             end
-            addJobFromScheduler(nextDelayedJobKey, nextDelayedJobId, ARGV[4], waitKey, pausedKey, 
-                KEYS[12], metaKey, prioritizedKey, KEYS[10], delayedKey, KEYS[7], eventsKey, 
-                schedulerAttributes[1], maxEvents, ARGV[5], templateData or '{}', jobSchedulerId)
+            local delay = nextMillis - now
+            -- Fast Clamp delay to minimum of 0
+            if delay < 0 then
+                delay = 0
+            end
+            jobOpts["delay"] = delay
+            addJobFromScheduler(nextDelayedJobKey, nextDelayedJobId, jobOpts, waitKey, pausedKey, KEYS[12], metaKey,
+                prioritizedKey, KEYS[10], delayedKey, KEYS[7], eventsKey, schedulerAttributes[1], maxEvents, ARGV[5],
+                templateData or '{}', jobSchedulerId, delay)
             -- TODO: remove this workaround in next breaking change
             if KEYS[11] ~= "" then
                 rcall("HSET", KEYS[11], "nrjid", nextDelayedJobId)
             end
             return nextDelayedJobId .. "" -- convert to string
         else
-            rcall("XADD", eventsKey, "MAXLEN", "~", maxEvents, "*", "event",
-                "duplicated", "jobId", nextDelayedJobId)
+            rcall("XADD", eventsKey, "MAXLEN", "~", maxEvents, "*", "event", "duplicated", "jobId", nextDelayedJobId)
         end
     end
 end

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

@@ -1 +1 @@
-{"version":3,"file":"updateJobScheduler-12.js","sourceRoot":"","sources":["../../../src/scripts/updateJobScheduler-12.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwQf,CAAC;AACW,QAAA,kBAAkB,GAAG;IAChC,IAAI,EAAE,oBAAoB;IAC1B,OAAO;IACP,IAAI,EAAE,EAAE;CACT,CAAC"}
+{"version":3,"file":"updateJobScheduler-12.js","sourceRoot":"","sources":["../../../src/scripts/updateJobScheduler-12.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyTf,CAAC;AACW,QAAA,kBAAkB,GAAG;IAChC,IAAI,EAAE,oBAAoB;IAC1B,OAAO;IACP,IAAI,EAAE,EAAE;CACT,CAAC"}