@tachybase/plugin-adapter-bullmq 0.23.8

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

@@ -0,0 +1,266 @@
+import { __rest } from "tslib";
+import { EventEmitter } from 'events';
+import { default as IORedis } from 'ioredis';
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+import { CONNECTION_CLOSED_ERROR_MSG } from 'ioredis/built/utils';
+import { decreaseMaxListeners, increaseMaxListeners, isNotConnectionError, isRedisCluster, isRedisInstance, isRedisVersionLowerThan, } from '../utils';
+import { version as packageVersion } from '../version';
+import * as scripts from '../scripts';
+const overrideMessage = [
+    'BullMQ: WARNING! Your redis options maxRetriesPerRequest must be null',
+    'and will be overridden by BullMQ.',
+].join(' ');
+const deprecationMessage = 'BullMQ: Your redis options maxRetriesPerRequest must be null.';
+export class RedisConnection extends EventEmitter {
+    constructor(opts, shared = false, blocking = true, skipVersionCheck = false) {
+        super();
+        this.shared = shared;
+        this.blocking = blocking;
+        this.capabilities = {
+            canDoubleTimeout: false,
+            canBlockFor1Ms: true,
+        };
+        this.status = 'initializing';
+        this.packageVersion = packageVersion;
+        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) {
+                this.opts.maxRetriesPerRequest = null;
+            }
+        }
+        else {
+            this._client = opts;
+            // Test if the redis instance is using keyPrefix
+            // and if so, throw an error.
+            if (this._client.options.keyPrefix) {
+                throw new Error('BullMQ: ioredis does not support ioredis prefixes, use the prefix option instead.');
+            }
+            if (isRedisCluster(this._client)) {
+                this.opts = this._client.options.redisOptions;
+            }
+            else {
+                this.opts = this._client.options;
+            }
+            this.checkBlockingOptions(deprecationMessage, this.opts, true);
+        }
+        this.skipVersionCheck =
+            skipVersionCheck || !!(this.opts && this.opts.skipVersionCheck);
+        this.handleClientError = (err) => {
+            this.emit('error', err);
+        };
+        this.handleClientClose = () => {
+            this.emit('close');
+        };
+        this.handleClientReady = () => {
+            this.emit('ready');
+        };
+        this.initializing = this.init();
+        this.initializing.catch(err => this.emit('error', err));
+    }
+    checkBlockingOptions(msg, options, throwError = false) {
+        if (this.blocking && options && options.maxRetriesPerRequest) {
+            if (throwError) {
+                throw new Error(msg);
+            }
+            else {
+                console.error(msg);
+            }
+        }
+    }
+    /**
+     * Waits for a redis client to be ready.
+     * @param redis - client
+     */
+    static async waitUntilReady(client) {
+        if (client.status === 'ready') {
+            return;
+        }
+        if (client.status === 'wait') {
+            return client.connect();
+        }
+        if (client.status === 'end') {
+            throw new Error(CONNECTION_CLOSED_ERROR_MSG);
+        }
+        let handleReady;
+        let handleEnd;
+        let handleError;
+        try {
+            await new Promise((resolve, reject) => {
+                let lastError;
+                handleError = (err) => {
+                    lastError = err;
+                };
+                handleReady = () => {
+                    resolve();
+                };
+                handleEnd = () => {
+                    if (client.status !== 'end') {
+                        reject(lastError || new Error(CONNECTION_CLOSED_ERROR_MSG));
+                    }
+                    else {
+                        if (lastError) {
+                            reject(lastError);
+                        }
+                        else {
+                            // when custon 'end' status is set we already closed
+                            resolve();
+                        }
+                    }
+                };
+                increaseMaxListeners(client, 3);
+                client.once('ready', handleReady);
+                client.on('end', handleEnd);
+                client.once('error', handleError);
+            });
+        }
+        finally {
+            client.removeListener('end', handleEnd);
+            client.removeListener('error', handleError);
+            client.removeListener('ready', handleReady);
+            decreaseMaxListeners(client, 3);
+        }
+    }
+    get client() {
+        return this.initializing;
+    }
+    loadCommands(packageVersion, providedScripts) {
+        const finalScripts = providedScripts || scripts;
+        for (const property in finalScripts) {
+            // Only define the command if not already defined
+            const commandName = `${finalScripts[property].name}:${packageVersion}`;
+            if (!this._client[commandName]) {
+                this._client.defineCommand(commandName, {
+                    numberOfKeys: finalScripts[property].keys,
+                    lua: finalScripts[property].content,
+                });
+            }
+        }
+    }
+    async init() {
+        if (!this._client) {
+            const _a = this.opts, { url } = _a, rest = __rest(_a, ["url"]);
+            this._client = url ? new IORedis(url, rest) : new IORedis(rest);
+        }
+        increaseMaxListeners(this._client, 3);
+        this._client.on('error', this.handleClientError);
+        // 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);
+        this.loadCommands(this.packageVersion);
+        if (this._client['status'] !== 'end') {
+            this.version = await this.getRedisVersion();
+            if (this.skipVersionCheck !== true && !this.closing) {
+                if (isRedisVersionLowerThan(this.version, RedisConnection.minimumVersion)) {
+                    throw new Error(`Redis version needs to be greater or equal than ${RedisConnection.minimumVersion} ` +
+                        `Current: ${this.version}`);
+                }
+                if (isRedisVersionLowerThan(this.version, RedisConnection.recommendedMinimumVersion)) {
+                    console.warn(`It is highly recommended to use a minimum Redis version of ${RedisConnection.recommendedMinimumVersion}
+             Current: ${this.version}`);
+                }
+            }
+            this.capabilities = {
+                canDoubleTimeout: !isRedisVersionLowerThan(this.version, '6.0.0'),
+                canBlockFor1Ms: !isRedisVersionLowerThan(this.version, '7.0.8'),
+            };
+            this.status = 'ready';
+        }
+        return this._client;
+    }
+    async disconnect(wait = true) {
+        const client = await this.client;
+        if (client.status !== 'end') {
+            let _resolve, _reject;
+            if (!wait) {
+                return client.disconnect();
+            }
+            const disconnecting = new Promise((resolve, reject) => {
+                increaseMaxListeners(client, 2);
+                client.once('end', resolve);
+                client.once('error', reject);
+                _resolve = resolve;
+                _reject = reject;
+            });
+            client.disconnect();
+            try {
+                await disconnecting;
+            }
+            finally {
+                decreaseMaxListeners(client, 2);
+                client.removeListener('end', _resolve);
+                client.removeListener('error', _reject);
+            }
+        }
+    }
+    async reconnect() {
+        const client = await this.client;
+        return client.connect();
+    }
+    async close(force = false) {
+        if (!this.closing) {
+            const status = this.status;
+            this.status = 'closing';
+            this.closing = true;
+            try {
+                if (status === 'ready') {
+                    // Not sure if we need to wait for this
+                    await this.initializing;
+                }
+                if (!this.shared) {
+                    if (status == 'initializing' || force) {
+                        // If we have not still connected to Redis, we need to disconnect.
+                        this._client.disconnect();
+                    }
+                    else {
+                        await this._client.quit();
+                    }
+                    // As IORedis does not update this status properly, we do it ourselves.
+                    this._client['status'] = 'end';
+                }
+            }
+            catch (error) {
+                if (isNotConnectionError(error)) {
+                    throw error;
+                }
+            }
+            finally {
+                this._client.off('error', this.handleClientError);
+                this._client.off('close', this.handleClientClose);
+                this._client.off('ready', this.handleClientReady);
+                decreaseMaxListeners(this._client, 3);
+                this.removeAllListeners();
+                this.status = 'closed';
+            }
+        }
+    }
+    async getRedisVersion() {
+        const doc = await this._client.info();
+        const redisPrefix = 'redis_version:';
+        const maxMemoryPolicyPrefix = 'maxmemory_policy:';
+        const lines = doc.split('\r\n');
+        let redisVersion;
+        for (let i = 0; i < lines.length; i++) {
+            if (lines[i].indexOf(maxMemoryPolicyPrefix) === 0) {
+                const maxMemoryPolicy = lines[i].substr(maxMemoryPolicyPrefix.length);
+                if (maxMemoryPolicy !== 'noeviction') {
+                    console.warn(`IMPORTANT! Eviction policy is ${maxMemoryPolicy}. It should be "noeviction"`);
+                }
+            }
+            if (lines[i].indexOf(redisPrefix) === 0) {
+                redisVersion = lines[i].substr(redisPrefix.length);
+            }
+        }
+        return redisVersion;
+    }
+    get redisVersion() {
+        return this.version;
+    }
+}
+RedisConnection.minimumVersion = '5.0.0';
+RedisConnection.recommendedMinimumVersion = '6.2.0';
+//# sourceMappingURL=redis-connection.js.map

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

