bullmq 3.6.1 → 3.6.3

package/dist/cjs/classes/flow-producer.d.ts

@@ -1,163 +0,0 @@
-/// <reference types="node" />
-import { EventEmitter } from 'events';
-import { ChainableCommander } from 'ioredis';
-import { FlowJob, FlowQueuesOpts, FlowOpts, IoredisListener, QueueBaseOptions, RedisClient } from '../interfaces';
-import { Job } from './job';
-import { KeysMap, QueueKeys } from './queue-keys';
-import { RedisConnection } from './redis-connection';
-export interface AddNodeOpts {
-    multi: ChainableCommander;
-    node: FlowJob;
-    parent?: {
-        parentOpts: {
-            id: string;
-            queue: string;
-        };
-        parentDependenciesKey: string;
-    };
-    /**
-     * Queues options that will be applied in each node depending on queue name presence.
-     */
-    queuesOpts?: FlowQueuesOpts;
-}
-export interface AddChildrenOpts {
-    multi: ChainableCommander;
-    nodes: FlowJob[];
-    parent: {
-        parentOpts: {
-            id: string;
-            queue: string;
-        };
-        parentDependenciesKey: string;
-    };
-    queuesOpts?: FlowQueuesOpts;
-}
-export interface NodeOpts {
-    /**
-     * Root job queue name.
-     */
-    queueName: string;
-    /**
-     * Prefix included in job key.
-     */
-    prefix?: string;
-    /**
-     * Root job id.
-     */
-    id: string;
-    /**
-     * Maximum depth or levels to visit in the tree.
-     */
-    depth?: number;
-    /**
-     * Maximum quantity of children per type (processed, unprocessed).
-     */
-    maxChildren?: number;
-}
-export interface JobNode {
-    job: Job;
-    children?: JobNode[];
-}
-export interface FlowProducerListener extends IoredisListener {
-    /**
-     * Listen to 'error' event.
-     *
-     * This event is triggered when an error is throw.
-     */
-    error: (failedReason: Error) => void;
-}
-/**
- * This class allows to add jobs with dependencies between them in such
- * a way that it is possible to build complex flows.
- * Note: A flow is a tree-like structure of jobs that depend on each other.
- * Whenever the children of a given parent are completed, the parent
- * will be processed, being able to access the children's result data.
- * All Jobs can be in different queues, either children or parents,
- */
-export declare class FlowProducer extends EventEmitter {
-    opts: QueueBaseOptions;
-    toKey: (name: string, type: string) => string;
-    keys: KeysMap;
-    closing: Promise<void>;
-    queueKeys: QueueKeys;
-    protected connection: RedisConnection;
-    constructor(opts?: QueueBaseOptions, Connection?: typeof RedisConnection);
-    emit<U extends keyof FlowProducerListener>(event: U, ...args: Parameters<FlowProducerListener[U]>): boolean;
-    off<U extends keyof FlowProducerListener>(eventName: U, listener: FlowProducerListener[U]): this;
-    on<U extends keyof FlowProducerListener>(event: U, listener: FlowProducerListener[U]): this;
-    once<U extends keyof FlowProducerListener>(event: U, listener: FlowProducerListener[U]): this;
-    /**
-     * Adds a flow.
-     *
-     * This call would be atomic, either it fails and no jobs will
-     * be added to the queues, or it succeeds and all jobs will be added.
-     *
-     * @param flow - an object with a tree-like structure where children jobs
-     * will be processed before their parents.
-     * @param opts - options that will be applied to the flow object.
-     */
-    add(flow: FlowJob, opts?: FlowOpts): Promise<JobNode>;
-    /**
-     * Get a flow.
-     *
-     * @param opts - an object with options for getting a JobNode.
-     */
-    getFlow(opts: NodeOpts): Promise<JobNode>;
-    get client(): Promise<RedisClient>;
-    /**
-     * Helper to easily extend Job class calls.
-     */
-    protected get Job(): typeof Job;
-    /**
-     * Adds multiple flows.
-     *
-     * A flow is a tree-like structure of jobs that depend on each other.
-     * Whenever the children of a given parent are completed, the parent
-     * will be processed, being able to access the children's result data.
-     *
-     * All Jobs can be in different queues, either children or parents,
-     * however this call would be atomic, either it fails and no jobs will
-     * be added to the queues, or it succeeds and all jobs will be added.
-     *
-     * @param flows - an array of objects with a tree-like structure where children jobs
-     * will be processed before their parents.
-     */
-    addBulk(flows: FlowJob[]): Promise<JobNode[]>;
-    /**
-     * Add a node (job) of a flow to the queue. This method will recursively
-     * add all its children as well. Note that a given job can potentially be
-     * a parent and a child job at the same time depending on where it is located
-     * in the tree hierarchy.
-     *
-     * @param multi - ioredis ChainableCommander
-     * @param node - the node representing a job to be added to some queue
-     * @param parent - parent data sent to children to create the "links" to their parent
-     * @returns
-     */
-    protected addNode({ multi, node, parent, queuesOpts }: AddNodeOpts): JobNode;
-    /**
-     * Adds nodes (jobs) of multiple flows to the queue. This method will recursively
-     * add all its children as well. Note that a given job can potentially be
-     * a parent and a child job at the same time depending on where it is located
-     * in the tree hierarchy.
-     *
-     * @param multi - ioredis ChainableCommander
-     * @param nodes - the nodes representing jobs to be added to some queue
-     * @returns
-     */
-    protected addNodes(multi: ChainableCommander, nodes: FlowJob[]): JobNode[];
-    private getNode;
-    private addChildren;
-    private getChildren;
-    /**
-     * Helper factory method that creates a queue-like object
-     * required to create jobs in any queue.
-     *
-     * @param node -
-     * @param queueKeys -
-     * @returns
-     */
-    private queueFromNode;
-    close(): Promise<void>;
-    disconnect(): Promise<void>;
-}

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

