bullmq 3.5.4 → 3.5.6

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

@@ -28,9 +28,10 @@
 local rcall = redis.call
 
 -- Includes
---- @include "includes/promoteDelayedJobs"
+--- @include "includes/addDelayMarkerIfNeeded"
 --- @include "includes/getTargetQueueList"
 --- @include "includes/getNextDelayedTimestamp"
+--- @include "includes/promoteDelayedJobs"
 
 local jobKey = KEYS[5]
 if rcall("EXISTS", jobKey) == 1 then
@@ -54,17 +55,13 @@ if rcall("EXISTS", jobKey) == 1 then
       return -3
     end
 
+    rcall("ZADD", delayedKey, score, jobId)
+    rcall("XADD", KEYS[6], "*", "event", "delayed", "jobId", jobId, "delay", delayedTimestamp)
+
     -- Check if we need to push a marker job to wake up sleeping workers.
     local target = getTargetQueueList(KEYS[8], KEYS[1], KEYS[7])
-    if rcall("LLEN", target) == 0 then
-        local nextTimestamp = getNextDelayedTimestamp(delayedKey)
-        if not nextTimestamp or (delayedTimestamp < nextTimestamp) then
-            rcall("LPUSH", target, "0:" .. delayedTimestamp - tonumber(ARGV[2]))
-        end
-    end
+    addDelayMarkerIfNeeded(target, delayedKey)
 
-    rcall("ZADD", delayedKey, score, jobId)
-    rcall("XADD", KEYS[6], "*", "event", "delayed", "jobId", jobId, "delay", delayedTimestamp)
     return 0
 else
     return -1

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

@@ -10,6 +10,7 @@ export * from './job-json';
 export * from './keep-jobs';
 export * from './metrics-options';
 export * from './metrics';
+export * from './minimal-job';
 export * from './parent-command';
 export * from './parent-message';
 export * from './parent';

package/dist/cjs/interfaces/index.js

@@ -13,6 +13,7 @@ tslib_1.__exportStar(require("./job-json"), exports);
 tslib_1.__exportStar(require("./keep-jobs"), exports);
 tslib_1.__exportStar(require("./metrics-options"), exports);
 tslib_1.__exportStar(require("./metrics"), exports);
+tslib_1.__exportStar(require("./minimal-job"), exports);
 tslib_1.__exportStar(require("./parent-command"), exports);
 tslib_1.__exportStar(require("./parent-message"), exports);
 tslib_1.__exportStar(require("./parent"), exports);

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

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/interfaces/index.ts"],"names":[],"mappings":";;;AAAA,6DAAmC;AACnC,4DAAkC;AAClC,6DAAmC;AACnC,0DAAgC;AAChC,0DAAgC;AAChC,uDAA6B;AAC7B,qDAA2B;AAC3B,2DAAiC;AACjC,qDAA2B;AAC3B,sDAA4B;AAC5B,4DAAkC;AAClC,oDAA0B;AAC1B,2DAAiC;AACjC,2DAAiC;AACjC,mDAAyB;AACzB,0DAAgC;AAChC,iEAAuC;AACvC,0DAAgC;AAChC,0DAAgC;AAChC,2DAAiC;AACjC,oEAA0C;AAC1C,0DAAgC;AAChC,2DAAiC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/interfaces/index.ts"],"names":[],"mappings":";;;AAAA,6DAAmC;AACnC,4DAAkC;AAClC,6DAAmC;AACnC,0DAAgC;AAChC,0DAAgC;AAChC,uDAA6B;AAC7B,qDAA2B;AAC3B,2DAAiC;AACjC,qDAA2B;AAC3B,sDAA4B;AAC5B,4DAAkC;AAClC,oDAA0B;AAC1B,wDAA8B;AAC9B,2DAAiC;AACjC,2DAAiC;AACjC,mDAAyB;AACzB,0DAAgC;AAChC,iEAAuC;AACvC,0DAAgC;AAChC,0DAAgC;AAChC,2DAAiC;AACjC,oEAA0C;AAC1C,0DAAgC;AAChC,2DAAiC"}

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

