@tachybase/plugin-print-template 0.23.8

package/dist/node_modules/bullmq/dist/esm/classes/main-base.d.ts

@@ -0,0 +1,4 @@
+declare const _default: (send: (msg: any) => Promise<void>, receiver: {
+    on: (evt: 'message', cb: (msg: any) => void) => void;
+}) => void;
+export default _default;

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

@@ -0,0 +1,42 @@
+/**
+ * Wrapper for sandboxing.
+ *
+ */
+import { ChildProcessor } from './child-processor';
+import { ParentCommand, ChildCommand } from '../enums';
+import { errorToJSON, toString } from '../utils';
+export default (send, receiver) => {
+    const childProcessor = new ChildProcessor(send);
+    receiver === null || receiver === void 0 ? void 0 : receiver.on('message', async (msg) => {
+        try {
+            switch (msg.cmd) {
+                case ChildCommand.Init:
+                    await childProcessor.init(msg.value);
+                    break;
+                case ChildCommand.Start:
+                    await childProcessor.start(msg.job, msg === null || msg === void 0 ? void 0 : msg.token);
+                    break;
+                case 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(toString(err));
+        }
+        await send({
+            cmd: ParentCommand.Failed,
+            value: 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/esm/classes/main-worker.d.ts

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

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

@@ -0,0 +1,8 @@
+/**
+ * Worker Thread wrapper for sandboxing
+ *
+ */
+import { parentPort } from 'worker_threads';
+import mainBase from './main-base';
+mainBase(async (msg) => parentPort.postMessage(msg), parentPort);
+//# sourceMappingURL=main-worker.js.map

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

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

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

@@ -0,0 +1,8 @@
+/**
+ * Child process wrapper for sandboxing.
+ *
+ */
+import { childSend } from '../utils';
+import mainBase from './main-base';
+mainBase((msg) => childSend(process, msg), process);
+//# sourceMappingURL=main.js.map

package/dist/node_modules/bullmq/dist/esm/classes/queue-base.d.ts

@@ -0,0 +1,83 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { QueueBaseOptions, RedisClient, Span } from '../interfaces';
+import { MinimalQueue } from '../types';
+import { RedisConnection } from './redis-connection';
+import { Job } from './job';
+import { KeysMap } from './queue-keys';
+import { Scripts } from './scripts';
+import { SpanKind } from '../enums';
+/**
+ * @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> | undefined;
+    protected closed: boolean;
+    protected hasBlockingConnection: boolean;
+    protected scripts: Scripts;
+    protected connection: RedisConnection;
+    readonly qualifiedName: string;
+    /**
+     *
+     * @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, hasBlockingConnection?: boolean);
+    /**
+     * Returns a promise that resolves to a redis client. Normally used only by subclasses.
+     */
+    get client(): Promise<RedisClient>;
+    protected setScripts(): void;
+    /**
+     * 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;
+    /**
+     *
+     * 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 | undefined>;
+    /**
+     * 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<T>(spanKind: SpanKind, operation: string, destination: string, callback: (span?: Span, dstPropagationMetadata?: string) => Promise<T> | T, srcPropagationMetadata?: string): Promise<T | Promise<T>>;
+}

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

@@ -0,0 +1,151 @@
+import { EventEmitter } from 'events';
+import { delay, DELAY_TIME_5, isNotConnectionError, isRedisInstance, trace, } from '../utils';
+import { RedisConnection } from './redis-connection';
+import { Job } from './job';
+import { QueueKeys } 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 class QueueBase extends 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 = 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, 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 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(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;
+    }
+    /**
+     * 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 = DELAY_TIME_5) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            if (isNotConnectionError(error)) {
+                this.emit('error', error);
+            }
+            if (!this.closing && delayInMs) {
+                await 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 trace(this.opts.telemetry, spanKind, this.name, operation, destination, callback, srcPropagationMetadata);
+    }
+}
+//# sourceMappingURL=queue-base.js.map

package/dist/node_modules/bullmq/dist/esm/classes/queue-events-producer.d.ts

@@ -0,0 +1,21 @@
+import { QueueBaseOptions } from '../interfaces';
+import { QueueBase } from './queue-base';
+import { RedisConnection } from './redis-connection';
+/**
+ * The QueueEventsProducer class is used for publishing custom events.
+ */
+export declare class QueueEventsProducer extends QueueBase {
+    constructor(name: string, opts?: QueueBaseOptions, Connection?: typeof RedisConnection);
+    /**
+     * Publish custom event to be processed in QueueEvents.
+     * @param argsObj - Event payload
+     * @param maxEvents - Max quantity of events to be saved
+     */
+    publishEvent<T extends {
+        eventName: string;
+    }>(argsObj: T, maxEvents?: number): Promise<void>;
+    /**
+     * Closes the connection and returns a promise that resolves when the connection is closed.
+     */
+    close(): Promise<void>;
+}

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

@@ -0,0 +1,38 @@
+import { __rest } from "tslib";
+import { QueueBase } from './queue-base';
+/**
+ * The QueueEventsProducer class is used for publishing custom events.
+ */
+export class QueueEventsProducer extends 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 = __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;
+    }
+}
+//# sourceMappingURL=queue-events-producer.js.map

package/dist/node_modules/bullmq/dist/esm/classes/queue-events.d.ts

@@ -0,0 +1,201 @@
+import { IoredisListener, QueueEventsOptions } from '../interfaces';
+import { QueueBase } from './queue-base';
+import { RedisConnection } from './redis-connection';
+export interface QueueEventsListener extends IoredisListener {
+    /**
+     * Listen to 'active' event.
+     *
+     * This event is triggered when a job enters the 'active' state.
+     */
+    active: (args: {
+        jobId: string;
+        prev?: string;
+    }, id: string) => void;
+    /**
+     * Listen to 'added' event.
+     *
+     * This event is triggered when a job is created.
+     */
+    added: (args: {
+        jobId: string;
+        name: string;
+    }, id: string) => void;
+    /**
+     * Listen to 'cleaned' event.
+     *
+     * This event is triggered when a cleaned method is triggered.
+     */
+    cleaned: (args: {
+        count: string;
+    }, id: string) => void;
+    /**
+     * Listen to 'completed' event.
+     *
+     * This event is triggered when a job has successfully completed.
+     */
+    completed: (args: {
+        jobId: string;
+        returnvalue: string;
+        prev?: string;
+    }, id: string) => void;
+    /**
+     * Listen to 'debounced' event.
+     * @deprecated use deduplicated event
+     *
+     * This event is triggered when a job is debounced because debounceId still existed.
+     */
+    debounced: (args: {
+        jobId: string;
+        debounceId: string;
+    }, id: string) => void;
+    /**
+     * Listen to 'deduplicated' event.
+     *
+     * This event is triggered when a job is deduplicated because deduplicatedId still existed.
+     */
+    deduplicated: (args: {
+        jobId: string;
+        deduplicationId: string;
+    }, id: string) => void;
+    /**
+     * Listen to 'delayed' event.
+     *
+     * This event is triggered when a job is delayed.
+     */
+    delayed: (args: {
+        jobId: string;
+        delay: number;
+    }, id: string) => void;
+    /**
+     * Listen to 'drained' event.
+     *
+     * This event is triggered when the queue has drained the waiting list.
+     * Note that there could still be delayed jobs waiting their timers to expire
+     * and this event will still be triggered as long as the waiting list has emptied.
+     */
+    drained: (id: string) => void;
+    /**
+     * Listen to 'duplicated' event.
+     *
+     * This event is triggered when a job is not created because it already exist.
+     */
+    duplicated: (args: {
+        jobId: string;
+    }, id: string) => void;
+    /**
+     * Listen to 'error' event.
+     *
+     * This event is triggered when an exception is thrown.
+     */
+    error: (args: Error) => void;
+    /**
+     * Listen to 'failed' event.
+     *
+     * This event is triggered when a job has thrown an exception.
+     */
+    failed: (args: {
+        jobId: string;
+        failedReason: string;
+        prev?: string;
+    }, id: string) => void;
+    /**
+     * Listen to 'paused' event.
+     *
+     * This event is triggered when a queue is paused.
+     */
+    paused: (args: {}, id: string) => void;
+    /**
+     * Listen to 'progress' event.
+     *
+     * This event is triggered when a job updates it progress, i.e. the
+     * Job##updateProgress() method is called. This is useful to notify
+     * progress or any other data from within a processor to the rest of the
+     * world.
+     */
+    progress: (args: {
+        jobId: string;
+        data: number | object;
+    }, id: string) => void;
+    /**
+     * Listen to 'removed' event.
+     *
+     * This event is triggered when a job has been manually
+     * removed from the queue.
+     */
+    removed: (args: {
+        jobId: string;
+        prev: string;
+    }, id: string) => void;
+    /**
+     * Listen to 'resumed' event.
+     *
+     * This event is triggered when a queue is resumed.
+     */
+    resumed: (args: {}, id: string) => void;
+    /**
+     * Listen to 'retries-exhausted' event.
+     *
+     * This event is triggered when a job has retried the maximum attempts.
+     */
+    'retries-exhausted': (args: {
+        jobId: string;
+        attemptsMade: string;
+    }, id: string) => void;
+    /**
+     * Listen to 'stalled' event.
+     *
+     * This event is triggered when a job has been moved from 'active' back
+     * to 'waiting'/'failed' due to the processor not being able to renew
+     * the lock on the said job.
+     */
+    stalled: (args: {
+        jobId: string;
+    }, id: string) => void;
+    /**
+     * Listen to 'waiting' event.
+     *
+     * This event is triggered when a job enters the 'waiting' state.
+     */
+    waiting: (args: {
+        jobId: string;
+        prev?: string;
+    }, id: string) => void;
+    /**
+     * Listen to 'waiting-children' event.
+     *
+     * This event is triggered when a job enters the 'waiting-children' state.
+     */
+    'waiting-children': (args: {
+        jobId: string;
+    }, id: string) => void;
+}
+type CustomParameters<T> = T extends (...args: infer Args) => void ? Args : never;
+type KeyOf<T extends object> = Extract<keyof T, string>;
+/**
+ * The QueueEvents class is used for listening to the global events
+ * emitted by a given queue.
+ *
+ * This class requires a dedicated redis connection.
+ *
+ */
+export declare class QueueEvents extends QueueBase {
+    private running;
+    constructor(name: string, { connection, autorun, ...opts }?: QueueEventsOptions, Connection?: typeof RedisConnection);
+    emit<QEL extends QueueEventsListener = QueueEventsListener, U extends KeyOf<QEL> = KeyOf<QEL>>(event: U, ...args: CustomParameters<QEL[U]>): boolean;
+    off<QEL extends QueueEventsListener = QueueEventsListener, U extends KeyOf<QEL> = KeyOf<QEL>>(eventName: U, listener: QEL[U]): this;
+    on<QEL extends QueueEventsListener = QueueEventsListener, U extends KeyOf<QEL> = KeyOf<QEL>>(event: U, listener: QEL[U]): this;
+    once<QEL extends QueueEventsListener = QueueEventsListener, U extends KeyOf<QEL> = KeyOf<QEL>>(event: U, listener: QEL[U]): this;
+    /**
+     * Manually starts running the event consumming loop. This shall be used if you do not
+     * use the default "autorun" option on the constructor.
+     */
+    run(): Promise<void>;
+    private consumeEvents;
+    /**
+     * Stops consuming events and close the underlying Redis connection if necessary.
+     *
+     * @returns
+     */
+    close(): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,121 @@
+import { __rest } from "tslib";
+import { array2obj, clientCommandMessageReg, isRedisInstance, QUEUE_EVENT_SUFFIX, } from '../utils';
+import { QueueBase } from './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.
+ *
+ */
+export class QueueEvents extends QueueBase {
+    constructor(name, _a = {
+        connection: {},
+    }, Connection) {
+        var { connection, autorun = true } = _a, opts = __rest(_a, ["connection", "autorun"]);
+        super(name, Object.assign(Object.assign({}, opts), { connection: 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(QUEUE_EVENT_SUFFIX));
+                }
+                catch (err) {
+                    if (!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 = 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 = __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;
+    }
+}
+//# sourceMappingURL=queue-events.js.map