@rvoh/psychic-workers 0.2.1

package/dist/esm/src/background/index.js

@@ -0,0 +1,524 @@
+import { closeAllDbConnections, compact, pascalize } from '@rvoh/dream';
+import { PsychicApplication } from '@rvoh/psychic';
+import { Job, Queue, Worker } from 'bullmq';
+import { Cluster } from 'ioredis';
+import NoQueueForSpecifiedQueueName from '../error/background/NoQueueForSpecifiedQueueName.js';
+import NoQueueForSpecifiedWorkstream from '../error/background/NoQueueForSpecifiedWorkstream.js';
+import EnvInternal from '../helpers/EnvInternal.js';
+import PsychicApplicationWorkers from '../psychic-application-workers/index.js';
+class DefaultBullMQNativeOptionsMissingQueueConnectionAndDefaultQueueConnection extends Error {
+    get message() {
+        return `
+Native BullMQ options don't include a default queue connection, and the
+default config does not include a queue connection
+`;
+    }
+}
+class NamedBullMQNativeOptionsMissingQueueConnectionAndDefaultQueueConnection extends Error {
+    queueName;
+    constructor(queueName) {
+        super();
+        this.queueName = queueName;
+    }
+    get message() {
+        return `
+Native BullMQ options don't include a default queue connection, and the
+${this.queueName} queue does not include a queue connection
+`;
+    }
+}
+class ActivatingBackgroundWorkersWithoutDefaultWorkerConnection extends Error {
+    get message() {
+        return `
+defaultWorkerConnection is required when activating workers. For example,
+it may be omitted on webserver instances, but is required on worker instances.
+`;
+    }
+}
+class ActivatingNamedQueueBackgroundWorkersWithoutWorkerConnection extends Error {
+    queueName;
+    constructor(queueName) {
+        super();
+        this.queueName = queueName;
+    }
+    get message() {
+        return `
+defaultWorkerConnection is missing, and the ${this.queueName} queue does not
+specify a workerConnection. A worker connection isrequired when activating workers.
+For example, it may be omitted on webserver instances, but is required on worker instances.
+`;
+    }
+}
+export class Background {
+    static get defaultQueueName() {
+        const psychicWorkersApp = PsychicApplicationWorkers.getOrFail();
+        return `${pascalize(psychicWorkersApp.psychicApp.appName)}BackgroundJobQueue`;
+    }
+    static get Worker() {
+        const psychicWorkersApp = PsychicApplicationWorkers.getOrFail();
+        return (psychicWorkersApp.backgroundOptions.providers?.Worker || Worker);
+    }
+    static get Queue() {
+        const psychicWorkersApp = PsychicApplicationWorkers.getOrFail();
+        return (psychicWorkersApp.backgroundOptions.providers?.Queue || Queue);
+    }
+    /**
+     * Used when adding jobs to the default queue
+     */
+    defaultQueue = null;
+    /**
+     * Used when adding jobs to the default transitional queue
+     */
+    defaultTransitionalQueue = null;
+    /**
+     * Used when adding jobs to a named queue
+     */
+    namedQueues = {};
+    groupNames = {};
+    workstreamNames = [];
+    /**
+     * Used when adding jobs to a named transitioanl queue
+     */
+    namedTransitionalQueues = {};
+    _workers = [];
+    redisConnections = [];
+    connect({ activateWorkers = false, } = {}) {
+        if (this.defaultQueue)
+            return;
+        const psychicWorkersApp = PsychicApplicationWorkers.getOrFail();
+        const defaultBullMQQueueOptions = psychicWorkersApp.backgroundOptions.defaultBullMQQueueOptions || {};
+        if (psychicWorkersApp.backgroundOptions.nativeBullMQ) {
+            this.nativeBullMQConnect(defaultBullMQQueueOptions, psychicWorkersApp.backgroundOptions, { activateWorkers });
+        }
+        else {
+            this.simpleConnect(defaultBullMQQueueOptions, psychicWorkersApp.backgroundOptions, { activateWorkers });
+        }
+    }
+    get queues() {
+        return compact([
+            this.defaultQueue,
+            ...Object.values(this.namedQueues).map(queue => queue),
+            this.defaultTransitionalQueue,
+            ...Object.values(this.namedTransitionalQueues).map(queue => queue),
+        ]);
+    }
+    get workers() {
+        return [...this._workers];
+    }
+    async shutdownAndExit() {
+        await this.shutdown();
+        process.exit();
+    }
+    async shutdown() {
+        await Promise.all(this._workers.map(worker => worker.close()));
+        const psychicWorkersApp = PsychicApplicationWorkers.getOrFail();
+        for (const hook of psychicWorkersApp.hooks.workerShutdown) {
+            await hook();
+        }
+        await closeAllDbConnections();
+        await this.closeAllRedisConnections();
+    }
+    async closeAllRedisConnections() {
+        for (const queue of this.queues) {
+            await queue.close();
+        }
+        for (const worker of this.workers) {
+            await worker.close();
+        }
+        for (const connection of this.redisConnections) {
+            try {
+                connection.disconnect();
+            }
+            catch {
+                // noop
+            }
+        }
+    }
+    simpleConnect(defaultBullMQQueueOptions, backgroundOptions, { activateWorkers = false, activatingTransitionalWorkstreams = false, }) {
+        const defaultQueueConnection = backgroundOptions.defaultQueueConnection;
+        const defaultWorkerConnection = backgroundOptions.defaultWorkerConnection;
+        if (defaultQueueConnection)
+            this.redisConnections.push(defaultQueueConnection);
+        if (defaultWorkerConnection)
+            this.redisConnections.push(defaultWorkerConnection);
+        // transitional queues must have the same names they had prior to making them
+        // transitional since the name is what identifies the queues and enables the
+        // queues to be worked off
+        const formattedQueueName = nameToRedisQueueName(Background.defaultQueueName, defaultQueueConnection);
+        ///////////////////////////////
+        // create default workstream //
+        ///////////////////////////////
+        const defaultQueue = new Background.Queue(formattedQueueName, {
+            ...defaultBullMQQueueOptions,
+            connection: defaultQueueConnection,
+        });
+        if (activatingTransitionalWorkstreams) {
+            this.defaultTransitionalQueue = defaultQueue;
+        }
+        else {
+            this.defaultQueue = defaultQueue;
+        }
+        ////////////////////////////////////
+        // end: create default workstream //
+        ////////////////////////////////////
+        /////////////////////////////
+        // create default workers //
+        /////////////////////////////
+        if (activateWorkers) {
+            if (!defaultWorkerConnection)
+                throw new ActivatingBackgroundWorkersWithoutDefaultWorkerConnection();
+            const workerCount = backgroundOptions.defaultWorkstream?.workerCount ?? 1;
+            for (let i = 0; i < workerCount; i++) {
+                this._workers.push(new Background.Worker(formattedQueueName, job => this.doWork(job), {
+                    connection: defaultWorkerConnection,
+                    concurrency: backgroundOptions.defaultWorkstream?.concurrency || 1,
+                }));
+            }
+        }
+        /////////////////////////////////
+        // end: create default workers //
+        /////////////////////////////////
+        //////////////////////////////
+        // create named workstreams //
+        //////////////////////////////
+        const namedWorkstreams = backgroundOptions.namedWorkstreams || [];
+        namedWorkstreams.forEach(namedWorkstream => {
+            if (namedWorkstream.queueConnection)
+                this.redisConnections.push(namedWorkstream.queueConnection);
+            if (namedWorkstream.workerConnection)
+                this.redisConnections.push(namedWorkstream.workerConnection);
+            const namedWorkstreamQueueConnection = namedWorkstream.queueConnection || defaultQueueConnection;
+            const namedWorkstreamWorkerConnection = namedWorkstream.workerConnection || defaultWorkerConnection;
+            // transitional queues must have the same names they had prior to making them
+            // transitional since the name is what identifies the queues and enables the
+            // queues to be worked off
+            const namedWorkstreamFormattedQueueName = nameToRedisQueueName(namedWorkstream.name, namedWorkstreamQueueConnection);
+            const namedQueue = new Background.Queue(namedWorkstreamFormattedQueueName, {
+                ...defaultBullMQQueueOptions,
+                connection: namedWorkstreamQueueConnection,
+            });
+            if (activatingTransitionalWorkstreams) {
+                this.namedTransitionalQueues[namedWorkstream.name] = namedQueue;
+            }
+            else {
+                this.namedQueues[namedWorkstream.name] = namedQueue;
+                this.workstreamNames.push(namedWorkstream.name);
+            }
+            //////////////////////////
+            // create named workers //
+            //////////////////////////
+            if (activateWorkers) {
+                if (!namedWorkstreamWorkerConnection)
+                    throw new ActivatingNamedQueueBackgroundWorkersWithoutWorkerConnection(namedWorkstream.name);
+                const workerCount = namedWorkstream.workerCount ?? 1;
+                for (let i = 0; i < workerCount; i++) {
+                    this._workers.push(new Background.Worker(namedWorkstreamFormattedQueueName, job => this.doWork(job), {
+                        group: {
+                            id: namedWorkstream.name,
+                            limit: namedWorkstream.rateLimit,
+                        },
+                        connection: namedWorkstreamWorkerConnection,
+                        concurrency: namedWorkstream.concurrency || 1,
+                        // explicitly typing as WorkerOptions because Psychic can't be aware of BullMQ Pro options
+                    }));
+                }
+            }
+            ///////////////////////////////
+            // end: create named workers //
+            ///////////////////////////////
+        });
+        ///////////////////////////////////
+        // end: create named workstreams //
+        ///////////////////////////////////
+        const transitionalWorkstreams = backgroundOptions
+            .transitionalWorkstreams;
+        if (transitionalWorkstreams) {
+            this.simpleConnect(defaultBullMQQueueOptions, transitionalWorkstreams, {
+                activateWorkers,
+                activatingTransitionalWorkstreams: true,
+            });
+        }
+    }
+    nativeBullMQConnect(defaultBullMQQueueOptions, backgroundOptions, { activateWorkers = false, }) {
+        const nativeBullMQ = backgroundOptions.nativeBullMQ;
+        const defaultQueueConnection = nativeBullMQ.defaultQueueOptions?.queueConnection || backgroundOptions.defaultQueueConnection;
+        const defaultWorkerConnection = nativeBullMQ.defaultQueueOptions?.workerConnection || backgroundOptions.defaultWorkerConnection;
+        if (defaultQueueConnection)
+            this.redisConnections.push(defaultQueueConnection);
+        if (defaultWorkerConnection)
+            this.redisConnections.push(defaultWorkerConnection);
+        if (!defaultQueueConnection)
+            throw new DefaultBullMQNativeOptionsMissingQueueConnectionAndDefaultQueueConnection();
+        const formattedQueueName = nameToRedisQueueName(Background.defaultQueueName, defaultQueueConnection);
+        //////////////////////////
+        // create default queue //
+        //////////////////////////
+        this.defaultQueue = new Background.Queue(formattedQueueName, {
+            ...defaultBullMQQueueOptions,
+            ...(nativeBullMQ.defaultQueueOptions || {}),
+            connection: defaultQueueConnection,
+        });
+        ///////////////////////////////
+        // end: create default queue //
+        ///////////////////////////////
+        /////////////////////////////
+        // create default workers //
+        /////////////////////////////
+        if (activateWorkers) {
+            if (!defaultWorkerConnection)
+                throw new ActivatingBackgroundWorkersWithoutDefaultWorkerConnection();
+            const workerCount = nativeBullMQ.defaultWorkerCount ?? 1;
+            for (let i = 0; i < workerCount; i++) {
+                this._workers.push(new Background.Worker(formattedQueueName, job => this.doWork(job), {
+                    ...(backgroundOptions.nativeBullMQ.defaultWorkerOptions || {}),
+                    connection: defaultWorkerConnection,
+                }));
+            }
+        }
+        /////////////////////////////////
+        // end: create default workers //
+        /////////////////////////////////
+        /////////////////////////
+        // create named queues //
+        /////////////////////////
+        const namedQueueOptionsMap = nativeBullMQ.namedQueueOptions || {};
+        Object.keys(namedQueueOptionsMap).forEach(queueName => {
+            const namedQueueOptions = namedQueueOptionsMap[queueName];
+            if (namedQueueOptions.queueConnection)
+                this.redisConnections.push(namedQueueOptions.queueConnection);
+            if (namedQueueOptions.workerConnection)
+                this.redisConnections.push(namedQueueOptions.workerConnection);
+            const namedQueueConnection = namedQueueOptions.queueConnection || defaultQueueConnection;
+            const namedWorkerConnection = namedQueueOptions.workerConnection || defaultWorkerConnection;
+            if (!namedQueueConnection)
+                throw new NamedBullMQNativeOptionsMissingQueueConnectionAndDefaultQueueConnection(queueName);
+            const formattedQueuename = nameToRedisQueueName(queueName, namedQueueConnection);
+            this.namedQueues[queueName] = new Background.Queue(formattedQueuename, {
+                ...defaultBullMQQueueOptions,
+                ...namedQueueOptions,
+                connection: namedQueueConnection,
+            });
+            //////////////////////////
+            // create extra workers //
+            //////////////////////////
+            const extraWorkerOptionsMap = nativeBullMQ.namedQueueWorkers || {};
+            const extraWorkerOptions = extraWorkerOptionsMap[queueName];
+            const extraWorkerCount = extraWorkerOptions ? (extraWorkerOptions.workerCount ?? 1) : 0;
+            this.groupNames[queueName] ||= [];
+            if (extraWorkerOptions.group?.id)
+                this.groupNames[queueName].push(extraWorkerOptions.group.id);
+            if (activateWorkers) {
+                if (!namedWorkerConnection)
+                    throw new ActivatingNamedQueueBackgroundWorkersWithoutWorkerConnection(queueName);
+                for (let i = 0; i < extraWorkerCount; i++) {
+                    this._workers.push(new Background.Worker(formattedQueuename, job => this.doWork(job), {
+                        ...extraWorkerOptions,
+                        connection: namedWorkerConnection,
+                    }));
+                }
+            }
+            ///////////////////////////////
+            // end: create extra workers //
+            ///////////////////////////////
+        });
+        //////////////////////////////
+        // end: create named queues //
+        //////////////////////////////
+    }
+    work() {
+        this.connect({ activateWorkers: true });
+        process.on('SIGTERM', () => {
+            void this.shutdownAndExit();
+        });
+        process.on('SIGINT', () => {
+            void this.shutdownAndExit();
+        });
+    }
+    async staticMethod(ObjectClass, method, { delaySeconds, globalName, args = [], jobConfig = {}, }) {
+        this.connect();
+        await this._addToQueue(`BackgroundJobQueueStaticJob`, {
+            globalName,
+            method,
+            args,
+        }, {
+            delaySeconds,
+            jobConfig: jobConfig,
+            groupId: this.jobConfigToGroupId(jobConfig),
+            priority: this.jobConfigToPriority(jobConfig),
+        });
+    }
+    async scheduledMethod(ObjectClass, pattern, method, { globalName, args = [], jobConfig = {}, }) {
+        this.connect();
+        // `jobId` is used to determine uniqueness along with name and repeat pattern.
+        // Since the name is really a job type and never changes, the `jobId` is the only
+        // way to allow multiple jobs with the same cron repeat pattern. Uniqueness will
+        // now be enforced by combining class name, method name, and cron repeat pattern.
+        //
+        // See: https://docs.bullmq.io/guide/jobs/repeatable
+        const jobId = `${ObjectClass.name}:${method}`;
+        await this.queueInstance(jobConfig).add('BackgroundJobQueueStaticJob', {
+            globalName,
+            method,
+            args,
+        }, {
+            repeat: {
+                pattern,
+            },
+            jobId,
+            group: this.jobConfigToGroup(jobConfig),
+            priority: this.mapPriorityWordToPriorityNumber(this.jobConfigToPriority(jobConfig)),
+            // explicitly typing as JobsOptions because Psychic can't be aware of BullMQ Pro options
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    queueInstance(values) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const workstreamConfig = values;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const queueConfig = values;
+        const queueInstance = typeof workstreamConfig.workstream === 'string'
+            ? this.namedQueues[workstreamConfig.workstream]
+            : typeof queueConfig.queue === 'string'
+                ? this.namedQueues[queueConfig.queue]
+                : this.defaultQueue;
+        if (!queueInstance) {
+            if (typeof workstreamConfig.workstream === 'string')
+                throw new NoQueueForSpecifiedWorkstream(workstreamConfig.workstream);
+            if (typeof queueConfig.queue === 'string')
+                throw new NoQueueForSpecifiedQueueName(queueConfig.queue);
+        }
+        return queueInstance;
+    }
+    async modelInstanceMethod(modelInstance, method, { delaySeconds, args = [], jobConfig = {}, }) {
+        this.connect();
+        await this._addToQueue('BackgroundJobQueueModelInstanceJob', {
+            id: modelInstance.primaryKeyValue,
+            globalName: modelInstance.constructor.globalName,
+            method,
+            args,
+        }, {
+            delaySeconds,
+            jobConfig: jobConfig,
+            groupId: this.jobConfigToGroupId(jobConfig),
+            priority: this.jobConfigToPriority(jobConfig),
+        });
+    }
+    // should be private, but public so we can test
+    async _addToQueue(jobType, jobData, { delaySeconds, jobConfig, priority, groupId, }) {
+        // set this variable out side of the conditional so that
+        // mismatches will raise exceptions even in tests
+        const queueInstance = this.queueInstance(jobConfig);
+        const delay = delaySeconds ? delaySeconds * 1000 : undefined;
+        if (EnvInternal.isTest && !EnvInternal.boolean('REALLY_TEST_BACKGROUND_QUEUE')) {
+            const queue = new Background.Queue('TestQueue', { connection: {} });
+            const job = new Job(queue, jobType, jobData, {});
+            await this.doWork(job);
+            //
+        }
+        else if (groupId && priority) {
+            await queueInstance.add(jobType, jobData, {
+                delay,
+                group: {
+                    ...this.groupIdToGroupConfig(groupId),
+                    priority: this.mapPriorityWordToPriorityNumber(priority),
+                },
+                // explicitly typing as JobsOptions because Psychic can't be aware of BullMQ Pro options
+            });
+            //
+        }
+        else {
+            await queueInstance.add(jobType, jobData, {
+                delay,
+                group: this.groupIdToGroupConfig(groupId),
+                priority: this.mapPriorityWordToPriorityNumber(priority),
+                // explicitly typing as JobsOptions because Psychic can't be aware of BullMQ Pro options
+            });
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    jobConfigToPriority(jobConfig) {
+        if (!jobConfig)
+            return 'default';
+        return jobConfig.priority || 'default';
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    jobConfigToGroupId(jobConfig) {
+        if (!jobConfig)
+            return;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const workstreamConfig = jobConfig;
+        if (typeof workstreamConfig.workstream === 'string')
+            return workstreamConfig.workstream;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const queueConfig = jobConfig;
+        if (typeof queueConfig.groupId === 'string')
+            return queueConfig.groupId;
+        return;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    jobConfigToGroup(jobConfig) {
+        return this.groupIdToGroupConfig(this.jobConfigToGroupId(jobConfig));
+    }
+    groupIdToGroupConfig(groupId) {
+        if (!groupId)
+            return;
+        return { id: groupId };
+    }
+    mapPriorityWordToPriorityNumber(priority) {
+        switch (priority) {
+            case 'urgent':
+                return 1;
+            case 'default':
+                return 2;
+            case 'not_urgent':
+                return 3;
+            case 'last':
+                return 4;
+            default:
+                return 2;
+        }
+    }
+    async doWork(job) {
+        const jobType = job.name;
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const { id, method, args, globalName } = job.data;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let objectClass;
+        let dreamClass;
+        switch (jobType) {
+            case 'BackgroundJobQueueStaticJob':
+                if (globalName) {
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                    objectClass = PsychicApplication.lookupClassByGlobalName(globalName);
+                }
+                if (!objectClass)
+                    return;
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+                await objectClass[method](...args, job);
+                break;
+            case 'BackgroundJobQueueModelInstanceJob':
+                if (globalName) {
+                    dreamClass = PsychicApplication.lookupClassByGlobalName(globalName);
+                }
+                if (dreamClass) {
+                    const modelInstance = await dreamClass.find(id);
+                    if (!modelInstance)
+                        return;
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+                    await modelInstance[method](...args, job);
+                }
+                break;
+        }
+    }
+}
+const background = new Background();
+export default background;
+export async function stopBackgroundWorkers() {
+    await background.shutdown();
+}
+function nameToRedisQueueName(queueName, redis) {
+    queueName = queueName.replace(/\{|\}/g, '');
+    if (redis instanceof Cluster)
+        return `{${queueName}}`;
+    return queueName;
+}

package/dist/esm/src/background/types.js

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

package/dist/esm/src/error/background/NoQueueForSpecifiedQueueName.js

@@ -0,0 +1,12 @@
+export default class NoQueueForSpecifiedQueueName extends Error {
+    queue;
+    constructor(queue) {
+        super();
+        this.queue = queue;
+    }
+    get message() {
+        return `Error enqueueing background job
+No queue matches "${this.queue}"
+`;
+    }
+}

package/dist/esm/src/error/background/NoQueueForSpecifiedWorkstream.js

@@ -0,0 +1,12 @@
+export default class NoQueueForSpecifiedWorkstream extends Error {
+    workstream;
+    constructor(workstream) {
+        super();
+        this.workstream = workstream;
+    }
+    get message() {
+        return `Error enqueueing background job
+No queue found for workstream "${this.workstream}"
+`;
+    }
+}

package/dist/esm/src/helpers/EnvInternal.js

@@ -0,0 +1,3 @@
+import { Env } from '@rvoh/dream';
+const EnvInternal = new Env();
+export default EnvInternal;

package/dist/esm/src/index.js

@@ -0,0 +1,7 @@
+export { default as background, Background, stopBackgroundWorkers, } from './background/index.js';
+export { default as BaseBackgroundedModel } from './background/BaseBackgroundedModel.js';
+export { default as BaseBackgroundedService } from './background/BaseBackgroundedService.js';
+export { default as BaseScheduledService } from './background/BaseScheduledService.js';
+export { default as PsychicApplicationWorkers, } from './psychic-application-workers/index.js';
+export { default as NoQueueForSpecifiedQueueName } from './error/background/NoQueueForSpecifiedQueueName.js';
+export { default as NoQueueForSpecifiedWorkstream } from './error/background/NoQueueForSpecifiedWorkstream.js';

package/dist/esm/src/psychic-application-workers/cache.js

@@ -0,0 +1,12 @@
+let _psychicWorkersApp = undefined;
+export function cachePsychicWorkersApplication(psychicWorkersApp) {
+    _psychicWorkersApp = psychicWorkersApp;
+}
+export function getCachedPsychicWorkersApplication() {
+    return _psychicWorkersApp;
+}
+export function getCachedPsychicWorkersApplicationOrFail() {
+    if (!_psychicWorkersApp)
+        throw new Error('must call `cachePsychicWorkersApplication` before loading cached psychic application workers');
+    return _psychicWorkersApp;
+}

package/dist/esm/src/psychic-application-workers/index.js

@@ -0,0 +1,74 @@
+import { Queue, Worker } from 'bullmq';
+import background from '../background/index.js';
+import { cachePsychicWorkersApplication, getCachedPsychicWorkersApplicationOrFail } from './cache.js';
+export default class PsychicApplicationWorkers {
+    static async init(psychicApp, cb) {
+        const psychicWorkersApp = new PsychicApplicationWorkers(psychicApp);
+        await cb(psychicWorkersApp);
+        psychicApp.on('sync', () => {
+            background.connect();
+            const output = {
+                workstreamNames: [...background['workstreamNames']],
+                queueGroupMap: { ...background['groupNames'] },
+            };
+            return output;
+        });
+        psychicApp.on('server:shutdown', async () => {
+            await background.closeAllRedisConnections();
+        });
+        cachePsychicWorkersApplication(psychicWorkersApp);
+        return psychicWorkersApp;
+    }
+    /**
+     * Returns the cached psychic application if it has been set.
+     * If it has not been set, an exception is raised.
+     *
+     * The psychic application can be set by calling PsychicApplication#init
+     */
+    static getOrFail() {
+        return getCachedPsychicWorkersApplicationOrFail();
+    }
+    psychicApp;
+    constructor(psychicApp) {
+        this.psychicApp = psychicApp;
+    }
+    /**
+     * Returns the background options provided by the user
+     */
+    get backgroundOptions() {
+        return this._backgroundOptions;
+    }
+    _backgroundOptions;
+    _hooks = {
+        workerShutdown: [],
+    };
+    get hooks() {
+        return this._hooks;
+    }
+    on(hookEventType, cb) {
+        switch (hookEventType) {
+            case 'workers:shutdown':
+                this._hooks.workerShutdown.push(cb);
+                break;
+            default:
+                throw new Error(`unrecognized event provided to PsychicWorkersApplication#on: ${hookEventType}`);
+        }
+    }
+    set(option, value) {
+        switch (option) {
+            case 'background':
+                this._backgroundOptions = {
+                    ...{
+                        providers: {
+                            Queue,
+                            Worker,
+                        },
+                    },
+                    ...value,
+                };
+                break;
+            default:
+                throw new Error(`Unhandled option type passed to PsychicWorkersApplication#set: ${option}`);
+        }
+    }
+}