bullmq 5.0.0 → 5.1.1

package/dist/cjs/scripts/addParentJob-4.js

@@ -67,6 +67,13 @@ local function storeJob(eventsKey, jobIdKey, jobId, name, data, opts, timestamp,
     rcall("XADD", eventsKey, "*", "event", "added", "jobId", jobId, "name", name)
     return delay, priority
 end
+--[[
+    This function is used to update the parent's dependencies if the job
+    is already completed and about to be ignored. The parent must get its
+    dependencies updated to avoid the parent job being stuck forever in 
+    the waiting-children state.
+]]
+-- Includes
 --[[
   Validate and move or add dependencies to parent.
 ]]
@@ -81,7 +88,7 @@ end
 -- Includes
 --[[
   Function to return the next delayed job timestamp.
-]] 
+]]
 local function getNextDelayedTimestamp(delayedKey)
   local result = rcall("ZRANGE", delayedKey, 0, 0, "WITHSCORES")
   if #result then
@@ -174,12 +181,6 @@ local function updateParentDepsIfNeeded(parentKey, parentQueueKey, parentDepende
   rcall("HSET", processedSet, jobIdKey, returnvalue)
   moveParentToWaitIfNeeded(parentQueueKey, parentDependenciesKey, parentKey, parentId, timestamp)
 end
---[[
-    This function is used to update the parent's dependencies if the job
-    is already completed and about to be ignored. The parent must get its
-    dependencies updated to avoid the parent job being stuck forever in 
-    the waiting-children state.
-]]
 local function updateExistingJobsParent(parentKey, parent, parentData,
                                         parentDependenciesKey, completedKey,
                                         jobIdKey, jobId, timestamp)
@@ -197,6 +198,9 @@ local function updateExistingJobsParent(parentKey, parent, parentData,
         rcall("HMSET", jobIdKey, "parentKey", parentKey, "parent", parentData)
     end
 end
+--[[
+  Function to get max events value or set by default 10000.
+]]
 local function getOrSetMaxEvents(metaKey)
     local maxEvents = rcall("HGET", metaKey, "opts.maxLenEvents")
     if not maxEvents then

package/dist/cjs/scripts/addParentJob-4.js.map

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

package/dist/cjs/scripts/addPrioritizedJob-7.js

@@ -90,6 +90,13 @@ local function addJobWithPriority(markerKey, prioritizedKey, priority, jobId, pr
     rcall("ZADD", markerKey, 0, "0")
   end
 end
+--[[
+    This function is used to update the parent's dependencies if the job
+    is already completed and about to be ignored. The parent must get its
+    dependencies updated to avoid the parent job being stuck forever in 
+    the waiting-children state.
+]]
+-- Includes
 --[[
   Validate and move or add dependencies to parent.
 ]]
@@ -104,7 +111,7 @@ end
 -- Includes
 --[[
   Function to return the next delayed job timestamp.
-]] 
+]]
 local function getNextDelayedTimestamp(delayedKey)
   local result = rcall("ZRANGE", delayedKey, 0, 0, "WITHSCORES")
   if #result then
@@ -179,12 +186,6 @@ local function updateParentDepsIfNeeded(parentKey, parentQueueKey, parentDepende
   rcall("HSET", processedSet, jobIdKey, returnvalue)
   moveParentToWaitIfNeeded(parentQueueKey, parentDependenciesKey, parentKey, parentId, timestamp)
 end
---[[
-    This function is used to update the parent's dependencies if the job
-    is already completed and about to be ignored. The parent must get its
-    dependencies updated to avoid the parent job being stuck forever in 
-    the waiting-children state.
-]]
 local function updateExistingJobsParent(parentKey, parent, parentData,
                                         parentDependenciesKey, completedKey,
                                         jobIdKey, jobId, timestamp)
@@ -202,6 +203,9 @@ local function updateExistingJobsParent(parentKey, parent, parentData,
         rcall("HMSET", jobIdKey, "parentKey", parentKey, "parent", parentData)
     end
 end
+--[[
+  Function to get max events value or set by default 10000.
+]]
 local function getOrSetMaxEvents(metaKey)
     local maxEvents = rcall("HGET", metaKey, "opts.maxLenEvents")
     if not maxEvents then

package/dist/cjs/scripts/addPrioritizedJob-7.js.map

@@ -1 +1 @@
-{"version":3,"file":"addPrioritizedJob-7.js","sourceRoot":"","sources":["../../../src/scripts/addPrioritizedJob-7.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuPf,CAAC;AACW,QAAA,iBAAiB,GAAG;IAC/B,IAAI,EAAE,mBAAmB;IACzB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}
+{"version":3,"file":"addPrioritizedJob-7.js","sourceRoot":"","sources":["../../../src/scripts/addPrioritizedJob-7.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2Pf,CAAC;AACW,QAAA,iBAAiB,GAAG;IAC/B,IAAI,EAAE,mBAAmB;IACzB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

package/dist/cjs/scripts/addStandardJob-7.js

@@ -76,6 +76,13 @@ local function storeJob(eventsKey, jobIdKey, jobId, name, data, opts, timestamp,
     rcall("XADD", eventsKey, "*", "event", "added", "jobId", jobId, "name", name)
     return delay, priority
 end
+--[[
+    This function is used to update the parent's dependencies if the job
+    is already completed and about to be ignored. The parent must get its
+    dependencies updated to avoid the parent job being stuck forever in 
+    the waiting-children state.
+]]
+-- Includes
 --[[
   Validate and move or add dependencies to parent.
 ]]
@@ -90,7 +97,7 @@ end
 -- Includes
 --[[
   Function to return the next delayed job timestamp.
-]] 
+]]
 local function getNextDelayedTimestamp(delayedKey)
   local result = rcall("ZRANGE", delayedKey, 0, 0, "WITHSCORES")
   if #result then
@@ -183,12 +190,6 @@ local function updateParentDepsIfNeeded(parentKey, parentQueueKey, parentDepende
   rcall("HSET", processedSet, jobIdKey, returnvalue)
   moveParentToWaitIfNeeded(parentQueueKey, parentDependenciesKey, parentKey, parentId, timestamp)
 end
---[[
-    This function is used to update the parent's dependencies if the job
-    is already completed and about to be ignored. The parent must get its
-    dependencies updated to avoid the parent job being stuck forever in 
-    the waiting-children state.
-]]
 local function updateExistingJobsParent(parentKey, parent, parentData,
                                         parentDependenciesKey, completedKey,
                                         jobIdKey, jobId, timestamp)
@@ -206,6 +207,9 @@ local function updateExistingJobsParent(parentKey, parent, parentData,
         rcall("HMSET", jobIdKey, "parentKey", parentKey, "parent", parentData)
     end
 end
+--[[
+  Function to get max events value or set by default 10000.
+]]
 local function getOrSetMaxEvents(metaKey)
     local maxEvents = rcall("HGET", metaKey, "opts.maxLenEvents")
     if not maxEvents then

package/dist/cjs/scripts/addStandardJob-7.js.map

@@ -1 +1 @@
-{"version":3,"file":"addStandardJob-7.js","sourceRoot":"","sources":["../../../src/scripts/addStandardJob-7.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgQf,CAAC;AACW,QAAA,cAAc,GAAG;IAC5B,IAAI,EAAE,gBAAgB;IACtB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}
+{"version":3,"file":"addStandardJob-7.js","sourceRoot":"","sources":["../../../src/scripts/addStandardJob-7.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoQf,CAAC;AACW,QAAA,cAAc,GAAG;IAC5B,IAAI,EAAE,gBAAgB;IACtB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

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

@@ -200,10 +200,12 @@ local function batches(n, batchSize)
     end
   end
 end
--- We use ZRANGEBYSCORE to make the case where we're deleting a limited number
--- of items in a sorted set only run a single iteration. If we simply used
--- ZRANGE, we may take a long time traversing through jobs that are within the
--- grace period.
+--[[
+  We use ZRANGEBYSCORE to make the case where we're deleting a limited number
+  of items in a sorted set only run a single iteration. If we simply used
+  ZRANGE, we may take a long time traversing through jobs that are within the
+  grace period.
+]]
 local function getJobsInZset(zsetKey, rangeEnd, limit)
   if limit > 0 then
     return rcall("ZRANGEBYSCORE", zsetKey, 0, rangeEnd, "LIMIT", 0, limit)

package/dist/cjs/scripts/cleanJobsInSet-2.js.map

@@ -1 +1 @@
-{"version":3,"file":"cleanJobsInSet-2.js","sourceRoot":"","sources":["../../../src/scripts/cleanJobsInSet-2.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqQf,CAAC;AACW,QAAA,cAAc,GAAG;IAC5B,IAAI,EAAE,gBAAgB;IACtB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}
+{"version":3,"file":"cleanJobsInSet-2.js","sourceRoot":"","sources":["../../../src/scripts/cleanJobsInSet-2.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuQf,CAAC;AACW,QAAA,cAAc,GAAG;IAC5B,IAAI,EAAE,gBAAgB;IACtB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

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

@@ -38,6 +38,17 @@ local function batches(n, batchSize)
     end
   end
 end
+--[[
+  Function to get max events value or set by default 10000.
+]]
+local function getOrSetMaxEvents(metaKey)
+    local maxEvents = rcall("HGET", metaKey, "opts.maxLenEvents")
+    if not maxEvents then
+        maxEvents = 10000
+        rcall("HSET", metaKey, "opts.maxLenEvents", maxEvents)
+    end
+    return maxEvents
+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).
@@ -64,7 +75,7 @@ if (#jobs > 0) then
             rcall("HDEL", jobKey, "finishedOn", "processedOn", "returnvalue")
         end
     end
-    local maxEvents = rcall("HGET", metaKey, "opts.maxLenEvents") or 10000
+    local maxEvents = getOrSetMaxEvents(metaKey)
     for i, key in ipairs(jobs) do
         -- Emit waiting event
         rcall("XADD", KEYS[2], "MAXLEN", "~", maxEvents, "*", "event",

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

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

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

@@ -180,8 +180,20 @@ end
 --[[
   Function to trim events, default 10000.
 ]]
+-- Includes
+--[[
+  Function to get max events value or set by default 10000.
+]]
+local function getOrSetMaxEvents(metaKey)
+    local maxEvents = rcall("HGET", metaKey, "opts.maxLenEvents")
+    if not maxEvents then
+        maxEvents = 10000
+        rcall("HSET", metaKey, "opts.maxLenEvents", maxEvents)
+    end
+    return maxEvents
+end
 local function trimEvents(metaKey, eventStreamKey)
-  local maxEvents = rcall("HGET", metaKey, "opts.maxLenEvents")
+  local maxEvents = getOrSetMaxEvents(metaKey)
   if maxEvents ~= false then
     rcall("XTRIM", eventStreamKey, "MAXLEN", "~", maxEvents)
   else

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwRf,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoSf,CAAC;AACW,QAAA,qBAAqB,GAAG;IACnC,IAAI,EAAE,uBAAuB;IAC7B,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

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

@@ -39,7 +39,7 @@ local opts = cmsgpack.unpack(ARGV[3])
 -- Includes
 --[[
   Function to return the next delayed job timestamp.
-]] 
+]]
 local function getNextDelayedTimestamp(delayedKey)
   local result = rcall("ZRANGE", delayedKey, 0, 0, "WITHSCORES")
   if #result then
@@ -50,6 +50,9 @@ local function getNextDelayedTimestamp(delayedKey)
     return nextTimestamp
   end
 end
+--[[
+  Function to get current rate limit ttl.
+]]
 local function getRateLimitTTL(maxJobs, rateLimiterKey)
   if maxJobs and maxJobs <= tonumber(rcall("GET", rateLimiterKey) or 0) then
     local pttl = rcall("PTTL", rateLimiterKey)

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

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

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

@@ -33,7 +33,7 @@ local rcall = redis.call
 -- Includes
 --[[
   Function to return the next delayed job timestamp.
-]] 
+]]
 local function getNextDelayedTimestamp(delayedKey)
   local result = rcall("ZRANGE", delayedKey, 0, 0, "WITHSCORES")
   if #result then
@@ -52,6 +52,17 @@ local function addDelayMarkerIfNeeded(markerKey, delayedKey)
         rcall("ZADD", markerKey, nextTimestamp, "0")
     end
 end
+--[[
+  Function to get max events value or set by default 10000.
+]]
+local function getOrSetMaxEvents(metaKey)
+    local maxEvents = rcall("HGET", metaKey, "opts.maxLenEvents")
+    if not maxEvents then
+        maxEvents = 10000
+        rcall("HSET", metaKey, "opts.maxLenEvents", maxEvents)
+    end
+    return maxEvents
+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).
@@ -80,7 +91,7 @@ if rcall("EXISTS", jobKey) == 1 then
         rcall("HINCRBY", jobKey, "atm", 1)
     end
     rcall("HSET", jobKey, "delay", ARGV[6])
-    local maxEvents = rcall("HGET", metaKey, "opts.maxLenEvents") or 10000
+    local maxEvents = getOrSetMaxEvents(metaKey)
     rcall("ZADD", delayedKey, score, jobId)
     rcall("XADD", KEYS[6], "MAXLEN", "~", maxEvents, "*", "event", "delayed",
           "jobId", jobId, "delay", delayedTimestamp)

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

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

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

@@ -105,7 +105,7 @@ local function collectMetrics(metaKey, dataPointsList, maxDataPoints,
 end
 --[[
   Function to return the next delayed job timestamp.
-]] 
+]]
 local function getNextDelayedTimestamp(delayedKey)
   local result = rcall("ZRANGE", delayedKey, 0, 0, "WITHSCORES")
   if #result then
@@ -457,8 +457,20 @@ end
 --[[
   Function to trim events, default 10000.
 ]]
+-- Includes
+--[[
+  Function to get max events value or set by default 10000.
+]]
+local function getOrSetMaxEvents(metaKey)
+    local maxEvents = rcall("HGET", metaKey, "opts.maxLenEvents")
+    if not maxEvents then
+        maxEvents = 10000
+        rcall("HSET", metaKey, "opts.maxLenEvents", maxEvents)
+    end
+    return maxEvents
+end
 local function trimEvents(metaKey, eventStreamKey)
-  local maxEvents = rcall("HGET", metaKey, "opts.maxLenEvents")
+  local maxEvents = getOrSetMaxEvents(metaKey)
   if maxEvents ~= false then
     rcall("XTRIM", eventStreamKey, "MAXLEN", "~", maxEvents)
   else
@@ -475,6 +487,9 @@ local function updateParentDepsIfNeeded(parentKey, parentQueueKey, parentDepende
   rcall("HSET", processedSet, jobIdKey, returnvalue)
   moveParentToWaitIfNeeded(parentQueueKey, parentDependenciesKey, parentKey, parentId, timestamp)
 end
+--[[
+  Function to get current rate limit ttl.
+]]
 local function getRateLimitTTL(maxJobs, rateLimiterKey)
   if maxJobs and maxJobs <= tonumber(rcall("GET", rateLimiterKey) or 0) then
     local pttl = rcall("PTTL", rateLimiterKey)

package/dist/cjs/scripts/moveToFinished-14.js.map

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

package/dist/cjs/scripts/pause-7.js

@@ -23,7 +23,7 @@ local rcall = redis.call
 -- Includes
 --[[
   Function to return the next delayed job timestamp.
-]] 
+]]
 local function getNextDelayedTimestamp(delayedKey)
   local result = rcall("ZRANGE", delayedKey, 0, 0, "WITHSCORES")
   if #result then

package/dist/cjs/scripts/removeJob-1.js

@@ -23,6 +23,17 @@ end
 local getJobKeyPrefix = function (jobKey, jobId)
   return string.sub(jobKey, 0, #jobKey - #jobId)
 end
+--[[
+  Function to get max events value or set by default 10000.
+]]
+local function getOrSetMaxEvents(metaKey)
+    local maxEvents = rcall("HGET", metaKey, "opts.maxLenEvents")
+    if not maxEvents then
+        maxEvents = 10000
+        rcall("HSET", metaKey, "opts.maxLenEvents", maxEvents)
+    end
+    return maxEvents
+end
 --[[
   Function to recursively check if there are no locks
   on the jobs to be removed.
@@ -191,7 +202,7 @@ local function removeJob( prefix, jobId, parentKey, removeChildren)
     end
     local prev = removeJobFromAnyState(prefix, jobId)
     if rcall("DEL", jobKey, jobKey .. ":logs", jobKey .. ":dependencies", jobKey .. ":processed") > 0 then
-        local maxEvents = rcall("HGET", prefix .. "meta", "opts.maxLenEvents") or 10000
+        local maxEvents = getOrSetMaxEvents(prefix .. "meta")
         rcall("XADD", prefix .. "events", "MAXLEN", "~", maxEvents, "*", "event", "removed",
             "jobId", jobId, "prev", prev)
     end

package/dist/cjs/scripts/removeJob-1.js.map

@@ -1 +1 @@
-{"version":3,"file":"removeJob-1.js","sourceRoot":"","sources":["../../../src/scripts/removeJob-1.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyMf,CAAC;AACW,QAAA,SAAS,GAAG;IACvB,IAAI,EAAE,WAAW;IACjB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}
+{"version":3,"file":"removeJob-1.js","sourceRoot":"","sources":["../../../src/scripts/removeJob-1.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoNf,CAAC;AACW,QAAA,SAAS,GAAG;IACvB,IAAI,EAAE,WAAW;IACjB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

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

@@ -39,6 +39,17 @@ local function addJobWithPriority(markerKey, prioritizedKey, priority, jobId, pr
     rcall("ZADD", markerKey, 0, "0")
   end
 end
+--[[
+  Function to get max events value or set by default 10000.
+]]
+local function getOrSetMaxEvents(metaKey)
+    local maxEvents = rcall("HGET", metaKey, "opts.maxLenEvents")
+    if not maxEvents then
+        maxEvents = 10000
+        rcall("HSET", metaKey, "opts.maxLenEvents", maxEvents)
+    end
+    return maxEvents
+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).
@@ -107,7 +118,7 @@ if rcall("EXISTS", KEYS[4]) == 1 then
     addJobWithPriority(markerKey, KEYS[8], priority, ARGV[4], KEYS[9], paused)
   end
   rcall("HINCRBY", KEYS[4], "atm", 1)
-  local maxEvents = rcall("HGET", KEYS[5], "opts.maxLenEvents") or 10000
+  local maxEvents = getOrSetMaxEvents(KEYS[5])
   -- Emit waiting event
   rcall("XADD", KEYS[6], "MAXLEN", "~", maxEvents, "*", "event", "waiting",
     "jobId", ARGV[4], "prev", "failed")

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

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

package/dist/cjs/scripts/updateProgress-3.js

@@ -16,8 +16,20 @@ const content = `--[[
     progress(jobId, progress)
 ]]
 local rcall = redis.call
+-- Includes
+--[[
+  Function to get max events value or set by default 10000.
+]]
+local function getOrSetMaxEvents(metaKey)
+    local maxEvents = rcall("HGET", metaKey, "opts.maxLenEvents")
+    if not maxEvents then
+        maxEvents = 10000
+        rcall("HSET", metaKey, "opts.maxLenEvents", maxEvents)
+    end
+    return maxEvents
+end
 if rcall("EXISTS", KEYS[1]) == 1 then -- // Make sure job exists
-    local maxEvents = rcall("HGET", KEYS[3], "opts.maxLenEvents") or 10000
+    local maxEvents = getOrSetMaxEvents(KEYS[3])
     rcall("HSET", KEYS[1], "progress", ARGV[2])
     rcall("XADD", KEYS[2], "MAXLEN", "~", maxEvents, "*", "event", "progress",
           "jobId", ARGV[1], "data", ARGV[2]);

package/dist/cjs/scripts/updateProgress-3.js.map

@@ -1 +1 @@
-{"version":3,"file":"updateProgress-3.js","sourceRoot":"","sources":["../../../src/scripts/updateProgress-3.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;CAwBf,CAAC;AACW,QAAA,cAAc,GAAG;IAC5B,IAAI,EAAE,gBAAgB;IACtB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}
+{"version":3,"file":"updateProgress-3.js","sourceRoot":"","sources":["../../../src/scripts/updateProgress-3.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoCf,CAAC;AACW,QAAA,cAAc,GAAG;IAC5B,IAAI,EAAE,gBAAgB;IACtB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}