bullmq 2.1.3 → 2.2.1

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

@@ -0,0 +1,264 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanJobsInSet = void 0;
+const content = `--[[
+  Remove jobs from the specific set.
+  Input:
+    KEYS[1]  set key,
+    KEYS[2]  events stream key
+    ARGV[1]  jobKey prefix
+    ARGV[2]  timestamp
+    ARGV[3]  limit the number of jobs to be removed. 0 is unlimited
+    ARGV[4]  set name, can be any of 'wait', 'active', 'paused', 'delayed', 'completed', or 'failed'
+]]
+local rcall = redis.call
+local rangeStart = 0
+local rangeEnd = -1
+local limit = tonumber(ARGV[3])
+-- If we're only deleting _n_ items, avoid retrieving all items
+-- for faster performance
+--
+-- Start from the tail of the list, since that's where oldest elements
+-- are generally added for FIFO lists
+if limit > 0 then
+  rangeStart = -1 - limit + 1
+  rangeEnd = -1
+end
+-- Includes
+--[[
+  Function to clean job list.
+  Returns jobIds and deleted count number.
+]]
+-- Includes
+--[[
+  Function to get the latest saved timestamp.
+]]
+local function getTimestamp(jobKey, attributes)
+  if #attributes == 1 then
+    return rcall("HGET", jobKey, attributes[1])
+  end
+  local jobTs
+  for _, ts in ipairs(rcall("HMGET", jobKey, unpack(attributes))) do
+    if (ts) then
+      jobTs = ts
+      break
+    end
+  end
+  return jobTs
+end
+--[[
+  Function to remove job.
+]]
+-- Includes
+--[[
+  Check if this job has a parent. If so we will just remove it from
+  the parent child list, but if it is the last child we should move the parent to "wait/paused"
+  which requires code from "moveToFinished"
+]]
+--[[
+  Functions to destructure job key.
+  Just a bit of warning, these functions may be a bit slow and affect performance significantly.
+]]
+local getJobIdFromKey = function (jobKey)
+  return string.match(jobKey, ".*:(.*)")
+end
+local getJobKeyPrefix = function (jobKey, jobId)
+  return string.sub(jobKey, 0, #jobKey - #jobId)
+end
+--[[
+  Function to check for the meta.paused key to decide if we are paused or not
+  (since an empty list and !EXISTS are not really the same).
+]]
+local function getTargetQueueList(queueMetaKey, waitKey, pausedKey)
+  if rcall("HEXISTS", queueMetaKey, "paused") ~= 1 then
+    return waitKey
+  else
+    return pausedKey
+  end
+end
+local function moveParentToWait(parentPrefix, parentId, emitEvent)
+  local parentTarget = getTargetQueueList(parentPrefix .. "meta", parentPrefix .. "wait", parentPrefix .. "paused")
+  rcall("RPUSH", parentTarget, parentId)
+  if emitEvent then
+    local parentEventStream = parentPrefix .. "events"
+    rcall("XADD", parentEventStream, "*", "event", "waiting", "jobId", parentId, "prev", "waiting-children")
+  end
+end
+local function removeParentDependencyKey(jobKey, hard, parentKey, baseKey)
+  if parentKey then
+    local parentProcessedKey = parentKey .. ":processed"
+    rcall("HDEL", parentProcessedKey, jobKey)
+    local parentDependenciesKey = parentKey .. ":dependencies"
+    local result = rcall("SREM", parentDependenciesKey, jobKey)
+    if result > 0 then
+      local pendingDependencies = rcall("SCARD", parentDependenciesKey)
+      if pendingDependencies == 0 then
+        local parentId = getJobIdFromKey(parentKey)
+        local parentPrefix = getJobKeyPrefix(parentKey, parentId)
+        local numRemovedElements = rcall("ZREM", parentPrefix .. "waiting-children", parentId)
+        if numRemovedElements == 1 then
+          if hard then
+            if parentPrefix == baseKey then
+              removeParentDependencyKey(parentKey, hard, nil, baseKey)
+              rcall("DEL", parentKey, parentKey .. ':logs',
+                parentKey .. ':dependencies', parentKey .. ':processed')
+            else
+              moveParentToWait(parentPrefix, parentId)
+            end
+          else
+            moveParentToWait(parentPrefix, parentId, true)
+          end
+        end
+      end
+    end
+  else
+    local missedParentKey = rcall("HGET", jobKey, "parentKey")
+    if( (type(missedParentKey) == "string") and missedParentKey ~= "" and (rcall("EXISTS", missedParentKey) == 1)) then
+      local parentProcessedKey = missedParentKey .. ":processed"
+      rcall("HDEL", parentProcessedKey, jobKey)
+      local parentDependenciesKey = missedParentKey .. ":dependencies"
+      local result = rcall("SREM", parentDependenciesKey, jobKey)
+      if result > 0 then
+        local pendingDependencies = rcall("SCARD", parentDependenciesKey)
+        if pendingDependencies == 0 then
+          local parentId = getJobIdFromKey(missedParentKey)
+          local parentPrefix = getJobKeyPrefix(missedParentKey, parentId)
+          local numRemovedElements = rcall("ZREM", parentPrefix .. "waiting-children", parentId)
+          if numRemovedElements == 1 then
+            if hard then
+              if parentPrefix == baseKey then
+                removeParentDependencyKey(missedParentKey, hard, nil, baseKey)
+                rcall("DEL", missedParentKey, missedParentKey .. ':logs',
+                  missedParentKey .. ':dependencies', missedParentKey .. ':processed')
+              else
+                moveParentToWait(parentPrefix, parentId)
+              end
+            else
+              moveParentToWait(parentPrefix, parentId, true)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+local function removeJob(jobId, hard, baseKey)
+  local jobKey = baseKey .. jobId
+  removeParentDependencyKey(jobKey, hard, nil, baseKey)
+  rcall("DEL", jobKey, jobKey .. ':logs',
+    jobKey .. ':dependencies', jobKey .. ':processed')
+end
+local function cleanList(listKey, jobKeyPrefix, rangeStart, rangeEnd,
+  timestamp, isWaiting)
+  local jobs = rcall("LRANGE", listKey, rangeStart, rangeEnd)
+  local deleted = {}
+  local deletedCount = 0
+  local jobTS
+  local deletionMarker = ''
+  local jobIdsLen = #jobs
+  for i, job in ipairs(jobs) do
+    if limit > 0 and deletedCount >= limit then
+      break
+    end
+    local jobKey = jobKeyPrefix .. job
+    if (isWaiting or rcall("EXISTS", jobKey .. ":lock") == 0) then
+      -- Find the right timestamp of the job to compare to maxTimestamp:
+      -- * finishedOn says when the job was completed, but it isn't set unless the job has actually completed
+      -- * processedOn represents when the job was last attempted, but it doesn't get populated until
+      --   the job is first tried
+      -- * timestamp is the original job submission time
+      -- Fetch all three of these (in that order) and use the first one that is set so that we'll leave jobs
+      -- that have been active within the grace period:
+      jobTS = getTimestamp(jobKey, {"finishedOn", "processedOn", "timestamp"})
+      if (not jobTS or jobTS < timestamp) then
+        -- replace the entry with a deletion marker; the actual deletion will
+        -- occur at the end of the script
+        rcall("LSET", listKey, rangeEnd - jobIdsLen + i, deletionMarker)
+        removeJob(job, true, jobKeyPrefix)
+        if isWaiting then
+          rcall("ZREM", jobKeyPrefix .. "priority", job)
+        end
+        deletedCount = deletedCount + 1
+        table.insert(deleted, job)
+      end
+    end
+  end
+  rcall("LREM", listKey, 0, deletionMarker)
+  return {deleted, deletedCount}
+end
+--[[
+  Function to clean job set.
+  Returns jobIds and deleted count number.
+]]
+-- Includes
+--[[
+  Function to loop in batches.
+  Just a bit of warning, some commands as ZREM
+  could receive a maximum of 7000 parameters per call.
+]]
+local function batches(n, batchSize)
+  local i = 0
+  return function()
+    local from = i * batchSize + 1
+    i = i + 1
+    if (from <= n) then
+      local to = math.min(from + batchSize - 1, n)
+      return from, to
+    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.
+local function getJobs(setKey, rangeStart, rangeEnd, maxTimestamp, limit)
+  if limit > 0 then
+    return rcall("ZRANGEBYSCORE", setKey, 0, maxTimestamp, "LIMIT", 0, limit)
+  else
+    return rcall("ZRANGE", setKey, rangeStart, rangeEnd)
+  end
+end
+local function cleanSet(setKey, jobKeyPrefix, rangeStart, rangeEnd, timestamp, limit, attributes)
+  local jobs = getJobs(setKey, rangeStart, rangeEnd, timestamp, limit)
+  local deleted = {}
+  local deletedCount = 0
+  local jobTS
+  for i, job in ipairs(jobs) do
+    if limit > 0 and deletedCount >= limit then
+      break
+    end
+    local jobKey = jobKeyPrefix .. job
+    -- * finishedOn says when the job was completed, but it isn't set unless the job has actually completed
+    jobTS = getTimestamp(jobKey, attributes)
+    if (not jobTS or jobTS < timestamp) then
+      removeJob(job, true, jobKeyPrefix)
+      deletedCount = deletedCount + 1
+      table.insert(deleted, job)
+    end
+  end
+  if(#deleted > 0) then
+    for from, to in batches(#deleted, 7000) do
+      rcall("ZREM", setKey, unpack(deleted, from, to))
+    end
+  end
+  return {deleted, deletedCount}
+end
+local result
+if ARGV[4] == "active" then
+  result = cleanList(KEYS[1], ARGV[1], rangeStart, rangeEnd, ARGV[2], false)
+elseif ARGV[4] == "delayed" then
+  result = cleanSet(KEYS[1], ARGV[1], rangeStart, rangeEnd, ARGV[2], limit, {"processedOn", "timestamp"})
+elseif ARGV[4] == "wait" or ARGV[4] == "paused" then
+  result = cleanList(KEYS[1], ARGV[1], rangeStart, rangeEnd, ARGV[2], true)
+else
+  result = cleanSet(KEYS[1], ARGV[1], rangeStart, rangeEnd, ARGV[2], limit, {"finishedOn"} )
+end
+rcall("XADD", KEYS[2], "*", "event", "cleaned", "count", result[2])
+return result[1]
+`;
+exports.cleanJobsInSet = {
+    name: 'cleanJobsInSet',
+    content,
+    keys: 2,
+};
+//# sourceMappingURL=cleanJobsInSet-2.js.map

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

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

