bullmq 5.49.2 → 5.51.0

package/dist/esm/commands/addJobScheduler-11.lua

@@ -58,55 +58,52 @@ local prefixKey = ARGV[8]
 local schedulerKey = repeatKey .. ":" .. jobSchedulerId
 local nextDelayedJobKey = schedulerKey .. ":" .. nextMillis
 local nextDelayedJobId = "repeat:" .. jobSchedulerId .. ":" .. nextMillis
-local prevMillis = rcall("ZSCORE", repeatKey, jobSchedulerId)
 
-if prevMillis ~= false then
-    local currentJobId = "repeat:" .. jobSchedulerId .. ":" .. prevMillis
-    local currentDelayedJobKey = schedulerKey .. ":" .. prevMillis
+local maxEvents = getOrSetMaxEvents(metaKey)
 
-    if rcall("EXISTS", nextDelayedJobKey) == 1 then
-        if rcall("ZSCORE", delayedKey, nextDelayedJobId) ~= false then
-            removeJob(nextDelayedJobId, true, prefixKey, true --[[remove debounce key]] )
-            rcall("ZREM", delayedKey, nextDelayedJobId)
-        elseif rcall("ZSCORE", prioritizedKey, nextDelayedJobId) ~= false then
-            removeJob(nextDelayedJobId, true, prefixKey, true --[[remove debounce key]] )
-            rcall("ZREM", prioritizedKey, nextDelayedJobId)
-        else
-            local pausedOrWaitKey = waitKey
-            if isQueuePaused(metaKey) then
-                pausedOrWaitKey = pausedKey
-            end
-
-            if rcall("LREM", pausedOrWaitKey, 1, nextDelayedJobId) > 0 then
-                removeJob(nextDelayedJobId, true, prefixKey, true --[[remove debounce key]] )
-            else
-                local maxEvents = getOrSetMaxEvents(metaKey)
-
-                rcall("XADD", eventsKey, "MAXLEN", "~", maxEvents, "*", "event",
-                    "duplicated", "jobId", nextDelayedJobId)
-
-                return nextDelayedJobId .. "" -- convert to string
-            end
+local function removeJobFromScheduler(prefixKey, delayedKey, prioritizedKey, waitKey, pausedKey, jobId,
+    metaKey, eventsKey)
+    if rcall("ZSCORE", delayedKey, jobId) then
+        removeJob(nextDelayedJobId, true, prefixKey, true --[[remove debounce key]] )
+        rcall("ZREM", delayedKey, jobId)
+        return true
+    elseif rcall("ZSCORE", prioritizedKey, jobId) then
+        removeJob(jobId, true, prefixKey, true --[[remove debounce key]] )
+        rcall("ZREM", prioritizedKey, jobId)
+        return true
+    else
+        local pausedOrWaitKey = waitKey
+        if isQueuePaused(metaKey) then
+            pausedOrWaitKey = pausedKey
         end
+
+        if rcall("LREM", pausedOrWaitKey, 1, jobId) > 0 then
+            removeJob(jobId, true, prefixKey, true --[[remove debounce key]] )
+            return true
+        end
+    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)
+
+if prevMillis then    
+    local currentJobId = "repeat:" .. jobSchedulerId .. ":" .. prevMillis
+    local currentDelayedJobKey = schedulerKey .. ":" .. prevMillis
+    
     if currentJobId ~= nextDelayedJobId and rcall("EXISTS", currentDelayedJobKey) == 1 then