@@ -0,0 +1,25 @@
+import { RepeatBaseOptions, RepeatableJob, RepeatOptions } from '../interfaces';
+import { JobsOptions } from '../types';
+import { Job } from './job';
+import { QueueBase } from './queue-base';
+import { RedisConnection } from './redis-connection';
+export declare class Repeat extends QueueBase {
+    private repeatStrategy;
+    private repeatKeyHashAlgorithm;
+    constructor(name: string, opts: RepeatBaseOptions, Connection?: typeof RedisConnection);
+    updateRepeatableJob<T = any, R = any, N extends string = string>(name: N, data: T, opts: JobsOptions, { override }: {
+        override: boolean;
+    }): Promise<Job<T, R, N> | undefined>;
+    private createNextJob;
+    getRepeatJobKey<T = any, N extends string = string>(name: N, nextMillis: number, repeatJobKey: string, data: T): string;
+    removeRepeatable(name: string, repeat: RepeatOptions, jobId?: string): Promise<number>;
+    removeRepeatableByKey(repeatJobKey: string): Promise<number>;
+    private getRepeatableData;
+    private keyToData;
+    getRepeatableJobs(start?: number, end?: number, asc?: boolean): Promise<RepeatableJob[]>;
+    getRepeatableCount(): Promise<number>;
+    private hash;
+    private getRepeatDelayedJobId;
+    private getRepeatJobId;
+}
+export declare const getNextMillis: (millis: number, opts: RepeatOptions) => number | undefined;

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

