@tachybase/plugin-adapter-bullmq 1.3.17 → 1.3.19

package/dist/node_modules/bullmq/dist/esm/classes/redis-connection.js

@@ -13,22 +13,23 @@ const overrideMessage = [
 ].join(' ');
 const deprecationMessage = 'BullMQ: Your redis options maxRetriesPerRequest must be null.';
 export class RedisConnection extends EventEmitter {
-    constructor(opts, shared = false, blocking = true, skipVersionCheck = false) {
+    constructor(opts, extraOptions) {
         super();
-        this.shared = shared;
-        this.blocking = blocking;
+        this.extraOptions = extraOptions;
         this.capabilities = {
             canDoubleTimeout: false,
             canBlockFor1Ms: true,
         };
         this.status = 'initializing';
         this.packageVersion = packageVersion;
+        // Set extra options defaults
+        this.extraOptions = Object.assign({ shared: false, blocking: true, skipVersionCheck: false, skipWaitingForReady: false }, extraOptions);
         if (!isRedisInstance(opts)) {
             this.checkBlockingOptions(overrideMessage, opts);
             this.opts = Object.assign({ port: 6379, host: '127.0.0.1', retryStrategy: function (times) {
                     return Math.max(Math.min(Math.exp(times), 20000), 1000);
                 } }, opts);
-            if (this.blocking) {
+            if (this.extraOptions.blocking) {
                 this.opts.maxRetriesPerRequest = null;
             }
         }
@@ -48,7 +49,8 @@ export class RedisConnection extends EventEmitter {
             this.checkBlockingOptions(deprecationMessage, this.opts, true);
         }
         this.skipVersionCheck =
-            skipVersionCheck || !!(this.opts && this.opts.skipVersionCheck);
+            (extraOptions === null || extraOptions === void 0 ? void 0 : extraOptions.skipVersionCheck) ||
+                !!(this.opts && this.opts.skipVersionCheck);
         this.handleClientError = (err) => {
             this.emit('error', err);
         };
@@ -62,7 +64,7 @@ export class RedisConnection extends EventEmitter {
         this.initializing.catch(err => this.emit('error', err));
     }
     checkBlockingOptions(msg, options, throwError = false) {
-        if (this.blocking && options && options.maxRetriesPerRequest) {
+        if (this.extraOptions.blocking && options && options.maxRetriesPerRequest) {
             if (throwError) {
                 throw new Error(msg);
             }
@@ -150,7 +152,9 @@ export class RedisConnection extends EventEmitter {
         // ioredis treats connection errors as a different event ('close')
         this._client.on('close', this.handleClientClose);
         this._client.on('ready', this.handleClientReady);
-        await RedisConnection.waitUntilReady(this._client);
+        if (!this.extraOptions.skipWaitingForReady) {
+            await RedisConnection.waitUntilReady(this._client);
+        }
         this.loadCommands(this.packageVersion);
         if (this._client['status'] !== 'end') {
             this.version = await this.getRedisVersion();
@@ -211,7 +215,7 @@ export class RedisConnection extends EventEmitter {
                     // Not sure if we need to wait for this
                     await this.initializing;
                 }
-                if (!this.shared) {
+                if (!this.extraOptions.shared) {
                     if (status == 'initializing' || force) {
                         // If we have not still connected to Redis, we need to disconnect.
                         this._client.disconnect();
@@ -239,10 +243,13 @@ export class RedisConnection extends EventEmitter {
         }
     }
     async getRedisVersion() {
+        if (this.skipVersionCheck) {
+            return RedisConnection.minimumVersion;
+        }
         const doc = await this._client.info();
         const redisPrefix = 'redis_version:';
         const maxMemoryPolicyPrefix = 'maxmemory_policy:';
-        const lines = doc.split('\r\n');
+        const lines = doc.split(/\r?\n/);
         let redisVersion;
         for (let i = 0; i < lines.length; i++) {
             if (lines[i].indexOf(maxMemoryPolicyPrefix) === 0) {

package/dist/node_modules/bullmq/dist/esm/classes/repeat.js

@@ -25,7 +25,7 @@ export class Repeat extends QueueBase {
         // Check if we reached the end date of the repeatable job
         let now = Date.now();
         const { endDate } = repeatOpts;
-        if (!(typeof endDate === undefined) && now > new Date(endDate).getTime()) {
+        if (endDate && now > new Date(endDate).getTime()) {
             return;
         }
         const prevMillis = opts.prevMillis || 0;

package/dist/node_modules/bullmq/dist/esm/classes/sandbox.js

@@ -11,32 +11,61 @@ const sandbox = (processFile, childPool) => {
                         exitHandler = (exitCode, signal) => {
                             reject(new Error('Unexpected exit code: ' + exitCode + ' signal: ' + signal));
                         };
-                        child = await childPool.retain(processFile, exitHandler);
+                        child = await childPool.retain(processFile);
+                        child.on('exit', exitHandler);
                         msgHandler = async (msg) => {
-                            var _a, _b;
-                            switch (msg.cmd) {
-                                case ParentCommand.Completed:
-                                    resolve(msg.value);
-                                    break;
-                                case ParentCommand.Failed:
-                                case ParentCommand.Error: {
-                                    const err = new Error();
-                                    Object.assign(err, msg.value);
-                                    reject(err);
-                                    break;
+                            var _a, _b, _c;
+                            try {
+                                switch (msg.cmd) {
+                                    case ParentCommand.Completed:
+                                        resolve(msg.value);
+                                        break;
+                                    case ParentCommand.Failed:
+                                    case ParentCommand.Error: {
+                                        const err = new Error();
+                                        Object.assign(err, msg.value);
+                                        reject(err);
+                                        break;
+                                    }
+                                    case ParentCommand.Progress:
+                                        await job.updateProgress(msg.value);
+                                        break;
+                                    case ParentCommand.Log:
+                                        await job.log(msg.value);
+                                        break;
+                                    case ParentCommand.MoveToDelayed:
+                                        await job.moveToDelayed((_a = msg.value) === null || _a === void 0 ? void 0 : _a.timestamp, (_b = msg.value) === null || _b === void 0 ? void 0 : _b.token);
+                                        break;
+                                    case ParentCommand.MoveToWait:
+                                        await job.moveToWait((_c = msg.value) === null || _c === void 0 ? void 0 : _c.token);
+                                        break;
+                                    case ParentCommand.Update:
+                                        await job.updateData(msg.value);
+                                        break;
+                                    case ParentCommand.GetChildrenValues:
+                                        {
+                                            const value = await job.getChildrenValues();
+                                            child.send({
+                                                requestId: msg.requestId,
+                                                cmd: ChildCommand.GetChildrenValuesResponse,
+                                                value,
+                                            });
+                                        }
+                                        break;
+                                    case ParentCommand.GetIgnoredChildrenFailures:
+                                        {
+                                            const value = await job.getIgnoredChildrenFailures();
+                                            child.send({
+                                                requestId: msg.requestId,
+                                                cmd: ChildCommand.GetIgnoredChildrenFailuresResponse,
+                                                value,
+                                            });
+                                        }
+                                        break;
                                 }
-                                case ParentCommand.Progress:
-                                    await job.updateProgress(msg.value);
-                                    break;
-                                case ParentCommand.Log:
-                                    await job.log(msg.value);
-                                    break;
-                                case ParentCommand.MoveToDelayed:
-                                    await job.moveToDelayed((_a = msg.value) === null || _a === void 0 ? void 0 : _a.timestamp, (_b = msg.value) === null || _b === void 0 ? void 0 : _b.token);
-                                    break;
-                                case ParentCommand.Update:
-                                    await job.updateData(msg.value);
-                                    break;
+                            }
+                            catch (err) {
+                                reject(err);
                             }
                         };
                         child.on('message', msgHandler);
@@ -59,10 +88,7 @@ const sandbox = (processFile, childPool) => {
             if (child) {
                 child.off('message', msgHandler);
                 child.off('exit', exitHandler);
-                if (child.exitCode !== null || /SIG.*/.test(`${child.signalCode}`)) {
-                    childPool.remove(child);
-                }
-                else {
+                if (child.exitCode === null && child.signalCode === null) {
                     childPool.release(child);
                 }
             }

package/dist/node_modules/bullmq/dist/esm/classes/scripts.d.ts

@@ -2,39 +2,44 @@
  * Includes all the scripts needed by the queue and jobs.
  */
 /// <reference types="node" />
-import { JobJson, JobJsonRaw, MinimalJob, MoveToWaitingChildrenOpts, ParentOpts, RedisClient, KeepJobs, MoveToDelayedOpts, RepeatableOptions } from '../interfaces';
-import { JobState, JobType, FinishedStatus, FinishedPropValAttribute, MinimalQueue, RedisJobOptions } from '../types';
+import { JobJson, JobJsonRaw, MinimalJob, MoveToWaitingChildrenOpts, ParentKeyOpts, RedisClient, KeepJobs, MoveToDelayedOpts, RepeatableOptions, RetryJobOpts } from '../interfaces';
+import { JobsOptions, JobState, JobType, FinishedStatus, FinishedPropValAttribute, ScriptQueueContext, RedisJobOptions, JobProgress } from '../types';
 import { ChainableCommander } from 'ioredis';
 export type JobData = [JobJsonRaw | number, string?];
 export declare class Scripts {
-    protected queue: MinimalQueue;
+    protected queue: ScriptQueueContext;
     protected version: string;
     moveToFinishedKeys: (string | undefined)[];
-    constructor(queue: MinimalQueue);
+    constructor(queue: ScriptQueueContext);
     execCommand(client: RedisClient | ChainableCommander, commandName: string, args: any[]): any;
     isJobInList(listKey: string, jobId: string): Promise<boolean>;
+    protected addDelayedJobArgs(job: JobJson, encodedOpts: any, args: (string | number | Record<string, any>)[]): (string | Buffer)[];
     protected addDelayedJob(client: RedisClient, job: JobJson, encodedOpts: any, args: (string | number | Record<string, any>)[]): Promise<string | number>;
+    protected addPrioritizedJobArgs(job: JobJson, encodedOpts: any, args: (string | number | Record<string, any>)[]): (string | Buffer)[];
     protected addPrioritizedJob(client: RedisClient, job: JobJson, encodedOpts: any, args: (string | number | Record<string, any>)[]): Promise<string | number>;
+    protected addParentJobArgs(job: JobJson, encodedOpts: any, args: (string | number | Record<string, any>)[]): (string | Buffer)[];
     protected addParentJob(client: RedisClient, job: JobJson, encodedOpts: any, args: (string | number | Record<string, any>)[]): Promise<string | number>;
+    protected addStandardJobArgs(job: JobJson, encodedOpts: any, args: (string | number | Record<string, any>)[]): (string | Buffer)[];
     protected addStandardJob(client: RedisClient, job: JobJson, encodedOpts: any, args: (string | number | Record<string, any>)[]): Promise<string | number>;
-    addJob(client: RedisClient, job: JobJson, opts: RedisJobOptions, jobId: string, parentOpts?: ParentOpts): Promise<string>;
+    addJob(client: RedisClient, job: JobJson, opts: RedisJobOptions, jobId: string, parentKeyOpts?: ParentKeyOpts): Promise<string>;
     protected pauseArgs(pause: boolean): (string | number)[];
     pause(pause: boolean): Promise<void>;
     protected addRepeatableJobArgs(customKey: string, nextMillis: number, opts: RepeatableOptions, legacyCustomKey: string): (string | number | Buffer)[];
     addRepeatableJob(customKey: string, nextMillis: number, opts: RepeatableOptions, legacyCustomKey: string): Promise<string>;
-    addJobScheduler(client: RedisClient, jobSchedulerId: string, nextMillis: number, templateData: string, templateOpts: RedisJobOptions, opts: RepeatableOptions): Promise<string>;
+    addJobScheduler(jobSchedulerId: string, nextMillis: number, templateData: string, templateOpts: RedisJobOptions, opts: RepeatableOptions, delayedJobOpts: JobsOptions, producerId?: string): Promise<string>;
     updateRepeatableJobMillis(client: RedisClient, customKey: string, nextMillis: number, legacyCustomKey: string): Promise<string>;
-    updateJobSchedulerNextMillis(client: RedisClient, jobSchedulerId: string, nextMillis: number): Promise<number>;
+    updateJobSchedulerNextMillis(jobSchedulerId: string, nextMillis: number, templateData: string, delayedJobOpts: JobsOptions, producerId?: string): Promise<string | null>;
     private removeRepeatableArgs;
     getRepeatConcatOptions(repeatConcatOptions: string, repeatJobKey: string): string;
     removeRepeatable(legacyRepeatJobId: string, repeatConcatOptions: string, repeatJobKey: string): Promise<number>;
     removeJobScheduler(jobSchedulerId: string): Promise<number>;
     protected removeArgs(jobId: string, removeChildren: boolean): (string | number)[];
     remove(jobId: string, removeChildren: boolean): Promise<number>;
+    removeUnprocessedChildren(jobId: string): Promise<void>;
     extendLock(jobId: string, token: string, duration: number, client?: RedisClient | ChainableCommander): Promise<number>;
     extendLocks(jobIds: string[], tokens: string[], duration: number): Promise<string[]>;
     updateData<T = any, R = any, N extends string = string>(job: MinimalJob<T, R, N>, data: T): Promise<void>;
-    updateProgress(jobId: string, progress: number | object): Promise<void>;
+    updateProgress(jobId: string, progress: JobProgress): Promise<void>;
     addLog(jobId: string, logRow: string, keepLogs?: number): Promise<number>;
     protected moveToFinishedArgs<T = any, R = any, N extends string = string>(job: MinimalJob<T, R, N>, val: any, propVal: FinishedPropValAttribute, shouldRemove: undefined | boolean | number | KeepJobs, target: FinishedStatus, token: string, timestamp: number, fetchNext?: boolean, fieldsToUpdate?: Record<string, any>): (string | number | boolean | Buffer)[];
     protected getKeepJobs(shouldRemove: undefined | boolean | number | KeepJobs, workerKeepJobs: undefined | KeepJobs): KeepJobs;
@@ -49,6 +54,8 @@ export declare class Scripts {
     getCounts(types: JobType[]): Promise<number[]>;
     protected getCountsPerPriorityArgs(priorities: number[]): (string | number)[];
     getCountsPerPriority(priorities: number[]): Promise<number[]>;
+    protected getDependencyCountsArgs(jobId: string, types: string[]): (string | number)[];
+    getDependencyCounts(jobId: string, types: string[]): Promise<number[]>;
     moveToCompletedArgs<T = any, R = any, N extends string = string>(job: MinimalJob<T, R, N>, returnvalue: R, removeOnComplete: boolean | number | KeepJobs, token: string, fetchNext?: boolean): (string | number | boolean | Buffer)[];
     moveToFailedArgs<T = any, R = any, N extends string = string>(job: MinimalJob<T, R, N>, failedReason: string, removeOnFailed: boolean | number | KeepJobs, token: string, fetchNext?: boolean, fieldsToUpdate?: Record<string, any>): (string | number | boolean | Buffer)[];
     isFinished(jobId: string, returnValue?: boolean): Promise<number | [number, string]>;
@@ -84,8 +91,8 @@ export declare class Scripts {
     cleanJobsInSet(set: string, timestamp: number, limit?: number): Promise<string[]>;
     getJobSchedulerArgs(id: string): string[];
     getJobScheduler(id: string): Promise<[any, string | null]>;
-    retryJobArgs(jobId: string, lifo: boolean, token: string, fieldsToUpdate?: Record<string, any>): (string | number | Buffer)[];
-    retryJob(jobId: string, lifo: boolean, token: string, fieldsToUpdate?: Record<string, any>): Promise<void>;
+    retryJobArgs(jobId: string, lifo: boolean, token: string, opts?: MoveToDelayedOpts): (string | number | Buffer)[];
+    retryJob(jobId: string, lifo: boolean, token?: string, opts?: RetryJobOpts): Promise<void>;
     protected moveJobsToWaitArgs(state: FinishedStatus | 'delayed', count: number, timestamp: number): (string | number)[];
     retryJobs(state?: FinishedStatus, count?: number, timestamp?: number): Promise<number>;
     promoteJobs(count?: number): Promise<number>;
@@ -115,7 +122,7 @@ export declare class Scripts {
      * (e.g. if the job handler keeps crashing),
      * we limit the number stalled job recoveries to settings.maxStalledCount.
      */
-    moveStalledJobsToWait(): Promise<[string[], string[]]>;
+    moveStalledJobsToWait(): Promise<string[]>;
     /**
      * Moves a job back from Active to Wait.
      * This script is used when a job has been manually rate limited and needs
@@ -125,14 +132,14 @@ export declare class Scripts {
      * @param jobId - Job id
      * @returns
      */
-    moveJobFromActiveToWait(jobId: string, token: string): Promise<any>;
+    moveJobFromActiveToWait(jobId: string, token?: string): Promise<any>;
     obliterate(opts: {
         force: boolean;
         count: number;
     }): Promise<number>;
     /**
      * Paginate a set or hash keys.
-     * @param opts
+     * @param opts - options to define the pagination behaviour
      *
      */
     paginate(key: string, opts: {