-        if rcall("ZSCORE", delayedKey, currentJobId) ~= false then
-            removeJob(currentJobId, true, prefixKey, true --[[remove debounce key]] )
-            rcall("ZREM", delayedKey, currentJobId)
-        elseif rcall("ZSCORE", prioritizedKey, currentJobId) ~= false then
-            removeJob(currentJobId, true, prefixKey, true --[[remove debounce key]] )
-            rcall("ZREM", prioritizedKey, currentJobId)
-        else
-            local pausedOrWaitKey = waitKey
-            if isQueuePaused(metaKey) then
-                pausedOrWaitKey = pausedKey
-            end
-
-            if rcall("LREM", pausedOrWaitKey, 1, currentJobId) > 0 then
-                removeJob(currentJobId, true, prefixKey, true --[[remove debounce key]] )
-            end
-        end
+        removeJobFromScheduler(prefixKey, delayedKey, prioritizedKey, waitKey, pausedKey,
+            currentJobId, metaKey, eventsKey)
     end
 end
 
@@ -115,8 +112,6 @@ storeJobScheduler(jobSchedulerId, schedulerKey, repeatKey, nextMillis, scheduler
 
 rcall("INCR", KEYS[8])
 
-local maxEvents = getOrSetMaxEvents(metaKey)
-
 addJobFromScheduler(nextDelayedJobKey, nextDelayedJobId, ARGV[6], waitKey, pausedKey,
     KEYS[11], metaKey, prioritizedKey, KEYS[10], delayedKey, KEYS[7], eventsKey,
     schedulerOpts['name'], maxEvents, ARGV[7], ARGV[4], jobSchedulerId)

package/dist/esm/commands/includes/moveChildFromDependenciesIfNeeded.lua

@@ -6,7 +6,6 @@
 --- @include "moveParentToWaitIfNoPendingDependencies"
 --- @include "moveParentToWaitIfNeeded"
 --- @include "moveParentToWait"
---- @include "removeDeduplicationKeyIfNeeded"
 --- @include "removeJobsOnFail"
 
 local moveParentToFailedIfNeeded

package/dist/esm/commands/includes/removeDeduplicationKeyIfNeededOnFinalization.lua

@@ -0,0 +1,23 @@
+--[[
+  Function to remove deduplication key if needed
+  when a job is moved to completed or failed states.
+]]
+
+local function removeDeduplicationKeyIfNeededOnFinalization(prefixKey,
+  deduplicationId, jobId)
+  if deduplicationId then
+    local deduplicationKey = prefixKey .. "de:" .. deduplicationId
+    local pttl = rcall("PTTL", deduplicationKey)
+
+    if pttl == 0 then
+      return rcall("DEL", deduplicationKey)
+    end
+
+    if pttl == -1 then
+      local currentJobId = rcall('GET', deduplicationKey)
+      if currentJobId and currentJobId == jobId then
+        return rcall("DEL", deduplicationKey)
+      end
+    end
+  end
+end

package/dist/esm/commands/includes/removeDeduplicationKeyIfNeededOnRemoval.lua

@@ -0,0 +1,16 @@
+--[[
+  Function to remove deduplication key if needed
+  when a job is being removed.
+]]
+
+local function removeDeduplicationKeyIfNeededOnRemoval(prefixKey,
+  jobKey, jobId)
+  local deduplicationId = rcall("HGET", jobKey, "deid")
+  if deduplicationId then
+    local deduplicationKey = prefixKey .. "de:" .. deduplicationId
+    local currentJobId = rcall('GET', deduplicationKey)
+    if currentJobId and currentJobId == jobId then
+      return rcall("DEL", deduplicationKey)
+    end
+  end
+end

package/dist/esm/commands/includes/removeJob.lua

@@ -3,7 +3,7 @@
 ]]
 
 -- Includes
---- @include "removeDeduplicationKey"
+--- @include "removeDeduplicationKeyIfNeededOnRemoval"
 --- @include "removeJobKeys"
 --- @include "removeParentDependencyKey"
 
@@ -11,7 +11,7 @@ local function removeJob(jobId, hard, baseKey, shouldRemoveDeduplicationKey)
   local jobKey = baseKey .. jobId
   removeParentDependencyKey(jobKey, hard, nil, baseKey)
   if shouldRemoveDeduplicationKey then