@@ -0,0 +1,199 @@
+import { __rest } from "tslib";
+import { parseExpression } from 'cron-parser';
+import { createHash } from 'crypto';
+import { QueueBase } from './queue-base';
+export class Repeat extends QueueBase {
+    constructor(name, opts, Connection) {
+        super(name, opts, Connection);
+        this.repeatStrategy =
+            (opts.settings && opts.settings.repeatStrategy) || getNextMillis;
+        this.repeatKeyHashAlgorithm =
+            (opts.settings && opts.settings.repeatKeyHashAlgorithm) || 'md5';
+    }
+    async updateRepeatableJob(name, data, opts, { override }) {
+        var _a, _b;
+        // Backwards compatibility for repeatable jobs for versions <= 3.0.0
+        const repeatOpts = Object.assign({}, opts.repeat);
+        (_a = repeatOpts.pattern) !== null && _a !== void 0 ? _a : (repeatOpts.pattern = repeatOpts.cron);
+        delete repeatOpts.cron;
+        // Check if we reached the limit of the repeatable job's iterations
+        const iterationCount = repeatOpts.count ? repeatOpts.count + 1 : 1;
+        if (typeof repeatOpts.limit !== 'undefined' &&
+            iterationCount > repeatOpts.limit) {
+            return;
+        }
+        // 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()) {
+            return;
+        }
+        const prevMillis = opts.prevMillis || 0;
+        now = prevMillis < now ? now : prevMillis;
+        const nextMillis = await this.repeatStrategy(now, repeatOpts, name);
+        const { every, pattern } = repeatOpts;
+        const hasImmediately = Boolean((every || pattern) && repeatOpts.immediately);
+        const offset = hasImmediately && every ? now - nextMillis : undefined;
+        if (nextMillis) {
+            // We store the undecorated opts.jobId into the repeat options
+            if (!prevMillis && opts.jobId) {
+                repeatOpts.jobId = opts.jobId;
+            }
+            const legacyRepeatKey = getRepeatConcatOptions(name, repeatOpts);
+            const newRepeatKey = (_b = opts.repeat.key) !== null && _b !== void 0 ? _b : this.hash(legacyRepeatKey);
+            let repeatJobKey;
+            if (override) {
+                repeatJobKey = await this.scripts.addRepeatableJob(newRepeatKey, nextMillis, {
+                    name,
+                    endDate: endDate ? new Date(endDate).getTime() : undefined,
+                    tz: repeatOpts.tz,
+                    pattern,
+                    every,
+                }, legacyRepeatKey);
+            }
+            else {
+                const client = await this.client;
+                repeatJobKey = await this.scripts.updateRepeatableJobMillis(client, newRepeatKey, nextMillis, legacyRepeatKey);
+            }
+            const { immediately } = repeatOpts, filteredRepeatOpts = __rest(repeatOpts, ["immediately"]);
+            return this.createNextJob(name, nextMillis, repeatJobKey, Object.assign(Object.assign({}, opts), { repeat: Object.assign({ offset }, filteredRepeatOpts) }), data, iterationCount, hasImmediately);
+        }
+    }
+    async createNextJob(name, nextMillis, repeatJobKey, opts, data, currentCount, hasImmediately) {
+        //
+        // Generate unique job id for this iteration.
+        //
+        const jobId = this.getRepeatJobKey(name, nextMillis, repeatJobKey, data);
+        const now = Date.now();
+        const delay = nextMillis + (opts.repeat.offset ? opts.repeat.offset : 0) - now;
+        const mergedOpts = Object.assign(Object.assign({}, opts), { jobId, delay: delay < 0 || hasImmediately ? 0 : delay, timestamp: now, prevMillis: nextMillis, repeatJobKey });
+        mergedOpts.repeat = Object.assign(Object.assign({}, opts.repeat), { count: currentCount });
+        return this.Job.create(this, name, data, mergedOpts);
+    }
+    // TODO: remove legacy code in next breaking change
+    getRepeatJobKey(name, nextMillis, repeatJobKey, data) {
+        if (repeatJobKey.split(':').length > 2) {
+            return this.getRepeatJobId({
+                name: name,
+                nextMillis: nextMillis,
+                namespace: this.hash(repeatJobKey),
+                jobId: data === null || data === void 0 ? void 0 : data.id,
+            });
+        }
+        return this.getRepeatDelayedJobId({
+            customKey: repeatJobKey,
+            nextMillis,
+        });
+    }
+    async removeRepeatable(name, repeat, jobId) {
+        var _a;
+        const repeatConcatOptions = getRepeatConcatOptions(name, Object.assign(Object.assign({}, repeat), { jobId }));
+        const repeatJobKey = (_a = repeat.key) !== null && _a !== void 0 ? _a : this.hash(repeatConcatOptions);
+        const legacyRepeatJobId = this.getRepeatJobId({
+            name,
+            nextMillis: '',
+            namespace: this.hash(repeatConcatOptions),
+            jobId: jobId !== null && jobId !== void 0 ? jobId : repeat.jobId,
+            key: repeat.key,
+        });
+        return this.scripts.removeRepeatable(legacyRepeatJobId, repeatConcatOptions, repeatJobKey);
+    }
+    async removeRepeatableByKey(repeatJobKey) {
+        const data = this.keyToData(repeatJobKey);
+        const legacyRepeatJobId = this.getRepeatJobId({
+            name: data.name,
+            nextMillis: '',
+            namespace: this.hash(repeatJobKey),
+            jobId: data.id,
+        });
+        return this.scripts.removeRepeatable(legacyRepeatJobId, '', repeatJobKey);
+    }
+    async getRepeatableData(client, key, next) {
+        const jobData = await client.hgetall(this.toKey('repeat:' + key));
+        if (jobData) {
+            return {
+                key,
+                name: jobData.name,
+                endDate: parseInt(jobData.endDate) || null,
+                tz: jobData.tz || null,
+                pattern: jobData.pattern || null,
+                every: jobData.every || null,
+                next,
+            };
+        }
+        return this.keyToData(key, next);
+    }
+    keyToData(key, next) {
+        const data = key.split(':');
+        const pattern = data.slice(4).join(':') || null;
+        return {
+            key,
+            name: data[0],
+            id: data[1] || null,
+            endDate: parseInt(data[2]) || null,
+            tz: data[3] || null,
+            pattern,
+            next,
+        };
+    }
+    async getRepeatableJobs(start = 0, end = -1, asc = false) {
+        const client = await this.client;
+        const key = this.keys.repeat;
+        const result = asc
+            ? await client.zrange(key, start, end, 'WITHSCORES')
+            : await client.zrevrange(key, start, end, 'WITHSCORES');
+        const jobs = [];
+        for (let i = 0; i < result.length; i += 2) {
+            jobs.push(this.getRepeatableData(client, result[i], parseInt(result[i + 1])));
+        }
+        return Promise.all(jobs);
+    }
+    async getRepeatableCount() {
+        const client = await this.client;
+        return client.zcard(this.toKey('repeat'));
+    }
+    hash(str) {
+        return createHash(this.repeatKeyHashAlgorithm).update(str).digest('hex');
+    }
+    getRepeatDelayedJobId({ nextMillis, customKey, }) {
+        return `repeat:${customKey}:${nextMillis}`;
+    }
+    getRepeatJobId({ name, nextMillis, namespace, jobId, key, }) {
+        const checksum = key !== null && key !== void 0 ? key : this.hash(`${name}${jobId || ''}${namespace}`);
+        return `repeat:${checksum}:${nextMillis}`;
+    }
+}
+function getRepeatConcatOptions(name, repeat) {
+    const endDate = repeat.endDate ? new Date(repeat.endDate).getTime() : '';
+    const tz = repeat.tz || '';
+    const pattern = repeat.pattern;
+    const suffix = (pattern ? pattern : String(repeat.every)) || '';
+    const jobId = repeat.jobId ? repeat.jobId : '';
+    return `${name}:${jobId}:${endDate}:${tz}:${suffix}`;
+}
+export const getNextMillis = (millis, opts) => {
+    const pattern = opts.pattern;
+    if (pattern && opts.every) {
+        throw new Error('Both .pattern and .every options are defined for this repeatable job');
+    }
+    if (opts.every) {
+        return (Math.floor(millis / opts.every) * opts.every +
+            (opts.immediately ? 0 : opts.every));
+    }
+    const currentDate = opts.startDate && new Date(opts.startDate) > new Date(millis)
+        ? new Date(opts.startDate)
+        : new Date(millis);
+    const interval = parseExpression(pattern, Object.assign(Object.assign({}, opts), { currentDate }));
+    try {
+        if (opts.immediately) {
+            return new Date().getTime();
+        }
+        else {
+            return interval.next().getTime();
+        }
+    }
+    catch (e) {
+        // Ignore error
+    }
+};
+//# sourceMappingURL=repeat.js.map

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

