@rvoh/psychic-workers 0.2.1

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

@@ -0,0 +1,529 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Background = void 0;
+exports.stopBackgroundWorkers = stopBackgroundWorkers;
+const dream_1 = require("@rvoh/dream");
+const psychic_1 = require("@rvoh/psychic");
+const bullmq_1 = require("bullmq");
+const ioredis_1 = require("ioredis");
+const NoQueueForSpecifiedQueueName_js_1 = require("../error/background/NoQueueForSpecifiedQueueName.js");
+const NoQueueForSpecifiedWorkstream_js_1 = require("../error/background/NoQueueForSpecifiedWorkstream.js");
+const EnvInternal_js_1 = require("../helpers/EnvInternal.js");
+const index_js_1 = require("../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.
+`;
+    }
+}
+class Background {
+    static get defaultQueueName() {
+        const psychicWorkersApp = index_js_1.default.getOrFail();
+        return `${(0, dream_1.pascalize)(psychicWorkersApp.psychicApp.appName)}BackgroundJobQueue`;
+    }
+    static get Worker() {
+        const psychicWorkersApp = index_js_1.default.getOrFail();
+        return (psychicWorkersApp.backgroundOptions.providers?.Worker || bullmq_1.Worker);
+    }
+    static get Queue() {
+        const psychicWorkersApp = index_js_1.default.getOrFail();
+        return (psychicWorkersApp.backgroundOptions.providers?.Queue || bullmq_1.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 = index_js_1.default.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 (0, dream_1.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 = index_js_1.default.getOrFail();
+        for (const hook of psychicWorkersApp.hooks.workerShutdown) {
+            await hook();
+        }
+        await (0, dream_1.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_js_1.default(workstreamConfig.workstream);
+            if (typeof queueConfig.queue === 'string')
+                throw new NoQueueForSpecifiedQueueName_js_1.default(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_js_1.default.isTest && !EnvInternal_js_1.default.boolean('REALLY_TEST_BACKGROUND_QUEUE')) {
+            const queue = new Background.Queue('TestQueue', { connection: {} });
+            const job = new bullmq_1.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 = psychic_1.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 = psychic_1.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;
+        }
+    }
+}
+exports.Background = Background;
+const background = new Background();
+exports.default = background;
+async function stopBackgroundWorkers() {
+    await background.shutdown();
+}
+function nameToRedisQueueName(queueName, redis) {
+    queueName = queueName.replace(/\{|\}/g, '');
+    if (redis instanceof ioredis_1.Cluster)
+        return `{${queueName}}`;
+    return queueName;
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class NoQueueForSpecifiedQueueName extends Error {
+    queue;
+    constructor(queue) {
+        super();
+        this.queue = queue;
+    }
+    get message() {
+        return `Error enqueueing background job
+No queue matches "${this.queue}"
+`;
+    }
+}
+exports.default = NoQueueForSpecifiedQueueName;

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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}"
+`;
+    }
+}
+exports.default = NoQueueForSpecifiedWorkstream;

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

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const dream_1 = require("@rvoh/dream");
+const EnvInternal = new dream_1.Env();
+exports.default = EnvInternal;

package/dist/cjs/src/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoQueueForSpecifiedWorkstream = exports.NoQueueForSpecifiedQueueName = exports.PsychicApplicationWorkers = exports.BaseScheduledService = exports.BaseBackgroundedService = exports.BaseBackgroundedModel = exports.stopBackgroundWorkers = exports.Background = exports.background = void 0;
+var index_js_1 = require("./background/index.js");
+Object.defineProperty(exports, "background", { enumerable: true, get: function () { return index_js_1.default; } });
+Object.defineProperty(exports, "Background", { enumerable: true, get: function () { return index_js_1.Background; } });
+Object.defineProperty(exports, "stopBackgroundWorkers", { enumerable: true, get: function () { return index_js_1.stopBackgroundWorkers; } });
+var BaseBackgroundedModel_js_1 = require("./background/BaseBackgroundedModel.js");
+Object.defineProperty(exports, "BaseBackgroundedModel", { enumerable: true, get: function () { return BaseBackgroundedModel_js_1.default; } });
+var BaseBackgroundedService_js_1 = require("./background/BaseBackgroundedService.js");
+Object.defineProperty(exports, "BaseBackgroundedService", { enumerable: true, get: function () { return BaseBackgroundedService_js_1.default; } });
+var BaseScheduledService_js_1 = require("./background/BaseScheduledService.js");
+Object.defineProperty(exports, "BaseScheduledService", { enumerable: true, get: function () { return BaseScheduledService_js_1.default; } });
+var index_js_2 = require("./psychic-application-workers/index.js");
+Object.defineProperty(exports, "PsychicApplicationWorkers", { enumerable: true, get: function () { return index_js_2.default; } });
+var NoQueueForSpecifiedQueueName_js_1 = require("./error/background/NoQueueForSpecifiedQueueName.js");
+Object.defineProperty(exports, "NoQueueForSpecifiedQueueName", { enumerable: true, get: function () { return NoQueueForSpecifiedQueueName_js_1.default; } });
+var NoQueueForSpecifiedWorkstream_js_1 = require("./error/background/NoQueueForSpecifiedWorkstream.js");
+Object.defineProperty(exports, "NoQueueForSpecifiedWorkstream", { enumerable: true, get: function () { return NoQueueForSpecifiedWorkstream_js_1.default; } });

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cachePsychicWorkersApplication = cachePsychicWorkersApplication;
+exports.getCachedPsychicWorkersApplication = getCachedPsychicWorkersApplication;
+exports.getCachedPsychicWorkersApplicationOrFail = getCachedPsychicWorkersApplicationOrFail;
+let _psychicWorkersApp = undefined;
+function cachePsychicWorkersApplication(psychicWorkersApp) {
+    _psychicWorkersApp = psychicWorkersApp;
+}
+function getCachedPsychicWorkersApplication() {
+    return _psychicWorkersApp;
+}
+function getCachedPsychicWorkersApplicationOrFail() {
+    if (!_psychicWorkersApp)
+        throw new Error('must call `cachePsychicWorkersApplication` before loading cached psychic application workers');
+    return _psychicWorkersApp;
+}