-    removeDeduplicationKey(baseKey, jobKey)
+    removeDeduplicationKeyIfNeededOnRemoval(baseKey, jobKey, jobId)
   end
   removeJobKeys(jobKey)
 end

package/dist/esm/commands/includes/removeJobWithChildren.lua

@@ -12,7 +12,7 @@ local rcall = redis.call
 --- @include "destructureJobKey"
 --- @include "getOrSetMaxEvents"
 --- @include "isJobSchedulerJob"
---- @include "removeDeduplicationKey"
+--- @include "removeDeduplicationKeyIfNeededOnRemoval"
 --- @include "removeJobFromAnyState"
 --- @include "removeJobKeys"
 --- @include "removeParentDependencyKey"
@@ -84,7 +84,7 @@ removeJobWithChildren = function(prefix, meta, jobId, parentKey, options)
         end
 
         local prev = removeJobFromAnyState(prefix, jobId)
-        removeDeduplicationKey(prefix, jobKey)
+        removeDeduplicationKeyIfNeededOnRemoval(prefix, jobKey, jobId)
         if removeJobKeys(jobKey) > 0 then
             local maxEvents = getOrSetMaxEvents(meta)
             rcall("XADD", prefix .. "events", "MAXLEN", "~", maxEvents, "*", "event", "removed",

package/dist/esm/commands/includes/storeJob.lua

@@ -16,7 +16,7 @@ local function storeJob(eventsKey, jobIdKey, jobId, name, data, opts, timestamp,
         table.insert(optionalValues, parentData)
     end
 
-    if repeatJobKey ~= nil then
+    if repeatJobKey then
         table.insert(optionalValues, "rjk")
         table.insert(optionalValues, repeatJobKey)
     end

package/dist/esm/commands/moveStalledJobsToWait-9.lua

@@ -27,7 +27,7 @@ local rcall = redis.call
 --- @include "includes/batches"
 --- @include "includes/getTargetQueueList"
 --- @include "includes/moveChildFromDependenciesIfNeeded"
---- @include "includes/removeDeduplicationKeyIfNeeded"
+--- @include "includes/removeDeduplicationKeyIfNeededOnFinalization"
 --- @include "includes/removeJobsOnFail"
 --- @include "includes/trimEvents"
 
@@ -84,7 +84,7 @@ if (#stalling > 0) then
                         local rawParentData = jobAttributes[2]
                         local opts = cjson.decode(rawOpts)
                         rcall("ZADD", failedKey, timestamp, jobId)
-                        removeDeduplicationKeyIfNeeded(queueKeyPrefix, jobAttributes[3])
+                        removeDeduplicationKeyIfNeededOnFinalization(queueKeyPrefix, jobAttributes[3], jobId)
 
                         local failedReason = "job stalled more than allowable limit"
                         rcall("HMSET", jobKey, "failedReason", failedReason, "finishedOn", timestamp)

package/dist/esm/commands/moveToFinished-14.lua

@@ -67,7 +67,7 @@ local rcall = redis.call
 --- @include "includes/moveChildFromDependenciesIfNeeded"
 --- @include "includes/prepareJobForProcessing"
 --- @include "includes/promoteDelayedJobs"
---- @include "includes/removeDeduplicationKeyIfNeeded"
+--- @include "includes/removeDeduplicationKeyIfNeededOnFinalization"
 --- @include "includes/removeJobKeys"
 --- @include "includes/removeJobsByMaxAge"
 --- @include "includes/removeJobsByMaxCount"
@@ -130,7 +130,7 @@ if rcall("EXISTS", jobIdKey) == 1 then -- Make sure job exists
 
     local prefix = ARGV[7]
 
-    removeDeduplicationKeyIfNeeded(prefix, jobAttributes[3])
+    removeDeduplicationKeyIfNeededOnFinalization(prefix, jobAttributes[3], jobId)
 
     -- If job has a parent we need to
     -- 1) remove this job id from parents dependencies

package/dist/esm/commands/moveToWaitingChildren-8.lua

@@ -37,7 +37,7 @@ local jobId = ARGV[4]
 
 --- Includes
 --- @include "includes/moveChildFromDependenciesIfNeeded"
---- @include "includes/removeDeduplicationKeyIfNeeded"
+--- @include "includes/removeDeduplicationKeyIfNeededOnFinalization"
 --- @include "includes/removeJobsOnFail"
 --- @include "includes/removeLock"
 
@@ -61,7 +61,7 @@ if rcall("EXISTS", jobKey) == 1 then
     -- TODO: refactor this logic in an include later
     local jobAttributes = rcall("HMGET", jobKey, "parent", "deid", "opts")
 
-    removeDeduplicationKeyIfNeeded(ARGV[5], jobAttributes[2])
+    removeDeduplicationKeyIfNeededOnFinalization(ARGV[5], jobAttributes[2], jobId)
   
     local failedReason = "children are failed"
     rcall("ZADD", failedKey, timestamp, jobId)

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

@@ -49,7 +49,7 @@ local nextDelayedJobKey = schedulerKey .. ":" .. nextMillis
 
 -- Validate that scheduler exists.
 local prevMillis = rcall("ZSCORE", repeatKey, jobSchedulerId)
-if prevMillis ~= false then
+if prevMillis then
     local currentDelayedJobId = "repeat:" .. jobSchedulerId .. ":" .. prevMillis
 
     if producerId == currentDelayedJobId then

package/dist/esm/interfaces/minimal-job.d.ts

@@ -15,15 +15,29 @@ export interface MoveToWaitingChildrenOpts {
         queue: string;
     };
 }
+export interface DependencyOpts {
+    /**
+     * Cursor value to be passed for pagination
+     */
+    cursor?: number;
+    /**
+     * Max quantity of jobs to be retrieved
+     */
+    count?: number;
+}
 export interface DependenciesOpts {
-    processed?: {
-        cursor?: number;
-        count?: number;
-    };
-    unprocessed?: {
-        cursor?: number;
-        count?: number;
-    };
+    /**
+     * Options for ignored child pagination
+     */
+    ignored?: DependencyOpts;
+    /**
+     * Options for processed child pagination
+     */
+    processed?: DependencyOpts;
+    /**
+     * Options for unprocessed child pagination
+     */
+    unprocessed?: DependencyOpts;
 }
 /**
  * MinimalJob

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

@@ -345,7 +345,7 @@ local function storeJob(eventsKey, jobIdKey, jobId, name, data, opts, timestamp,
         table.insert(optionalValues, "parent")
         table.insert(optionalValues, parentData)
     end
-    if repeatJobKey ~= nil then
+    if repeatJobKey then
         table.insert(optionalValues, "rjk")
         table.insert(optionalValues, repeatJobKey)
     end

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

@@ -158,7 +158,7 @@ local function storeJob(eventsKey, jobIdKey, jobId, name, data, opts, timestamp,
         table.insert(optionalValues, "parent")
         table.insert(optionalValues, parentData)
     end
-    if repeatJobKey ~= nil then
+    if repeatJobKey then
         table.insert(optionalValues, "rjk")
         table.insert(optionalValues, repeatJobKey)
     end
@@ -238,13 +238,18 @@ end
 ]]
 -- Includes
 --[[
-  Function to remove deduplication key.
+  Function to remove deduplication key if needed
+  when a job is being removed.
 ]]
-local function removeDeduplicationKey(prefixKey, jobKey)
+local function removeDeduplicationKeyIfNeededOnRemoval(prefixKey,
+  jobKey, jobId)
   local deduplicationId = rcall("HGET", jobKey, "deid")
   if deduplicationId then
     local deduplicationKey = prefixKey .. "de:" .. deduplicationId
-    rcall("DEL", deduplicationKey)
+    local currentJobId = rcall('GET', deduplicationKey)
+    if currentJobId and currentJobId == jobId then
+      return rcall("DEL", deduplicationKey)
+    end
   end
 end
 --[[
@@ -346,7 +351,7 @@ local function removeJob(jobId, hard, baseKey, shouldRemoveDeduplicationKey)
   local jobKey = baseKey .. jobId
   removeParentDependencyKey(jobKey, hard, nil, baseKey)
   if shouldRemoveDeduplicationKey then
-    removeDeduplicationKey(baseKey, jobKey)
+    removeDeduplicationKeyIfNeededOnRemoval(baseKey, jobKey, jobId)
   end
   removeJobKeys(jobKey)
 end
@@ -393,54 +398,49 @@ end
 local schedulerKey = repeatKey .. ":" .. jobSchedulerId
 local nextDelayedJobKey = schedulerKey .. ":" .. nextMillis
 local nextDelayedJobId = "repeat:" .. jobSchedulerId .. ":" .. nextMillis
+local maxEvents = getOrSetMaxEvents(metaKey)
+local function removeJobFromScheduler(prefixKey, delayedKey, prioritizedKey, waitKey, pausedKey, jobId,
+    metaKey, eventsKey)
+    if rcall("ZSCORE", delayedKey, jobId) then
+        removeJob(nextDelayedJobId, true, prefixKey, true --[[remove debounce key]] )
+        rcall("ZREM", delayedKey, jobId)
+        return true
+    elseif rcall("ZSCORE", prioritizedKey, jobId) then
+        removeJob(jobId, true, prefixKey, true --[[remove debounce key]] )
+        rcall("ZREM", prioritizedKey, jobId)
+        return true
+    else
+        local pausedOrWaitKey = waitKey
+        if isQueuePaused(metaKey) then
+            pausedOrWaitKey = pausedKey
+        end
+        if rcall("LREM", pausedOrWaitKey, 1, jobId) > 0 then
+            removeJob(jobId, true, prefixKey, true --[[remove debounce key]] )
+            return true
+        end
+    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)
-if prevMillis ~= false then
+if prevMillis then    
     local currentJobId = "repeat:" .. jobSchedulerId .. ":" .. prevMillis
     local currentDelayedJobKey = schedulerKey .. ":" .. prevMillis
-    if rcall("EXISTS", nextDelayedJobKey) == 1 then
-        if rcall("ZSCORE", delayedKey, nextDelayedJobId) ~= false then
-            removeJob(nextDelayedJobId, true, prefixKey, true --[[remove debounce key]] )
-            rcall("ZREM", delayedKey, nextDelayedJobId)
-        elseif rcall("ZSCORE", prioritizedKey, nextDelayedJobId) ~= false then
-            removeJob(nextDelayedJobId, true, prefixKey, true --[[remove debounce key]] )
-            rcall("ZREM", prioritizedKey, nextDelayedJobId)
-        else
-            local pausedOrWaitKey = waitKey
-            if isQueuePaused(metaKey) then
-                pausedOrWaitKey = pausedKey
-            end
-            if rcall("LREM", pausedOrWaitKey, 1, nextDelayedJobId) > 0 then
-                removeJob(nextDelayedJobId, true, prefixKey, true --[[remove debounce key]] )
-            else
-                local maxEvents = getOrSetMaxEvents(metaKey)
-                rcall("XADD", eventsKey, "MAXLEN", "~", maxEvents, "*", "event",
-                    "duplicated", "jobId", nextDelayedJobId)
-                return nextDelayedJobId .. "" -- convert to string
-            end
-        end
-    end
     if currentJobId ~= nextDelayedJobId and rcall("EXISTS", currentDelayedJobKey) == 1 then
-        if rcall("ZSCORE", delayedKey, currentJobId) ~= false then
-            removeJob(currentJobId, true, prefixKey, true --[[remove debounce key]] )
-            rcall("ZREM", delayedKey, currentJobId)
-        elseif rcall("ZSCORE", prioritizedKey, currentJobId) ~= false then
-            removeJob(currentJobId, true, prefixKey, true --[[remove debounce key]] )
-            rcall("ZREM", prioritizedKey, currentJobId)
-        else
-            local pausedOrWaitKey = waitKey
-            if isQueuePaused(metaKey) then
-                pausedOrWaitKey = pausedKey
-            end
-            if rcall("LREM", pausedOrWaitKey, 1, currentJobId) > 0 then
-                removeJob(currentJobId, true, prefixKey, true --[[remove debounce key]] )
-            end
-        end
+        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)
 rcall("INCR", KEYS[8])
-local maxEvents = getOrSetMaxEvents(metaKey)
 addJobFromScheduler(nextDelayedJobKey, nextDelayedJobId, ARGV[6], waitKey, pausedKey,
     KEYS[11], metaKey, prioritizedKey, KEYS[10], delayedKey, KEYS[7], eventsKey,
     schedulerOpts['name'], maxEvents, ARGV[7], ARGV[4], jobSchedulerId)

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

@@ -301,7 +301,7 @@ local function storeJob(eventsKey, jobIdKey, jobId, name, data, opts, timestamp,
         table.insert(optionalValues, "parent")
         table.insert(optionalValues, parentData)
     end
-    if repeatJobKey ~= nil then
+    if repeatJobKey then
         table.insert(optionalValues, "rjk")
         table.insert(optionalValues, repeatJobKey)
     end

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

@@ -112,7 +112,7 @@ local function storeJob(eventsKey, jobIdKey, jobId, name, data, opts, timestamp,
         table.insert(optionalValues, "parent")
         table.insert(optionalValues, parentData)
     end
-    if repeatJobKey ~= nil then
+    if repeatJobKey then
         table.insert(optionalValues, "rjk")
         table.insert(optionalValues, repeatJobKey)
     end

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

@@ -29,13 +29,18 @@ local prefixKey = ARGV[5]
 ]]
 -- Includes
 --[[
-  Function to remove deduplication key.
+  Function to remove deduplication key if needed
+  when a job is being removed.
 ]]
-local function removeDeduplicationKey(prefixKey, jobKey)
+local function removeDeduplicationKeyIfNeededOnRemoval(prefixKey,
+  jobKey, jobId)
   local deduplicationId = rcall("HGET", jobKey, "deid")
   if deduplicationId then
     local deduplicationKey = prefixKey .. "de:" .. deduplicationId
-    rcall("DEL", deduplicationKey)
+    local currentJobId = rcall('GET', deduplicationKey)
+    if currentJobId and currentJobId == jobId then
+      return rcall("DEL", deduplicationKey)
+    end
   end
 end
 --[[
@@ -173,7 +178,7 @@ local function removeJob(jobId, hard, baseKey, shouldRemoveDeduplicationKey)
   local jobKey = baseKey .. jobId
   removeParentDependencyKey(jobKey, hard, nil, baseKey)
   if shouldRemoveDeduplicationKey then
-    removeDeduplicationKey(baseKey, jobKey)
+    removeDeduplicationKeyIfNeededOnRemoval(baseKey, jobKey, jobId)
   end
   removeJobKeys(jobKey)
 end

package/dist/esm/scripts/addRepeatableJob-2.js.map

@@ -1 +1 @@
-{"version":3,"file":"addRepeatableJob-2.js","sourceRoot":"","sources":["../../../src/scripts/addRepeatableJob-2.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4Nf,CAAC;AACF,MAAM,CAAC,MAAM,gBAAgB,GAAG;IAC9B,IAAI,EAAE,kBAAkB;IACxB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}
+{"version":3,"file":"addRepeatableJob-2.js","sourceRoot":"","sources":["../../../src/scripts/addRepeatableJob-2.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiOf,CAAC;AACF,MAAM,CAAC,MAAM,gBAAgB,GAAG;IAC9B,IAAI,EAAE,kBAAkB;IACxB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

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

@@ -311,7 +311,7 @@ local function storeJob(eventsKey, jobIdKey, jobId, name, data, opts, timestamp,
         table.insert(optionalValues, "parent")
         table.insert(optionalValues, parentData)
     end
-    if repeatJobKey ~= nil then
+    if repeatJobKey then
         table.insert(optionalValues, "rjk")
         table.insert(optionalValues, repeatJobKey)
     end

package/dist/esm/scripts/cleanJobsInSet-3.js

@@ -65,13 +65,18 @@ end
 ]]
 -- Includes
 --[[
-  Function to remove deduplication key.
+  Function to remove deduplication key if needed
+  when a job is being removed.
 ]]
-local function removeDeduplicationKey(prefixKey, jobKey)
+local function removeDeduplicationKeyIfNeededOnRemoval(prefixKey,
+  jobKey, jobId)
   local deduplicationId = rcall("HGET", jobKey, "deid")
   if deduplicationId then
     local deduplicationKey = prefixKey .. "de:" .. deduplicationId
-    rcall("DEL", deduplicationKey)
+    local currentJobId = rcall('GET', deduplicationKey)
+    if currentJobId and currentJobId == jobId then
+      return rcall("DEL", deduplicationKey)
+    end
   end
 end
 --[[
@@ -209,7 +214,7 @@ local function removeJob(jobId, hard, baseKey, shouldRemoveDeduplicationKey)
   local jobKey = baseKey .. jobId
   removeParentDependencyKey(jobKey, hard, nil, baseKey)
   if shouldRemoveDeduplicationKey then
-    removeDeduplicationKey(baseKey, jobKey)
+    removeDeduplicationKeyIfNeededOnRemoval(baseKey, jobKey, jobId)
   end
   removeJobKeys(jobKey)
 end

package/dist/esm/scripts/cleanJobsInSet-3.js.map

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

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

@@ -37,13 +37,18 @@ end
 ]]
 -- Includes
 --[[
-  Function to remove deduplication key.
+  Function to remove deduplication key if needed
+  when a job is being removed.
 ]]
-local function removeDeduplicationKey(prefixKey, jobKey)
+local function removeDeduplicationKeyIfNeededOnRemoval(prefixKey,
+  jobKey, jobId)
   local deduplicationId = rcall("HGET", jobKey, "deid")
   if deduplicationId then
     local deduplicationKey = prefixKey .. "de:" .. deduplicationId
-    rcall("DEL", deduplicationKey)
+    local currentJobId = rcall('GET', deduplicationKey)
+    if currentJobId and currentJobId == jobId then
+      return rcall("DEL", deduplicationKey)
+    end
   end
 end
 --[[
@@ -181,7 +186,7 @@ local function removeJob(jobId, hard, baseKey, shouldRemoveDeduplicationKey)
   local jobKey = baseKey .. jobId
   removeParentDependencyKey(jobKey, hard, nil, baseKey)
   if shouldRemoveDeduplicationKey then
-    removeDeduplicationKey(baseKey, jobKey)
+    removeDeduplicationKeyIfNeededOnRemoval(baseKey, jobKey, jobId)
   end
   removeJobKeys(jobKey)
 end

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

@@ -1 +1 @@
-{"version":3,"file":"drain-5.js","sourceRoot":"","sources":["../../../src/scripts/drain-5.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiQf,CAAC;AACF,MAAM,CAAC,MAAM,KAAK,GAAG;IACnB,IAAI,EAAE,OAAO;IACb,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}
+{"version":3,"file":"drain-5.js","sourceRoot":"","sources":["../../../src/scripts/drain-5.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsQf,CAAC;AACF,MAAM,CAAC,MAAM,KAAK,GAAG;IACnB,IAAI,EAAE,OAAO;IACb,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}