@tachybase/plugin-adapter-bullmq 0.23.8

package/dist/node_modules/bullmq/dist/cjs/classes/main-base.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Wrapper for sandboxing.
+ *
+ */
+const child_processor_1 = require("./child-processor");
+const enums_1 = require("../enums");
+const utils_1 = require("../utils");
+exports.default = (send, receiver) => {
+    const childProcessor = new child_processor_1.ChildProcessor(send);
+    receiver === null || receiver === void 0 ? void 0 : receiver.on('message', async (msg) => {
+        try {
+            switch (msg.cmd) {
+                case enums_1.ChildCommand.Init:
+                    await childProcessor.init(msg.value);
+                    break;
+                case enums_1.ChildCommand.Start:
+                    await childProcessor.start(msg.job, msg === null || msg === void 0 ? void 0 : msg.token);
+                    break;
+                case enums_1.ChildCommand.Stop:
+                    break;
+            }
+        }
+        catch (err) {
+            console.error('Error handling child message');
+        }
+    });
+    process.on('SIGTERM', () => childProcessor.waitForCurrentJobAndExit());
+    process.on('SIGINT', () => childProcessor.waitForCurrentJobAndExit());
+    process.on('uncaughtException', async (err) => {
+        if (typeof err !== 'object') {
+            err = new Error((0, utils_1.toString)(err));
+        }
+        await send({
+            cmd: enums_1.ParentCommand.Failed,
+            value: (0, utils_1.errorToJSON)(err),
+        });
+        // An uncaughException leaves this process in a potentially undetermined state so
+        // we must exit
+        process.exit();
+    });
+};
+//# sourceMappingURL=main-base.js.map

package/dist/node_modules/bullmq/dist/cjs/classes/main-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/node_modules/bullmq/dist/cjs/classes/main-worker.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Worker Thread wrapper for sandboxing
+ *
+ */
+const worker_threads_1 = require("worker_threads");
+const main_base_1 = require("./main-base");
+(0, main_base_1.default)(async (msg) => worker_threads_1.parentPort.postMessage(msg), worker_threads_1.parentPort);
+//# sourceMappingURL=main-worker.js.map

package/dist/node_modules/bullmq/dist/cjs/classes/main.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/node_modules/bullmq/dist/cjs/classes/main.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Child process wrapper for sandboxing.
+ *
+ */
+const utils_1 = require("../utils");
+const main_base_1 = require("./main-base");
+(0, main_base_1.default)((msg) => (0, utils_1.childSend)(process, msg), process);
+//# sourceMappingURL=main.js.map