@@ -0,0 +1,129 @@
+import { JobsOptions, JobJsonSandbox } from '../types';
+import { JobJson } from './job-json';
+import { ParentKeys } from './parent';
+export type BulkJobOptions = Omit<JobsOptions, 'repeat'>;
+export interface MoveToWaitingChildrenOpts {
+    child?: {
+        id: string;
+        queue: string;
+    };
+}
+export interface DependenciesOpts {
+    processed?: {
+        cursor?: number;
+        count?: number;
+    };
+    unprocessed?: {
+        cursor?: number;
+        count?: number;
+    };
+}
+/**
+ * MinimalJob
+ */
+export interface MinimalJob<DataType = any, ReturnType = any, NameType extends string = string> {
+    /**
+     * The name of the Job
+     */
+    name: NameType;
+    /**
+     * The payload for this job.
+     */
+    data: DataType;
+    /**
+     * The options object for this job.
+     */
+    opts: JobsOptions;
+    id?: string;
+    /**
+     * The progress a job has performed so far.
+     * @defaultValue 0
+     */
+    progress: number | object;
+    /**
+     * The value returned by the processor when processing this job.
+     * @defaultValue null
+     */
+    returnvalue: ReturnType;
+    /**
+     * Stacktrace for the error (for failed jobs).
+     * @defaultValue null
+     */
+    stacktrace: string[];
+    /**
+     * An amount of milliseconds to wait until this job can be processed.
+     * @defaultValue 0
+     */
+    delay: number;
+    /**
+     * Timestamp when the job was created (unless overridden with job options).
+     */
+    timestamp: number;
+    /**
+     * Number of attempts after the job has failed.
+     * @defaultValue 0
+     */
+    attemptsMade: number;
+    /**
+     * Reason for failing.
+     */
+    failedReason: string;
+    /**
+     * Timestamp for when the job finished (completed or failed).
+     */
+    finishedOn?: number;
+    /**
+     * Timestamp for when the job was processed.
+     */
+    processedOn?: number;
+    /**
+     * Fully qualified key (including the queue prefix) pointing to the parent of this job.
+     */
+    parentKey?: string;
+    /**
+     * Object that contains parentId (id) and parent queueKey.
+     */
+    parent?: ParentKeys;
+    /**
+     * Base repeat job key.
+     */
+    repeatJobKey?: string;
+    /**
+     * Prepares a job to be serialized for storage in Redis.
+     * @returns
+     */
+    asJSON(): JobJson;
+    /**
+     * Prepares a job to be passed to Sandbox.
+     * @returns
+     */
+    asJSONSandbox(): JobJsonSandbox;
+    /**
+     * Updates a job's data
+     *
+     * @param data - the data that will replace the current jobs data.
+     */
+    update(data: DataType): Promise<void>;
+    /**
+     * Updates a job's progress
+     *
+     * @param progress - number or object to be saved as progress.
+     */
+    updateProgress(progress: number | object): Promise<void>;
+    /**
+     * Logs one row of log data.
+     *
+     * @param logRow - string with log data to be logged.
+     */
+    log(logRow: string): Promise<number>;
+    get queueName(): string;
+    /**
+     * @returns the prefix that is used.
+     */
+    get prefix(): string;
+    /**
+     * @returns it includes the prefix, the namespace separator :, and queue name.
+     * @see https://www.gnu.org/software/gawk/manual/html_node/Qualified-Names.html
+     */
+    get queueQualifiedName(): string;
+}

package/dist/cjs/interfaces/minimal-job.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=minimal-job.js.map

package/dist/cjs/interfaces/minimal-job.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"minimal-job.js","sourceRoot":"","sources":["../../../src/interfaces/minimal-job.ts"],"names":[],"mappings":""}

package/dist/cjs/interfaces/parent.d.ts

@@ -13,3 +13,8 @@ export interface ParentKeys {
     id: string;
     queueKey: string;
 }
+export type ParentOpts = {
+    waitChildrenKey?: string;
+    parentDependenciesKey?: string;
+    parentKey?: string;
+};

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

@@ -51,6 +51,31 @@ local repeatJobKey = args[9]
 local parent = args[8]
 local parentData
 -- Includes