package/dist/cjs/scripts/drain-4.d.ts

@@ -0,0 +1,5 @@
+export declare const drain: {
+    name: string;
+    content: string;
+    keys: number;
+};

package/dist/cjs/{commands/includes/removeParentDependencyKey.lua → scripts/drain-4.js}

@@ -1,22 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.drain = void 0;
+const content = `--[[
+  Drains the queue, removes all jobs that are waiting
+  or delayed, but not active, completed or failed
+  Input:
+    KEYS[1] 'wait',
+    KEYS[2] 'paused'
+    KEYS[3] 'delayed'
+    KEYS[4] 'priority'
+    ARGV[1]  queue key prefix
+]]
+local rcall = redis.call
+local queueBaseKey = ARGV[1]
+--[[
+  Functions to remove jobs.
+]]
+-- Includes
+--[[
+  Function to loop in batches.
+  Just a bit of warning, some commands as ZREM
+  could receive a maximum of 7000 parameters per call.
+]]
+local function batches(n, batchSize)
+  local i = 0
+  return function()
+    local from = i * batchSize + 1
+    i = i + 1
+    if (from <= n) then
+      local to = math.min(from + batchSize - 1, n)
+      return from, to
+    end
+  end
+end
+local function getListItems(keyName, max)
+  return rcall('LRANGE', keyName, 0, max - 1)
+end
+--[[
+  Function to get ZSet items.
+]]
+local function getZSetItems(keyName, max)
+  return rcall('ZRANGE', keyName, 0, max - 1)
+end
+--[[
+  Function to remove job.
+]]
+-- Includes
 --[[
   Check if this job has a parent. If so we will just remove it from
   the parent child list, but if it is the last child we should move the parent to "wait/paused"
   which requires code from "moveToFinished"
 ]]
-
---- @include "destructureJobKey"
---- @include "getTargetQueueList"
-
+--[[
+  Functions to destructure job key.
+  Just a bit of warning, these functions may be a bit slow and affect performance significantly.
+]]
+local getJobIdFromKey = function (jobKey)
+  return string.match(jobKey, ".*:(.*)")
+end
+local getJobKeyPrefix = function (jobKey, jobId)
+  return string.sub(jobKey, 0, #jobKey - #jobId)
+end
+--[[
+  Function to check for the meta.paused key to decide if we are paused or not
+  (since an empty list and !EXISTS are not really the same).
+]]
+local function getTargetQueueList(queueMetaKey, waitKey, pausedKey)
+  if rcall("HEXISTS", queueMetaKey, "paused") ~= 1 then
+    return waitKey
+  else
+    return pausedKey
+  end
+end
 local function moveParentToWait(parentPrefix, parentId, emitEvent)
   local parentTarget = getTargetQueueList(parentPrefix .. "meta", parentPrefix .. "wait", parentPrefix .. "paused")
   rcall("RPUSH", parentTarget, parentId)
-
   if emitEvent then
     local parentEventStream = parentPrefix .. "events"
     rcall("XADD", parentEventStream, "*", "event", "waiting", "jobId", parentId, "prev", "waiting-children")
   end
 end
-
 local function removeParentDependencyKey(jobKey, hard, parentKey, baseKey)
   if parentKey then
     local parentProcessedKey = parentKey .. ":processed"
@@ -28,9 +91,7 @@ local function removeParentDependencyKey(jobKey, hard, parentKey, baseKey)
       if pendingDependencies == 0 then
         local parentId = getJobIdFromKey(parentKey)
         local parentPrefix = getJobKeyPrefix(parentKey, parentId)
-
         local numRemovedElements = rcall("ZREM", parentPrefix .. "waiting-children", parentId)
-
         if numRemovedElements == 1 then
           if hard then
             if parentPrefix == baseKey then
@@ -58,9 +119,7 @@ local function removeParentDependencyKey(jobKey, hard, parentKey, baseKey)
         if pendingDependencies == 0 then
           local parentId = getJobIdFromKey(missedParentKey)
           local parentPrefix = getJobKeyPrefix(missedParentKey, parentId)
-
           local numRemovedElements = rcall("ZREM", parentPrefix .. "waiting-children", parentId)
-
           if numRemovedElements == 1 then
             if hard then
               if parentPrefix == baseKey then
@@ -79,3 +138,44 @@ local function removeParentDependencyKey(jobKey, hard, parentKey, baseKey)
     end
   end
 end
+local function removeJob(jobId, hard, baseKey)
+  local jobKey = baseKey .. jobId
+  removeParentDependencyKey(jobKey, hard, nil, baseKey)
+  rcall("DEL", jobKey, jobKey .. ':logs',
+    jobKey .. ':dependencies', jobKey .. ':processed')
+end
+local function removeJobs(keys, hard, baseKey, max)
+  for i, key in ipairs(keys) do
+    removeJob(key, hard, baseKey)
+  end
+  return max - #keys
+end
+local function removeListJobs(keyName, hard, baseKey, max)
+  local jobs = getListItems(keyName, max)
+  local count = removeJobs(jobs, hard, baseKey, max)
+  rcall("LTRIM", keyName, #jobs, -1)
+  return count
+end
+local function removeZSetJobs(keyName, hard, baseKey, max)
+  local jobs = getZSetItems(keyName, max)
+  local count = removeJobs(jobs, hard, baseKey, max)
+  if(#jobs > 0) then
+    for from, to in batches(#jobs, 7000) do
+      rcall("ZREM", keyName, unpack(jobs))
+    end
+  end
+  return count
+end
+removeListJobs(KEYS[1], true, queueBaseKey, 0) --wait
+removeListJobs(KEYS[2], true, queueBaseKey, 0) --paused
+if KEYS[3] ~= "" then
+  removeZSetJobs(KEYS[3], true, queueBaseKey, 0) --delayed
+end
+rcall("DEL", KEYS[4])
+`;
+exports.drain = {
+    name: 'drain',
+    content,
+    keys: 4,
+};
+//# sourceMappingURL=drain-4.js.map

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

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