@@ -1,18 +0,0 @@
-export * from './backoffs';
-export * from './child-pool';
-export * from './child-processor';
-export * from './flow-producer';
-export * from './job';
-export * from './process-utils';
-export * from './queue-base';
-export * from './queue-events';
-export * from './queue-getters';
-export * from './queue-keys';
-export * from './queue';
-export * from './redis-connection';
-export * from './repeat';
-export * from './sandbox';
-export * from './scripts';
-export * from './timer-manager';
-export * from './unrecoverable-error';
-export * from './worker';

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

@@ -1,341 +0,0 @@
-import { ChainableCommander } from 'ioredis';
-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
- *
- * This class represents a Job in the queue. Normally job are implicitly created when
- * you add a job to the queue with methods such as Queue.addJob( ... )
- *
- * A Job instance is also passed to the Worker's process function.
- *
- * @class Job
- */
-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
-     */
-    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;
-    protected toKey: (type: string) => string;
-    protected discarded: boolean;
-    protected scripts: Scripts;
-    constructor(queue: MinimalQueue, 
-    /**
-     * The name of the Job
-     */
-    name: NameType, 
-    /**
-     * The payload for this job.
-     */
-    data: DataType, 
-    /**
-     * The options object for this job.
-     */
-    opts?: JobsOptions, id?: string);
-    /**
-     * Creates a new job and adds it to the queue.
-     *
-     * @param queue - the queue where to add the job.
-     * @param name - the name of the job.
-     * @param data - the payload of the job.
-     * @param opts - the options bag for this job.
-     * @returns
-     */
-    static create<T = any, R = any, N extends string = string>(queue: MinimalQueue, name: N, data: T, opts?: JobsOptions): Promise<Job<T, R, N>>;
-    /**
-     * Creates a bulk of jobs and adds them atomically to the given queue.
-     *
-     * @param queue -the queue were to add the jobs.
-     * @param jobs - an array of jobs to be added to the queue.
-     * @returns
-     */
-    static createBulk<T = any, R = any, N extends string = string>(queue: MinimalQueue, jobs: {
-        name: N;
-        data: T;
-        opts?: BulkJobOptions;
-    }[]): Promise<Job<T, R, N>[]>;
-    /**
-     * Instantiates a Job from a JobJsonRaw object (coming from a deserialized JSON object)
-     *
-     * @param queue - the queue where the job belongs to.
-     * @param json - the plain object containing the job.
-     * @param jobId - an optional job id (overrides the id coming from the JSON object)
-     * @returns
-     */
-    static fromJSON<T = any, R = any, N extends string = string>(queue: MinimalQueue, json: JobJsonRaw, jobId?: string): Job<T, R, N>;
-    private static optsFromJSON;
-    /**
-     * Fetches a Job from the queue given the passed job id.
-     *
-     * @param queue - the queue where the job belongs to.
-     * @param jobId - the job id.
-     * @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" | "addJob" | "changeDelay" | "extendLock" | "getState" | "moveToDelayed" | "moveToWaitingChildren" | "promote" | "updateProgress" | "discard" | "queue" | "asJSON" | "asJSONSandbox" | "update" | "log" | "clearLogs" | "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
-     */
-    asJSON(): JobJson;
-    private optsAsJSON;
-    /**
-     * 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>;
-    /**
-     * Clears job's logs
-     *
-     * @param keepLogs - the amount of log entries to preserve
-     */
-    clearLogs(keepLogs?: number): Promise<void>;
-    /**
-     * Completely remove the job from the queue.
-     * Note, this call will throw an exception if the job
-     * is being processed when the call is performed.
-     */
-    remove(): Promise<void>;
-    /**
-     * Extend the lock for this job.
-     *
-     * @param token - unique token for the lock
-     * @param duration - lock duration in milliseconds
-     */
-    extendLock(token: string, duration: number): Promise<number>;
-    /**
-     * Moves a job to the completed queue.
-     * Returned job to be used with Queue.prototype.nextJobFromJobData.
-     *
-     * @param returnValue - The jobs success message.
-     * @param token - Worker token used to acquire completed job.
-     * @param fetchNext - True when wanting to fetch the next job.
-     * @returns Returns the jobData of the next job in the waiting queue.
-     */
-    moveToCompleted(returnValue: ReturnType, token: string, fetchNext?: boolean): Promise<any[]>;
-    /**
-     * Moves a job to the failed queue.
-     *
-     * @param err - the jobs error message.
-     * @param token - token to check job is locked by current worker
-     * @param fetchNext - true when wanting to fetch the next job
-     * @returns void
-     */
-    moveToFailed<E extends Error>(err: E, token: string, fetchNext?: boolean): Promise<void>;
-    /**
-     * @returns true if the job has completed.
-     */
-    isCompleted(): Promise<boolean>;
-    /**
-     * @returns true if the job has failed.
-     */
-    isFailed(): Promise<boolean>;
-    /**
-     * @returns true if the job is delayed.
-     */
-    isDelayed(): Promise<boolean>;
-    /**
-     * @returns true if the job is waiting for children.
-     */
-    isWaitingChildren(): Promise<boolean>;
-    /**
-     * @returns true of the job is active.
-     */
-    isActive(): Promise<boolean>;
-    /**
-     * @returns true if the job is waiting.
-     */
-    isWaiting(): Promise<boolean>;
-    /**
-     * @returns the queue name this job belongs to.
-     */
-    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;
-    /**
-     * Get current state.
-     *
-     * @returns Returns one of these values:
-     * 'completed', 'failed', 'delayed', 'active', 'waiting', 'waiting-children', 'unknown'.
-     */
-    getState(): Promise<JobState | 'unknown'>;
-    /**
-     * Change delay of a delayed job.
-     *
-     * @param delay - milliseconds to be added to current time.
-     * @returns void
-     */
-    changeDelay(delay: number): Promise<void>;
-    /**
-     * Get this jobs children result values if any.
-     *
-     * @returns Object mapping children job keys with their values.
-     */
-    getChildrenValues<CT = any>(): Promise<{
-        [jobKey: string]: CT;
-    }>;
-    /**
-     * Get children job keys if this job is a parent and has children.
-     *
-     * @returns dependencies separated by processed and unprocessed.
-     */
-    getDependencies(opts?: DependenciesOpts): Promise<{
-        nextProcessedCursor?: number;
-        processed?: Record<string, any>;
-        nextUnprocessedCursor?: number;
-        unprocessed?: string[];
-    }>;
-    /**
-     * Get children job counts if this job is a parent and has children.
-     *
-     * @returns dependencies count separated by processed and unprocessed.
-     */
-    getDependenciesCount(opts?: {
-        processed?: boolean;
-        unprocessed?: boolean;
-    }): Promise<{
-        processed?: number;
-        unprocessed?: number;
-    }>;
-    /**
-     * Returns a promise the resolves when the job has completed (containing the return value of the job),
-     * or rejects when the job has failed (containing the failedReason).
-     *
-     * @param queueEvents - Instance of QueueEvents.
-     * @param ttl - Time in milliseconds to wait for job to finish before timing out.
-     */
-    waitUntilFinished(queueEvents: MinimalQueue, ttl?: number): Promise<ReturnType>;
-    /**
-     * Moves the job to the delay set.
-     *
-     * @param timestamp - timestamp where the job should be moved back to "wait"
-     * @param token - token to check job is locked by current worker
-     * @returns
-     */
-    moveToDelayed(timestamp: number, token?: string): Promise<void>;
-    /**
-     * Moves the job to the waiting-children set.
-     *
-     * @param token - Token to check job is locked by current worker
-     * @param opts - The options bag for moving a job to waiting-children.
-     * @returns true if the job was moved
-     */
-    moveToWaitingChildren(token: string, opts?: MoveToWaitingChildrenOpts): Promise<boolean>;
-    /**
-     * Promotes a delayed job so that it starts to be processed as soon as possible.
-     */
-    promote(): Promise<void>;
-    /**
-     * Attempts to retry the job. Only a job that has failed or completed can be retried.
-     *
-     * @param state - completed / failed
-     * @returns If resolved and return code is 1, then the queue emits a waiting event
-     * otherwise the operation was not a success and throw the corresponding error. If the promise
-     * rejects, it indicates that the script failed to execute
-     */
-    retry(state?: FinishedStatus): Promise<void>;
-    /**
-     * Marks a job to not be retried if it fails (even if attempts has been configured)
-     */
-    discard(): void;
-    private isInZSet;
-    private isInList;
-    /**
-     * Adds the job to Redis.
-     *
-     * @param client -
-     * @param parentOpts -
-     * @returns
-     */
-    addJob(client: RedisClient, parentOpts?: ParentOpts): Promise<string>;
-    protected saveStacktrace(multi: ChainableCommander, err: Error): void;
-}