package/dist/node_modules/bullmq/dist/cjs/classes/queue-base.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueueBase = void 0;
+const events_1 = require("events");
+const utils_1 = require("../utils");
+const redis_connection_1 = require("./redis-connection");
+const job_1 = require("./job");
+const queue_keys_1 = require("./queue-keys");
+const scripts_1 = require("./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.
+ *
+ */
+class QueueBase extends events_1.EventEmitter {
+    /**
+     *
+     * @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, opts = { connection: {} }, Connection = redis_connection_1.RedisConnection, hasBlockingConnection = false) {
+        super();
+        this.name = name;
+        this.opts = opts;
+        this.closed = false;
+        this.hasBlockingConnection = false;
+        this.hasBlockingConnection = hasBlockingConnection;
+        this.opts = Object.assign({ prefix: 'bull' }, opts);
+        if (!name) {
+            throw new Error('Queue name must be provided');
+        }
+        if (name.includes(':')) {
+            throw new Error('Queue name cannot contain :');
+        }
+        this.connection = new Connection(opts.connection, (0, utils_1.isRedisInstance)(opts.connection), hasBlockingConnection, opts.skipVersionCheck);
+        this.connection.on('error', (error) => this.emit('error', error));
+        this.connection.on('close', () => {
+            if (!this.closing) {
+                this.emit('ioredis:close');
+            }
+        });
+        const queueKeys = new queue_keys_1.QueueKeys(opts.prefix);
+        this.qualifiedName = queueKeys.getQueueQualifiedName(name);
+        this.keys = queueKeys.getKeys(name);
+        this.toKey = (type) => queueKeys.toKey(name, type);
+        this.setScripts();
+    }
+    /**
+     * Returns a promise that resolves to a redis client. Normally used only by subclasses.
+     */
+    get client() {
+        return this.connection.client;
+    }
+    setScripts() {
+        this.scripts = new scripts_1.Scripts(this);
+    }
+    /**
+     * Returns the version of the Redis instance the client is connected to,
+     */
+    get redisVersion() {
+        return this.connection.redisVersion;
+    }
+    /**
+     * Helper to easily extend Job class calls.
+     */
+    get Job() {
+        return job_1.Job;
+    }
+    /**
+     * Emits an event. Normally used by subclasses to emit events.
+     *
+     * @param event - The emitted event.
+     * @param args -
+     * @returns
+     */
+    emit(event, ...args) {
+        try {
+            return super.emit(event, ...args);
+        }
+        catch (err) {
+            try {
+                return super.emit('error', err);
+            }
+            catch (err) {
+                // We give up if the error event also throws an exception.
+                console.error(err);
+                return false;
+            }
+        }
+    }
+    waitUntilReady() {
+        return this.client;
+    }
+    base64Name() {
+        return Buffer.from(this.name).toString('base64');
+    }
+    clientName(suffix = '') {
+        const queueNameBase64 = this.base64Name();
+        return `${this.opts.prefix}:${queueNameBase64}${suffix}`;
+    }
+    /**
+     *
+     * Closes the connection and returns a promise that resolves when the connection is closed.
+     */
+    async close() {
+        if (!this.closing) {
+            this.closing = this.connection.close();
+        }
+        await this.closing;
+        this.closed = true;
+    }
+    /**
+     *
+     * Force disconnects a connection.
+     */
+    disconnect() {
+        return this.connection.disconnect();
+    }
+    async checkConnectionError(fn, delayInMs = utils_1.DELAY_TIME_5) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            if ((0, utils_1.isNotConnectionError)(error)) {
+                this.emit('error', error);
+            }
+            if (!this.closing && delayInMs) {
+                await (0, utils_1.delay)(delayInMs);
+            }
+            else {
+                return;
+            }
+        }
+    }
+    /**
+     * Wraps the code with telemetry and provides a span for configuration.
+     *
+     * @param spanKind - kind of the span: Producer, Consumer, Internal
+     * @param operation - operation name (such as add, process, etc)
+     * @param destination - destination name (normally the queue name)
+     * @param callback - code to wrap with telemetry
+     * @param srcPropagationMedatada -
+     * @returns
+     */
+    trace(spanKind, operation, destination, callback, srcPropagationMetadata) {
+        return (0, utils_1.trace)(this.opts.telemetry, spanKind, this.name, operation, destination, callback, srcPropagationMetadata);
+    }
+}
+exports.QueueBase = QueueBase;
+//# sourceMappingURL=queue-base.js.map

package/dist/node_modules/bullmq/dist/cjs/classes/queue-events-producer.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueueEventsProducer = void 0;
+const tslib_1 = require("tslib");
+const queue_base_1 = require("./queue-base");
+/**
+ * The QueueEventsProducer class is used for publishing custom events.
+ */
+class QueueEventsProducer extends queue_base_1.QueueBase {
+    constructor(name, opts = {
+        connection: {},
+    }, Connection) {
+        super(name, Object.assign({ blockingConnection: false }, opts), Connection);
+        this.opts = opts;
+    }
+    /**
+     * Publish custom event to be processed in QueueEvents.
+     * @param argsObj - Event payload
+     * @param maxEvents - Max quantity of events to be saved
+     */
+    async publishEvent(argsObj, maxEvents = 1000) {
+        const client = await this.client;
+        const key = this.keys.events;
+        const { eventName } = argsObj, restArgs = tslib_1.__rest(argsObj, ["eventName"]);
+        const args = ['MAXLEN', '~', maxEvents, '*', 'event', eventName];
+        for (const [key, value] of Object.entries(restArgs)) {
+            args.push(key, value);
+        }
+        await client.xadd(key, ...args);
+    }
+    /**
+     * Closes the connection and returns a promise that resolves when the connection is closed.
+     */
+    async close() {
+        if (!this.closing) {
+            this.closing = this.connection.close();
+        }
+        await this.closing;
+    }
+}
+exports.QueueEventsProducer = QueueEventsProducer;
+//# sourceMappingURL=queue-events-producer.js.map