@@ -0,0 +1,4 @@
+import { ChildPool } from './child-pool';
+import { Job } from './job';
+declare const sandbox: <T, R, N extends string>(processFile: any, childPool: ChildPool) => (job: Job<T, R, N>, token?: string) => Promise<R>;
+export default sandbox;

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

@@ -0,0 +1,73 @@
+import { ChildCommand, ParentCommand } from '../enums';
+const sandbox = (processFile, childPool) => {
+    return async function process(job, token) {
+        let child;
+        let msgHandler;
+        let exitHandler;
+        try {
+            const done = new Promise((resolve, reject) => {
+                const initChild = async () => {
+                    try {
+                        exitHandler = (exitCode, signal) => {
+                            reject(new Error('Unexpected exit code: ' + exitCode + ' signal: ' + signal));
+                        };
+                        child = await childPool.retain(processFile, 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;
+                                }
+                                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;
+                            }
+                        };
+                        child.on('message', msgHandler);
+                        child.send({
+                            cmd: ChildCommand.Start,
+                            job: job.asJSONSandbox(),
+                            token,
+                        });
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                };
+                initChild();
+            });
+            await done;
+            return done;
+        }
+        finally {
+            if (child) {
+                child.off('message', msgHandler);
+                child.off('exit', exitHandler);
+                if (child.exitCode !== null || /SIG.*/.test(`${child.signalCode}`)) {
+                    childPool.remove(child);
+                }
+                else {
+                    childPool.release(child);
+                }
+            }
+        }
+    };
+};
+export default sandbox;
+//# sourceMappingURL=sandbox.js.map