package/dist/cjs/scripts/extendLock-2.d.ts

@@ -0,0 +1,5 @@
+export declare const extendLock: {
+    name: string;
+    content: string;
+    keys: number;
+};

package/dist/{esm/commands/extendLock-2.lua → cjs/scripts/extendLock-2.js}

@@ -1,14 +1,14 @@
---[[
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendLock = void 0;
+const content = `--[[
   Extend lock and removes the job from the stalled set.
-
   Input:
     KEYS[1] 'lock',
     KEYS[2] 'stalled'
-
     ARGV[1]  token
     ARGV[2]  lock duration in milliseconds
     ARGV[3]  jobid
-
   Output:
     "1" if lock extented succesfully.
 ]]
@@ -21,3 +21,10 @@ if rcall("GET", KEYS[1]) == ARGV[1] then
   end
 end
 return 0
+`;
+exports.extendLock = {
+    name: 'extendLock',
+    content,
+    keys: 2,
+};
+//# sourceMappingURL=extendLock-2.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"extendLock-2.js","sourceRoot":"","sources":["../../../src/scripts/extendLock-2.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;CAoBf,CAAC;AACW,QAAA,UAAU,GAAG;IACxB,IAAI,EAAE,YAAY;IAClB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

package/dist/cjs/scripts/getState-7.d.ts

@@ -0,0 +1,5 @@
+export declare const getState: {
+    name: string;
+    content: string;
+    keys: number;
+};

package/dist/{esm/commands/getState-7.lua → cjs/scripts/getState-7.js}

@@ -1,6 +1,8 @@
---[[
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getState = void 0;
+const content = `--[[
   Get a job state
-
   Input: 
     KEYS[1] 'completed' key,
     KEYS[2] 'failed' key
@@ -9,7 +11,6 @@
     KEYS[5] 'wait' key
     KEYS[6] 'paused' key
     KEYS[7] waitChildrenKey key
-
     ARGV[1] job id
   Output:
     'completed'
@@ -23,35 +24,44 @@
 if redis.call("ZSCORE", KEYS[1], ARGV[1]) ~= false then
   return "completed"
 end
-
 if redis.call("ZSCORE", KEYS[2], ARGV[1]) ~= false then
   return "failed"
 end
-
 if redis.call("ZSCORE", KEYS[3], ARGV[1]) ~= false then
   return "delayed"
 end
-
 -- Includes
---- @include "includes/checkItemInList"
-
+--[[
+  Functions to check if a item belongs to a list.
+]]
+local function checkItemInList(list, item)
+  for _, v in pairs(list) do
+    if v == item then
+      return 1
+    end
+  end
+  return nil
+end
 local active_items = redis.call("LRANGE", KEYS[4] , 0, -1)
 if checkItemInList(active_items, ARGV[1]) ~= nil then
   return "active"
 end
-
 local wait_items = redis.call("LRANGE", KEYS[5] , 0, -1)
 if checkItemInList(wait_items, ARGV[1]) ~= nil then
   return "waiting"
 end
-
 local paused_items = redis.call("LRANGE", KEYS[6] , 0, -1)
 if checkItemInList(paused_items, ARGV[1]) ~= nil then
   return "waiting"
 end
-
 if redis.call("ZSCORE", KEYS[7], ARGV[1]) ~= false then
   return "waiting-children"
 end
-
 return "unknown"
+`;
+exports.getState = {
+    name: 'getState',
+    content,
+    keys: 7,
+};
+//# sourceMappingURL=getState-7.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getState-7.js","sourceRoot":"","sources":["../../../src/scripts/getState-7.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyDf,CAAC;AACW,QAAA,QAAQ,GAAG;IACtB,IAAI,EAAE,UAAU;IAChB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

package/dist/cjs/scripts/getStateV2-7.d.ts

@@ -0,0 +1,5 @@
+export declare const getStateV2: {
+    name: string;
+    content: string;
+    keys: number;
+};

package/dist/cjs/{commands/getStateV2-7.lua → scripts/getStateV2-7.js}

@@ -1,6 +1,8 @@
---[[
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStateV2 = void 0;
+const content = `--[[
   Get a job state
-
   Input: 
     KEYS[1] 'completed' key,
     KEYS[2] 'failed' key
@@ -9,7 +11,6 @@
     KEYS[5] 'wait' key
     KEYS[6] 'paused' key
     KEYS[7] waitChildrenKey key
-
     ARGV[1] job id
   Output:
     'completed'
@@ -23,29 +24,29 @@
 if redis.call("ZSCORE", KEYS[1], ARGV[1]) ~= false then
   return "completed"
 end
-
 if redis.call("ZSCORE", KEYS[2], ARGV[1]) ~= false then
   return "failed"
 end
-
 if redis.call("ZSCORE", KEYS[3], ARGV[1]) ~= false then
   return "delayed"
 end
-
 if redis.call("LPOS", KEYS[4] , ARGV[1]) ~= false then
   return "active"
 end
-
 if redis.call("LPOS", KEYS[5] , ARGV[1]) ~= false then
   return "waiting"
 end
-
 if redis.call("LPOS", KEYS[6] , ARGV[1]) ~= false then
   return "waiting"
 end
-
 if redis.call("ZSCORE", KEYS[7] , ARGV[1]) ~= false then
   return "waiting-children"
 end
-
 return "unknown"
+`;
+exports.getStateV2 = {
+    name: 'getStateV2',
+    content,
+    keys: 7,
+};
+//# sourceMappingURL=getStateV2-7.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getStateV2-7.js","sourceRoot":"","sources":["../../../src/scripts/getStateV2-7.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0Cf,CAAC;AACW,QAAA,UAAU,GAAG;IACxB,IAAI,EAAE,YAAY;IAClB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

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

@@ -0,0 +1,26 @@
+export * from './addJob-8';
+export * from './changeDelay-4';
+export * from './cleanJobsInSet-2';
+export * from './drain-4';
+export * from './extendLock-2';
+export * from './getState-7';
+export * from './getStateV2-7';
+export * from './isFinished-3';
+export * from './isJobInList-1';
+export * from './moveStalledJobsToWait-8';
+export * from './moveToActive-9';
+export * from './moveToDelayed-5';
+export * from './moveToFinished-12';
+export * from './moveToWaitingChildren-4';
+export * from './obliterate-2';
+export * from './pause-4';
+export * from './promote-6';
+export * from './releaseLock-1';
+export * from './removeJob-1';
+export * from './removeRepeatable-2';
+export * from './reprocessJob-4';
+export * from './retryJob-6';
+export * from './retryJobs-6';
+export * from './takeLock-1';
+export * from './updateData-1';
+export * from './updateProgress-2';

package/dist/cjs/scripts/index.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./addJob-8"), exports);
+tslib_1.__exportStar(require("./changeDelay-4"), exports);
+tslib_1.__exportStar(require("./cleanJobsInSet-2"), exports);
+tslib_1.__exportStar(require("./drain-4"), exports);
+tslib_1.__exportStar(require("./extendLock-2"), exports);
+tslib_1.__exportStar(require("./getState-7"), exports);
+tslib_1.__exportStar(require("./getStateV2-7"), exports);
+tslib_1.__exportStar(require("./isFinished-3"), exports);
+tslib_1.__exportStar(require("./isJobInList-1"), exports);
+tslib_1.__exportStar(require("./moveStalledJobsToWait-8"), exports);
+tslib_1.__exportStar(require("./moveToActive-9"), exports);
+tslib_1.__exportStar(require("./moveToDelayed-5"), exports);
+tslib_1.__exportStar(require("./moveToFinished-12"), exports);
+tslib_1.__exportStar(require("./moveToWaitingChildren-4"), exports);
+tslib_1.__exportStar(require("./obliterate-2"), exports);
+tslib_1.__exportStar(require("./pause-4"), exports);
+tslib_1.__exportStar(require("./promote-6"), exports);
+tslib_1.__exportStar(require("./releaseLock-1"), exports);
+tslib_1.__exportStar(require("./removeJob-1"), exports);
+tslib_1.__exportStar(require("./removeRepeatable-2"), exports);
+tslib_1.__exportStar(require("./reprocessJob-4"), exports);
+tslib_1.__exportStar(require("./retryJob-6"), exports);
+tslib_1.__exportStar(require("./retryJobs-6"), exports);
+tslib_1.__exportStar(require("./takeLock-1"), exports);
+tslib_1.__exportStar(require("./updateData-1"), exports);
+tslib_1.__exportStar(require("./updateProgress-2"), exports);
+//# sourceMappingURL=index.js.map

package/dist/cjs/scripts/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/scripts/index.ts"],"names":[],"mappings":";;;AAAA,qDAA2B;AAC3B,0DAAgC;AAChC,6DAAmC;AACnC,oDAA0B;AAC1B,yDAA+B;AAC/B,uDAA6B;AAC7B,yDAA+B;AAC/B,yDAA+B;AAC/B,0DAAgC;AAChC,oEAA0C;AAC1C,2DAAiC;AACjC,4DAAkC;AAClC,8DAAoC;AACpC,oEAA0C;AAC1C,yDAA+B;AAC/B,oDAA0B;AAC1B,sDAA4B;AAC5B,0DAAgC;AAChC,wDAA8B;AAC9B,+DAAqC;AACrC,2DAAiC;AACjC,uDAA6B;AAC7B,wDAA8B;AAC9B,uDAA6B;AAC7B,yDAA+B;AAC/B,6DAAmC"}