package/dist/node_modules/bullmq/dist/cjs/classes/queue-events.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueueEvents = void 0;
+const tslib_1 = require("tslib");
+const utils_1 = require("../utils");
+const queue_base_1 = require("./queue-base");
+/**
+ * The QueueEvents class is used for listening to the global events
+ * emitted by a given queue.
+ *
+ * This class requires a dedicated redis connection.
+ *
+ */
+class QueueEvents extends queue_base_1.QueueBase {
+    constructor(name, _a = {
+        connection: {},
+    }, Connection) {
+        var { connection, autorun = true } = _a, opts = tslib_1.__rest(_a, ["connection", "autorun"]);
+        super(name, Object.assign(Object.assign({}, opts), { connection: (0, utils_1.isRedisInstance)(connection)
+                ? connection.duplicate()
+                : connection }), Connection, true);
+        this.running = false;
+        this.opts = Object.assign({
+            blockingTimeout: 10000,
+        }, this.opts);
+        if (autorun) {
+            this.run().catch(error => this.emit('error', error));
+        }
+    }
+    emit(event, ...args) {
+        return super.emit(event, ...args);
+    }
+    off(eventName, listener) {
+        super.off(eventName, listener);
+        return this;
+    }
+    on(event, listener) {
+        super.on(event, listener);
+        return this;
+    }
+    once(event, listener) {
+        super.once(event, listener);
+        return this;
+    }
+    /**
+     * Manually starts running the event consumming loop. This shall be used if you do not
+     * use the default "autorun" option on the constructor.
+     */
+    async run() {
+        if (!this.running) {
+            try {
+                this.running = true;
+                const client = await this.client;
+                // TODO: Planed for deprecation as it has no really a use case
+                try {
+                    await client.client('SETNAME', this.clientName(utils_1.QUEUE_EVENT_SUFFIX));
+                }
+                catch (err) {
+                    if (!utils_1.clientCommandMessageReg.test(err.message)) {
+                        throw err;
+                    }
+                }
+                await this.consumeEvents(client);
+            }
+            catch (error) {
+                this.running = false;
+                throw error;
+            }
+        }
+        else {
+            throw new Error('Queue Events is already running.');
+        }
+    }
+    async consumeEvents(client) {
+        const opts = this.opts;
+        const key = this.keys.events;
+        let id = opts.lastEventId || '$';
+        while (!this.closing) {
+            // Cast to actual return type, see: https://github.com/DefinitelyTyped/DefinitelyTyped/issues/44301
+            const data = await this.checkConnectionError(() => client.xread('BLOCK', opts.blockingTimeout, 'STREAMS', key, id));
+            if (data) {
+                const stream = data[0];
+                const events = stream[1];
+                for (let i = 0; i < events.length; i++) {
+                    id = events[i][0];
+                    const args = (0, utils_1.array2obj)(events[i][1]);
+                    //
+                    // TODO: we may need to have a separate xtream for progress data
+                    // to avoid this hack.
+                    switch (args.event) {
+                        case 'progress':
+                            args.data = JSON.parse(args.data);
+                            break;
+                        case 'completed':
+                            args.returnvalue = JSON.parse(args.returnvalue);
+                            break;
+                    }
+                    const { event } = args, restArgs = tslib_1.__rest(args, ["event"]);
+                    if (event === 'drained') {
+                        this.emit(event, id);
+                    }
+                    else {
+                        this.emit(event, restArgs, id);
+                        if (restArgs.jobId) {
+                            this.emit(`${event}:${restArgs.jobId}`, restArgs, id);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Stops consuming events and close the underlying Redis connection if necessary.
+     *
+     * @returns
+     */
+    close() {
+        if (!this.closing) {
+            this.closing = this.disconnect();
+        }
+        return this.closing;
+    }
+}
+exports.QueueEvents = QueueEvents;
+//# sourceMappingURL=queue-events.js.map