+--[[
+  Add delay marker if needed.
+]]
+-- Includes
+--[[
+  Function to return the next delayed job timestamp.
+]] 
+local function getNextDelayedTimestamp(delayedKey)
+  local result = rcall("ZRANGE", delayedKey, 0, 0, "WITHSCORES")
+  if #result then
+    local nextTimestamp = tonumber(result[2])
+    if (nextTimestamp ~= nil) then 
+      nextTimestamp = nextTimestamp / 0x1000
+    end
+    return nextTimestamp
+  end
+end
+local function addDelayMarkerIfNeeded(target, delayedKey)
+  if rcall("LLEN", target) == 0 then
+    local nextTimestamp = getNextDelayedTimestamp(delayedKey)
+    if nextTimestamp ~= nil then
+      rcall("LPUSH", target, "0:" .. nextTimestamp)
+    end
+  end
+end
 --[[
   Function to add job considering priority.
 ]]
@@ -87,19 +112,6 @@ local function trimEvents(metaKey, eventStreamKey)
     rcall("XTRIM", eventStreamKey, "MAXLEN", "~", 10000)
   end
 end
---[[
-  Function to return the next delayed job timestamp.
-]] 
-local function getNextDelayedTimestamp(delayedKey)
-  local result = rcall("ZRANGE", delayedKey, 0, 0, "WITHSCORES")
-  if #result then
-    local nextTimestamp = tonumber(result[2])
-    if (nextTimestamp ~= nil) then 
-      nextTimestamp = nextTimestamp / 0x1000
-    end
-    return nextTimestamp
-  end
-end
 --[[
   Validate and move or add dependencies to parent.
 ]]