package/dist/cjs/classes/process-utils.d.ts

@@ -1,7 +0,0 @@
-/// <reference types="node" />
-import { ChildProcess } from 'child_process';
-/**
- * Sends a kill signal to a child resolving when the child has exited,
- * resorting to SIGKILL if the given timeout is reached
- */
-export declare function killAsync(child: ChildProcess, signal?: 'SIGTERM' | 'SIGKILL', timeoutMs?: number): Promise<void>;

package/dist/cjs/classes/queue-base.d.ts

@@ -1,67 +0,0 @@
-/// <reference types="node" />
-import { EventEmitter } from 'events';
-import { QueueBaseOptions, RedisClient } from '../interfaces';
-import { MinimalQueue } from '../types';
-import { RedisConnection } from './redis-connection';
-import { Job } from './job';
-import { KeysMap } from './queue-keys';
-import { Scripts } from './scripts';
-/**
- * @class QueueBase
- * @extends EventEmitter
- *
- * @description Base class for all classes that need to interact with queues.
- * This class is normally not used directly, but extended by the other classes.
- *
- */
-export declare class QueueBase extends EventEmitter implements MinimalQueue {
-    readonly name: string;
-    opts: QueueBaseOptions;
-    toKey: (type: string) => string;
-    keys: KeysMap;
-    closing: Promise<void>;
-    protected scripts: Scripts;
-    protected connection: RedisConnection;
-    /**
-     *
-     * @param name - The name of the queue.
-     * @param opts - Options for the queue.
-     * @param Connection - An optional "Connection" class used to instantiate a Connection. This is useful for
-     * testing with mockups and/or extending the Connection class and passing an alternate implementation.
-     */
-    constructor(name: string, opts?: QueueBaseOptions, Connection?: typeof RedisConnection);
-    /**
-     * Returns a promise that resolves to a redis client. Normally used only by subclasses.
-     */
-    get client(): Promise<RedisClient>;
-    /**
-     * Returns the version of the Redis instance the client is connected to,
-     */
-    get redisVersion(): string;
-    /**
-     * Helper to easily extend Job class calls.
-     */
-    protected get Job(): typeof Job;
-    /**
-     * Emits an event. Normally used by subclasses to emit events.
-     *
-     * @param event - The emitted event.
-     * @param args -
-     * @returns
-     */
-    emit(event: string | symbol, ...args: any[]): boolean;
-    waitUntilReady(): Promise<RedisClient>;
-    protected base64Name(): string;
-    protected clientName(suffix?: string): string;
-    /**
-     *
-     * @returns Closes the connection and returns a promise that resolves when the connection is closed.
-     */
-    close(): Promise<void>;
-    /**
-     *
-     * Force disconnects a connection.
-     */
-    disconnect(): Promise<void>;
-    protected checkConnectionError<T>(fn: () => Promise<T>, delayInMs?: number): Promise<T>;
-}