@@ -121,12 +133,7 @@ local function updateParentDepsIfNeeded(parentKey, parentQueueKey, parentDepende
       local score = delayedTimestamp * 0x1000
       local parentDelayedKey = parentQueueKey .. ":delayed" 
       rcall("ZADD", parentDelayedKey, score, parentId)
-      if rcall("LLEN", parentTarget) == 0 then
-        local nextTimestamp = getNextDelayedTimestamp(parentDelayedKey)
-        if not nextTimestamp or (delayedTimestamp <= nextTimestamp) then
-          rcall("LPUSH", parentTarget, "0:" .. delayedTimestamp - tonumber(timestamp))
-        end
-      end
+      addDelayMarkerIfNeeded(parentTarget, parentDelayedKey)
     -- Standard or priority add
     elseif priority == 0 then
       rcall("RPUSH", parentTarget, parentId)
@@ -203,13 +210,7 @@ elseif (delayedTimestamp ~= 0) then
   -- If wait list is empty, and this delayed job is the next one to be processed,
   -- then we need to signal the workers by adding a dummy job (jobId 0:delay) to the wait list.
   local target = getTargetQueueList(KEYS[3], KEYS[1], KEYS[2])
-  if rcall("LLEN", target) == 0 then
-    local nextTimestamp = getNextDelayedTimestamp(KEYS[5])
-    if not nextTimestamp or (delayedTimestamp < nextTimestamp) then
-      local delay = delayedTimestamp - tonumber(timestamp)
-      rcall("LPUSH", target, "0:" .. delay)
-    end
-  end
+  addDelayMarkerIfNeeded(target, KEYS[5])
 else
   local target = getTargetQueueList(KEYS[3], KEYS[1], KEYS[2])
   -- Standard or priority add

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

@@ -1 +1 @@
-{"version":3,"file":"addJob-8.js","sourceRoot":"","sources":["../../../src/scripts/addJob-8.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsOf,CAAC;AACW,QAAA,MAAM,GAAG;IACpB,IAAI,EAAE,QAAQ;IACd,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}
+{"version":3,"file":"addJob-8.js","sourceRoot":"","sources":["../../../src/scripts/addJob-8.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuOf,CAAC;AACW,QAAA,MAAM,GAAG;IACpB,IAAI,EAAE,QAAQ;IACd,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

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

@@ -199,7 +199,7 @@ end
 -- Return the timestamp for the next delayed job if any.
 local nextTimestamp = getNextDelayedTimestamp(KEYS[7])
 if (nextTimestamp ~= nil) then
-    return { 0, 0, 0, nextTimestamp - tonumber(ARGV[2])}
+  return { 0, 0, 0, nextTimestamp}
 end
 `;
 exports.moveToActive = {

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

@@ -26,6 +26,42 @@ const content = `--[[
 ]]
 local rcall = redis.call
 -- Includes
+--[[
+  Add delay marker if needed.
+]]
+-- Includes
+--[[
+  Function to return the next delayed job timestamp.
+]] 
+local function getNextDelayedTimestamp(delayedKey)
+  local result = rcall("ZRANGE", delayedKey, 0, 0, "WITHSCORES")
+  if #result then
+    local nextTimestamp = tonumber(result[2])
+    if (nextTimestamp ~= nil) then 
+      nextTimestamp = nextTimestamp / 0x1000
+    end
+    return nextTimestamp
+  end
+end
+local function addDelayMarkerIfNeeded(target, delayedKey)
+  if rcall("LLEN", target) == 0 then
+    local nextTimestamp = getNextDelayedTimestamp(delayedKey)
+    if nextTimestamp ~= nil then
+      rcall("LPUSH", target, "0:" .. nextTimestamp)
+    end
+  end
+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
 --[[
   Updates the delay set, by moving delayed jobs that should
   be processed now to "wait".
@@ -48,17 +84,6 @@ local function addJobWithPriority(priorityKey, priority, targetKey, jobId)
     rcall("RPUSH", targetKey, jobId)
   end
 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
 -- Try to get as much as 1000 jobs at once
 local function promoteDelayedJobs(delayedKey, waitKey, priorityKey, pausedKey,
                                   metaKey, eventStreamKey, prefix, timestamp)
@@ -83,19 +108,6 @@ local function promoteDelayedJobs(delayedKey, waitKey, priorityKey, pausedKey,
         end
     end
 end
---[[
-  Function to return the next delayed job timestamp.
-]] 
-local function getNextDelayedTimestamp(delayedKey)
-  local result = rcall("ZRANGE", delayedKey, 0, 0, "WITHSCORES")
-  if #result then
-    local nextTimestamp = tonumber(result[2])
-    if (nextTimestamp ~= nil) then 
-      nextTimestamp = nextTimestamp / 0x1000
-    end
-    return nextTimestamp
-  end
-end
 local jobKey = KEYS[5]
 if rcall("EXISTS", jobKey) == 1 then
     local delayedKey = KEYS[4]
@@ -114,16 +126,11 @@ if rcall("EXISTS", jobKey) == 1 then
     if (numRemovedElements < 1) then 
       return -3
     end
-    -- Check if we need to push a marker job to wake up sleeping workers.
-    local target = getTargetQueueList(KEYS[8], KEYS[1], KEYS[7])
-    if rcall("LLEN", target) == 0 then
-        local nextTimestamp = getNextDelayedTimestamp(delayedKey)
-        if not nextTimestamp or (delayedTimestamp < nextTimestamp) then
-            rcall("LPUSH", target, "0:" .. delayedTimestamp - tonumber(ARGV[2]))
-        end
-    end
     rcall("ZADD", delayedKey, score, jobId)
     rcall("XADD", KEYS[6], "*", "event", "delayed", "jobId", jobId, "delay", delayedTimestamp)
+    -- Check if we need to push a marker job to wake up sleeping workers.
+    local target = getTargetQueueList(KEYS[8], KEYS[1], KEYS[7])
+    addDelayMarkerIfNeeded(target, delayedKey)
     return 0
 else
     return -1

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

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

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

@@ -379,6 +379,18 @@ end
   Validate and move or add dependencies to parent.
 ]]
 -- Includes
+--[[
+  Add delay marker if needed.
+]]
+-- Includes
+local function addDelayMarkerIfNeeded(target, delayedKey)
+  if rcall("LLEN", target) == 0 then
+    local nextTimestamp = getNextDelayedTimestamp(delayedKey)
+    if nextTimestamp ~= nil then
+      rcall("LPUSH", target, "0:" .. nextTimestamp)
+    end
+  end
+end
 local function updateParentDepsIfNeeded(parentKey, parentQueueKey, parentDependenciesKey,
   parentId, jobIdKey, returnvalue, timestamp )
   local processedSet = parentKey .. ":processed"
@@ -396,12 +408,7 @@ local function updateParentDepsIfNeeded(parentKey, parentQueueKey, parentDepende
       local score = delayedTimestamp * 0x1000
       local parentDelayedKey = parentQueueKey .. ":delayed" 
       rcall("ZADD", parentDelayedKey, score, parentId)
-      if rcall("LLEN", parentTarget) == 0 then
-        local nextTimestamp = getNextDelayedTimestamp(parentDelayedKey)
-        if not nextTimestamp or (delayedTimestamp <= nextTimestamp) then
-          rcall("LPUSH", parentTarget, "0:" .. delayedTimestamp - tonumber(timestamp))
-        end
-      end
+      addDelayMarkerIfNeeded(parentTarget, parentDelayedKey)
     -- Standard or priority add
     elseif priority == 0 then
       rcall("RPUSH", parentTarget, parentId)

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

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

package/dist/cjs/types/backoff-strategy.d.ts

@@ -1,2 +1,2 @@
-import { Job } from '../classes/job';
-export type BackoffStrategy = (attemptsMade?: number, type?: string, err?: Error, job?: Job) => Promise<number> | number;
+import { MinimalJob } from '../interfaces/minimal-job';
+export type BackoffStrategy = (attemptsMade?: number, type?: string, err?: Error, job?: MinimalJob) => Promise<number> | number;

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

@@ -1,5 +1,6 @@
 export * from './backoff-strategy';
 export * from './finished-status';
+export * from './minimal-queue';
 export * from './job-json-sandbox';
 export * from './job-options';
 export * from './job-type';

package/dist/cjs/types/index.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./backoff-strategy"), exports);
 tslib_1.__exportStar(require("./finished-status"), exports);
+tslib_1.__exportStar(require("./minimal-queue"), exports);
 tslib_1.__exportStar(require("./job-json-sandbox"), exports);
 tslib_1.__exportStar(require("./job-options"), exports);
 tslib_1.__exportStar(require("./job-type"), exports);

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

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/types/index.ts"],"names":[],"mappings":";;;AAAA,6DAAmC;AACnC,4DAAkC;AAClC,6DAAmC;AACnC,wDAA8B;AAC9B,qDAA2B;AAC3B,4DAAkC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/types/index.ts"],"names":[],"mappings":";;;AAAA,6DAAmC;AACnC,4DAAkC;AAClC,0DAAgC;AAChC,6DAAmC;AACnC,wDAA8B;AAC9B,qDAA2B;AAC3B,4DAAkC"}

package/dist/cjs/types/minimal-queue.d.ts

@@ -0,0 +1,2 @@
+import { QueueBase } from '../classes/queue-base';
+export type MinimalQueue = Pick<QueueBase, 'name' | 'client' | 'toKey' | 'keys' | 'opts' | 'closing' | 'waitUntilReady' | 'removeListener' | 'emit' | 'on' | 'redisVersion'>;

package/dist/cjs/types/minimal-queue.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=minimal-queue.js.map

package/dist/cjs/types/minimal-queue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"minimal-queue.js","sourceRoot":"","sources":["../../../src/types/minimal-queue.ts"],"names":[],"mappings":""}

package/dist/esm/classes/backoffs.d.ts

@@ -1,5 +1,4 @@
-import { Job } from './job';
-import { BackoffOptions } from '../interfaces/backoff-options';
+import { BackoffOptions, MinimalJob } from '../interfaces';
 import { BackoffStrategy } from '../types';
 interface BuiltInStrategies {
     [index: string]: (delay: number) => BackoffStrategy;
@@ -7,6 +6,6 @@ interface BuiltInStrategies {
 export declare class Backoffs {
     static builtinStrategies: BuiltInStrategies;
     static normalize(backoff: number | BackoffOptions): BackoffOptions;
-    static calculate(backoff: BackoffOptions, attemptsMade: number, err: Error, job: Job, customStrategy?: BackoffStrategy): Promise<number> | number;
+    static calculate(backoff: BackoffOptions, attemptsMade: number, err: Error, job: MinimalJob, customStrategy?: BackoffStrategy): Promise<number> | number;
 }
 export {};

package/dist/esm/classes/backoffs.js.map

@@ -1 +1 @@
-{"version":3,"file":"backoffs.js","sourceRoot":"","sources":["../../../src/classes/backoffs.ts"],"names":[],"mappings":"AAQA,MAAM,OAAO,QAAQ;IAenB,MAAM,CAAC,SAAS,CAAC,OAAgC;QAC/C,IAAI,MAAM,CAAC,QAAQ,CAAS,OAAO,CAAC,EAAE;YACpC,OAAO;gBACL,IAAI,EAAE,OAAO;gBACb,KAAK,EAAU,OAAO;aACvB,CAAC;SACH;aAAM,IAAI,OAAO,EAAE;YAClB,OAAuB,OAAO,CAAC;SAChC;IACH,CAAC;IAED,MAAM,CAAC,SAAS,CACd,OAAuB,EACvB,YAAoB,EACpB,GAAU,EACV,GAAQ,EACR,cAAgC;QAEhC,IAAI,OAAO,EAAE;YACX,MAAM,QAAQ,GAAG,cAAc,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC;YAEzD,OAAO,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;SACvD;IACH,CAAC;;AArCM,0BAAiB,GAAsB;IAC5C,KAAK,EAAE,UAAU,KAAa;QAC5B,OAAO;YACL,OAAO,KAAK,CAAC;QACf,CAAC,CAAC;IACJ,CAAC;IAED,WAAW,EAAE,UAAU,KAAa;QAClC,OAAO,UAAU,YAAoB;YACnC,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,YAAY,GAAG,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC;QAC3D,CAAC,CAAC;IACJ,CAAC;CACF,CAAC;AA4BJ,SAAS,cAAc,CACrB,OAAuB,EACvB,cAA+B;IAE/B,IAAI,OAAO,CAAC,IAAI,IAAI,QAAQ,CAAC,iBAAiB,EAAE;QAC9C,OAAO,QAAQ,CAAC,iBAAiB,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;KAChE;SAAM,IAAI,cAAc,EAAE;QACzB,OAAO,cAAc,CAAC;KACvB;SAAM;QACL,MAAM,IAAI,KAAK,CACb,4BAA4B,OAAO,CAAC,IAAI;kFACoC,CAC7E,CAAC;KACH;AACH,CAAC"}
+{"version":3,"file":"backoffs.js","sourceRoot":"","sources":["../../../src/classes/backoffs.ts"],"names":[],"mappings":"AAOA,MAAM,OAAO,QAAQ;IAenB,MAAM,CAAC,SAAS,CAAC,OAAgC;QAC/C,IAAI,MAAM,CAAC,QAAQ,CAAS,OAAO,CAAC,EAAE;YACpC,OAAO;gBACL,IAAI,EAAE,OAAO;gBACb,KAAK,EAAU,OAAO;aACvB,CAAC;SACH;aAAM,IAAI,OAAO,EAAE;YAClB,OAAuB,OAAO,CAAC;SAChC;IACH,CAAC;IAED,MAAM,CAAC,SAAS,CACd,OAAuB,EACvB,YAAoB,EACpB,GAAU,EACV,GAAe,EACf,cAAgC;QAEhC,IAAI,OAAO,EAAE;YACX,MAAM,QAAQ,GAAG,cAAc,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC;YAEzD,OAAO,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;SACvD;IACH,CAAC;;AArCM,0BAAiB,GAAsB;IAC5C,KAAK,EAAE,UAAU,KAAa;QAC5B,OAAO;YACL,OAAO,KAAK,CAAC;QACf,CAAC,CAAC;IACJ,CAAC;IAED,WAAW,EAAE,UAAU,KAAa;QAClC,OAAO,UAAU,YAAoB;YACnC,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,YAAY,GAAG,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC;QAC3D,CAAC,CAAC;IACJ,CAAC;CACF,CAAC;AA4BJ,SAAS,cAAc,CACrB,OAAuB,EACvB,cAA+B;IAE/B,IAAI,OAAO,CAAC,IAAI,IAAI,QAAQ,CAAC,iBAAiB,EAAE;QAC9C,OAAO,QAAQ,CAAC,iBAAiB,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;KAChE;SAAM,IAAI,cAAc,EAAE;QACzB,OAAO,cAAc,CAAC;KACvB;SAAM;QACL,MAAM,IAAI,KAAK,CACb,4BAA4B,OAAO,CAAC,IAAI;kFACoC,CAC7E,CAAC;KACH;AACH,CAAC"}

package/dist/esm/classes/job.d.ts

@@ -1,25 +1,7 @@
 import { ChainableCommander } from 'ioredis';
-import { JobJson, JobJsonRaw, ParentKeys, RedisClient } from '../interfaces';
-import { FinishedStatus, JobsOptions, JobState, JobJsonSandbox } from '../types';
-import { QueueEvents } from './queue-events';
-import { MinimalQueue, ParentOpts, Scripts } from './scripts';
-export type BulkJobOptions = Omit<JobsOptions, 'repeat'>;
-export interface MoveToWaitingChildrenOpts {
-    child?: {
-        id: string;
-        queue: string;
-    };
-}
-export interface DependenciesOpts {
-    processed?: {
-        cursor?: number;
-        count?: number;
-    };
-    unprocessed?: {
-        cursor?: number;
-        count?: number;
-    };
-}
+import { BulkJobOptions, DependenciesOpts, JobJson, JobJsonRaw, MinimalJob, MoveToWaitingChildrenOpts, ParentKeys, ParentOpts, RedisClient } from '../interfaces';
+import { FinishedStatus, JobsOptions, JobState, JobJsonSandbox, MinimalQueue } from '../types';
+import { Scripts } from './scripts';
 /**
  * Job
  *
@@ -30,7 +12,7 @@ export interface DependenciesOpts {
  *
  * @class Job
  */
-export declare class Job<DataType = any, ReturnType = any, NameType extends string = string> {
+export declare class Job<DataType = any, ReturnType = any, NameType extends string = string> implements MinimalJob<DataType, ReturnType, NameType> {
     protected queue: MinimalQueue;
     /**
      * The name of the Job
@@ -154,7 +136,7 @@ export declare class Job<DataType = any, ReturnType = any, NameType extends stri
      * @returns
      */
     static fromId<T = any, R = any, N extends string = string>(queue: MinimalQueue, jobId: string): Promise<Job<T, R, N> | undefined>;
-    toJSON(): Omit<this, "toJSON" | "scripts" | "prefix" | "addJob" | "changeDelay" | "extendLock" | "getState" | "moveToDelayed" | "moveToWaitingChildren" | "promote" | "updateProgress" | "discard" | "queue" | "asJSON" | "asJSONSandbox" | "update" | "log" | "remove" | "moveToCompleted" | "moveToFailed" | "isCompleted" | "isFailed" | "isDelayed" | "isWaitingChildren" | "isActive" | "isWaiting" | "queueName" | "queueQualifiedName" | "getChildrenValues" | "getDependencies" | "getDependenciesCount" | "waitUntilFinished" | "retry">;
+    toJSON(): Omit<this, "toJSON" | "scripts" | "addJob" | "changeDelay" | "extendLock" | "getState" | "moveToDelayed" | "moveToWaitingChildren" | "promote" | "updateProgress" | "discard" | "queue" | "asJSON" | "asJSONSandbox" | "update" | "log" | "remove" | "moveToCompleted" | "moveToFailed" | "isCompleted" | "isFailed" | "isDelayed" | "isWaitingChildren" | "isActive" | "isWaiting" | "queueName" | "prefix" | "queueQualifiedName" | "getChildrenValues" | "getDependencies" | "getDependenciesCount" | "waitUntilFinished" | "retry">;
     /**
      * Prepares a job to be serialized for storage in Redis.
      * @returns
@@ -305,7 +287,7 @@ export declare class Job<DataType = any, ReturnType = any, NameType extends stri
      * @param queueEvents - Instance of QueueEvents.
      * @param ttl - Time in milliseconds to wait for job to finish before timing out.
      */
-    waitUntilFinished(queueEvents: QueueEvents, ttl?: number): Promise<ReturnType>;
+    waitUntilFinished(queueEvents: MinimalQueue, ttl?: number): Promise<ReturnType>;
     /**
      * Moves the job to the delay set.
      *