@rvoh/psychic-workers 0.2.9 → 0.3.1

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

@@ -0,0 +1,14 @@
+export default 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.
+`;
+    }
+}

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

@@ -0,0 +1,8 @@
+export default 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
+`;
+    }
+}

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

@@ -0,0 +1,13 @@
+export default 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
+`;
+    }
+}

package/dist/esm/src/index.js

@@ -1,7 +1,7 @@
-export { default as background, Background, stopBackgroundWorkers, } from './background/index.js';
+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 PsychicAppWorkers, } from './psychic-app-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-app-workers/cache.js

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

package/dist/esm/src/{psychic-application-workers → psychic-app-workers}/index.js

@@ -1,9 +1,9 @@
 import { Queue, Worker } from 'bullmq';
+import { cachePsychicWorkersApp, getCachedPsychicWorkersAppOrFail } from './cache.js';
 import background from '../background/index.js';
-import { cachePsychicWorkersApplication, getCachedPsychicWorkersApplicationOrFail } from './cache.js';
-export default class PsychicApplicationWorkers {
+export default class PsychicAppWorkers {
     static async init(psychicApp, cb) {
-        const psychicWorkersApp = new PsychicApplicationWorkers(psychicApp);
+        const psychicWorkersApp = new PsychicAppWorkers(psychicApp);
         await cb(psychicWorkersApp);
         psychicApp.on('sync', () => {
             background.connect();
@@ -16,17 +16,17 @@ export default class PsychicApplicationWorkers {
         psychicApp.on('server:shutdown', async () => {
             await background.closeAllRedisConnections();
         });
-        cachePsychicWorkersApplication(psychicWorkersApp);
+        cachePsychicWorkersApp(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
+     * The psychic application can be set by calling PsychicApp#init
      */
     static getOrFail() {
-        return getCachedPsychicWorkersApplicationOrFail();
+        return getCachedPsychicWorkersAppOrFail();
     }
     psychicApp;
     constructor(psychicApp) {
@@ -51,7 +51,7 @@ export default class PsychicApplicationWorkers {
                 this._hooks.workerShutdown.push(cb);
                 break;
             default:
-                throw new Error(`unrecognized event provided to PsychicWorkersApplication#on: ${hookEventType}`);
+                throw new Error(`unrecognized event provided to PsychicWorkersApp#on: ${hookEventType}`);
         }
     }
     set(option, value) {
@@ -68,7 +68,7 @@ export default class PsychicApplicationWorkers {
                 };
                 break;
             default:
-                throw new Error(`Unhandled option type passed to PsychicWorkersApplication#set: ${option}`);
+                throw new Error(`Unhandled option type passed to PsychicWorkersApp#set: ${option}`);
         }
     }
 }

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

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

package/dist/types/src/background/BaseBackgroundedModel.d.ts

@@ -1,14 +1,119 @@
 import { Dream } from '@rvoh/dream';
+import { BackgroundJobConfig } from '../types/background.js';
+import { FunctionPropertyNames } from '../types/utils.js';
 import { BackgroundableMethodArgs } from './BaseBackgroundedService.js';
-import { BackgroundJobConfig } from './index.js';
-import { FunctionPropertyNames } from './types.js';
 export default class BaseBackgroundedModel extends Dream {
+    /**
+     * A getter meant to be overridden in child classes. This does
+     * not have to be explicitly provided, but if so, it would allow
+     * you to override the default behavior of anything backgrounded
+     * by this service, such as the priority or workstream.
+     *
+     * @returns {object} config - the background job config
+     * @returns {string} config.priority - 'default' | 'urgent' | 'not_urgent' | 'last'
+     * @returns {string} config.workstream - a workstream name. This would be the name of a workstream, as defined in conf/workers.ts
+     * @returns {string} config.queueId - the id of the BullMQ queue you wish to connect to. This can only be provided if workstream is not provided.
+     * @returns {string} config.groupId - the groupId of the BullMQ queue you wish to connect to. This can only be provided if workstream is not provided.
+     */
     static get backgroundJobConfig(): BackgroundJobConfig<BaseBackgroundedModel>;
-    get backgroundJobConfig(): BackgroundJobConfig<BaseBackgroundedModel>;
+    /**
+     * @internal
+     *
+     * shadows the static `backgroundJobConfig` getter provided by the user.
+     * This should never be overridden, and is meant to provide easy access
+     * to the config from within an instance.
+     */
+    protected get backgroundJobConfig(): BackgroundJobConfig<BaseBackgroundedModel>;
+    /**
+     * runs the specified method in a background queue, driven by BullMQ,
+     * sending in the provided args.
+     *
+     * ```ts
+     * await User.background('myMethod', 'abc', 123)
+     * ```
+     * though calling background must be awaited, the resolution of the promise
+     * is an indication that the job was put in the queue, not that it has
+     * completed.
+     *
+     * NOTE: in test environments, psychic will immediately invoke the underlying
+     * method, preventing you from needing to explicitly wait for queues to flush
+     * before making assertions.
+     *
+     * @param methodName - the name of the static method you wish to run in the background
+     * @param args - a variadic list of arguments to be sent to your method
+     */
     static background<T, MethodName extends PsychicBackgroundedModelStaticMethods<T & typeof BaseBackgroundedModel>, MethodFunc extends T[MethodName & keyof T], MethodArgs extends BackgroundableMethodArgs<MethodFunc>>(this: T, methodName: MethodName, ...args: MethodArgs): Promise<void>;
+    /**
+     * runs the specified method in a background queue, driven by BullMQ,
+     * sending in the provided args, including a delay in seconds, which
+     * can be used to hold off the job for a certain amount of time after
+     * it is entered into the queue.
+     *
+     * ```ts
+     * await User.backgroundWithDelay('myMethod', 'abc', 123)
+     * ```
+     * though calling background must be awaited, the resolution of the promise
+     * is an indication that the job was put in the queue, not that it has
+     * completed.
+     *
+     * NOTE: in test environments, psychic will immediately invoke the underlying
+     * method, preventing you from needing to explicitly wait for queues to flush
+     * before making assertions.
+     *
+     * @param delaySeconds - the amount of time (in seconds) you want to hold off before allowing the job to run
+     * @param methodName - the name of the static method you wish to run in the background
+     * @param args - a variadic list of arguments to be sent to your method
+     */
     static backgroundWithDelay<T, MethodName extends PsychicBackgroundedModelStaticMethods<T & typeof BaseBackgroundedModel>, MethodFunc extends T[MethodName & keyof T], MethodArgs extends BackgroundableMethodArgs<MethodFunc>>(this: T, delaySeconds: number, methodName: MethodName, ...args: MethodArgs): Promise<void>;
+    /**
+     * types composed by psychic must be provided, since psychic-workers leverages
+     * the sync command in psychic to read your backgroundable services and extract
+     * metadata, which can be used to help provide types for the underlying methods
+     * in psychic-workers.
+     */
     get psychicTypes(): any;
+    /**
+     * runs the specified method in a background queue, driven by BullMQ,
+     * sending in the provided args.
+     *
+     * ```ts
+     * const user = await User.lastOrFail()
+     * await user.background('myMethod', 'abc', 123)
+     * ```
+     * though calling background must be awaited, the resolution of the promise
+     * is an indication that the job was put in the queue, not that it has
+     * completed.
+     *
+     * NOTE: in test environments, psychic will immediately invoke the underlying
+     * method, preventing you from needing to explicitly wait for queues to flush
+     * before making assertions.
+     *
+     * @param methodName - the name of the static method you wish to run in the background
+     * @param args - a variadic list of arguments to be sent to your method
+     */
     background<T, MethodName extends PsychicBackgroundedServiceInstanceMethods<T & BaseBackgroundedModel>, MethodFunc extends T[MethodName & keyof T], MethodArgs extends BackgroundableMethodArgs<MethodFunc>>(this: T, methodName: MethodName, ...args: MethodArgs): Promise<void>;
+    /**
+     * runs the specified method in a background queue, driven by BullMQ,
+     * sending in the provided args, including a delay in seconds, which
+     * can be used to hold off the job for a certain amount of time after
+     * it is entered into the queue.
+     *
+     * ```ts
+     * const user = await User.lastOrFail()
+     * await user.backgroundWithDelay('myMethod', 'abc', 123)
+     * ```
+     * though calling background must be awaited, the resolution of the promise
+     * is an indication that the job was put in the queue, not that it has
+     * completed.
+     *
+     * NOTE: in test environments, psychic will immediately invoke the underlying
+     * method, preventing you from needing to explicitly wait for queues to flush
+     * before making assertions.
+     *
+     * @param delaySeconds - the amount of time (in seconds) you want to hold off before allowing the job to run
+     * @param methodName - the name of the static method you wish to run in the background
+     * @param args - a variadic list of arguments to be sent to your method
+     */
     backgroundWithDelay<T, MethodName extends PsychicBackgroundedServiceInstanceMethods<T & BaseBackgroundedModel>, MethodFunc extends T[MethodName & keyof T], MethodArgs extends BackgroundableMethodArgs<MethodFunc>>(this: T, delaySeconds: number, methodName: MethodName, ...args: MethodArgs): Promise<void>;
 }
 export type PsychicBackgroundedModelStaticMethods<T extends typeof BaseBackgroundedModel> = Exclude<FunctionPropertyNames<Required<T>>, FunctionPropertyNames<typeof BaseBackgroundedModel>>;

package/dist/types/src/background/BaseBackgroundedService.d.ts

@@ -1,13 +1,84 @@
 import { Job } from 'bullmq';
-import { BackgroundJobConfig } from './index.js';
-import { FunctionPropertyNames } from './types.js';
+import { BackgroundJobConfig } from '../types/background.js';
+import { FunctionPropertyNames } from '../types/utils.js';
 export default class BaseBackgroundedService {
+    /**
+     * A getter meant to be overridden in child classes. This does
+     * not have to be explicitly provided, but if so, it would allow
+     * you to override the default behavior of anything backgrounded
+     * by this service, such as the priority or workstream.
+     *
+     * @returns {object} config - the background job config
+     * @returns {string} config.priority - 'default' | 'urgent' | 'not_urgent' | 'last'
+     * @returns {string} config.workstream - a workstream name. This would be the name of a workstream, as defined in conf/workers.ts
+     * @returns {string} config.queueId - the id of the BullMQ queue you wish to connect to. This can only be provided if workstream is not provided.
+     * @returns {string} config.groupId - the groupId of the BullMQ queue you wish to connect to. This can only be provided if workstream is not provided.
+     */
     static get backgroundJobConfig(): BackgroundJobConfig<BaseBackgroundedService>;
+    /**
+     * @internal
+     *
+     * Returns a unique global name for the given service.
+     *
+     * @returns A string representing a unique key for this service
+     */
     static get globalName(): string;
+    /**
+     * @internal
+     *
+     * Used by PsychicApplicationWorkers during the load process
+     * for services to assign unique global names to each service
+     * based on the file name of that model.
+     */
     static setGlobalName(globalName: string): void;
     private static _globalName;
+    /**
+     * runs the specified method in a background queue, driven by BullMQ,
+     * sending in the provided args.
+     *
+     * ```ts
+     * await MyBackgroundableClass.background('myMethod', 'abc', 123)
+     * ```
+     * though calling background must be awaited, the resolution of the promise
+     * is an indication that the job was put in the queue, not that it has
+     * completed.
+     *
+     * NOTE: in test environments, psychic will immediately invoke the underlying
+     * method, preventing you from needing to explicitly wait for queues to flush
+     * before making assertions.
+     *
+     * @param methodName - the name of the static method you wish to run in the background
+     * @param args - a variadic list of arguments to be sent to your method
+     */
     static background<T, MethodName extends PsychicBackgroundedServiceStaticMethods<T & typeof BaseBackgroundedService>, MethodFunc extends T[MethodName & keyof T], MethodArgs extends BackgroundableMethodArgs<MethodFunc>>(this: T, methodName: MethodName, ...args: MethodArgs): Promise<void>;
+    /**
+     * runs the specified method in a background queue, driven by BullMQ,
+     * sending in the provided args, including a delay in seconds, which
+     * can be used to hold off the job for a certain amount of time after
+     * it is entered into the queue.
+     *
+     * ```ts
+     * await MyBackgroundableClass.backgroundWithDelay('myMethod', 'abc', 123)
+     * ```
+     * though calling background must be awaited, the resolution of the promise
+     * is an indication that the job was put in the queue, not that it has
+     * completed.
+     *
+     * NOTE: in test environments, psychic will immediately invoke the underlying
+     * method, preventing you from needing to explicitly wait for queues to flush
+     * before making assertions.
+     *
+     * @param delaySeconds - the amount of time (in seconds) you want to hold off before allowing the job to run
+     * @param methodName - the name of the static method you wish to run in the background
+     * @param args - a variadic list of arguments to be sent to your method
+     */
     static backgroundWithDelay<T, MethodName extends PsychicBackgroundedServiceStaticMethods<T & typeof BaseBackgroundedService>, MethodFunc extends T[MethodName & keyof T], MethodArgs extends BackgroundableMethodArgs<MethodFunc>>(this: T, delaySeconds: number, methodName: MethodName, ...args: MethodArgs): Promise<void>;
+    /**
+     * types composed by psychic must be provided, since psychic-workers leverages
+     * the sync command in psychic to read your backgroundable services and extract
+     * metadata, which can be used to help provide types for the underlying methods
+     * in psychic-workers.
+     */
     get psychicTypes(): any;
 }
 export type PsychicBackgroundedServiceStaticMethods<T extends typeof BaseBackgroundedService> = Exclude<FunctionPropertyNames<Required<T>>, FunctionPropertyNames<typeof BaseBackgroundedService>>;

package/dist/types/src/background/BaseScheduledService.d.ts

@@ -1,11 +1,62 @@
-import { BackgroundJobConfig } from './index.js';
-import { FunctionPropertyNames } from './types.js';
+import { BackgroundJobConfig } from '../types/background.js';
+import { FunctionPropertyNames } from '../types/utils.js';
 export default class BaseScheduledService {
+    /**
+     * A getter meant to be overridden in child classes. This does
+     * not have to be explicitly provided, but if so, it would allow
+     * you to override the default behavior of anything backgrounded
+     * by this service, such as the priority or workstream.
+     *
+     * @returns {object} config - the background job config
+     * @returns {string} config.priority - 'default' | 'urgent' | 'not_urgent' | 'last'
+     * @returns {string} config.workstream - a workstream name. This would be the name of a workstream, as defined in conf/workers.ts
+     * @returns {string} config.queueId - the id of the BullMQ queue you wish to connect to. This can only be provided if workstream is not provided.
+     * @returns {string} config.groupId - the groupId of the BullMQ queue you wish to connect to. This can only be provided if workstream is not provided.
+     */
     static get backgroundJobConfig(): BackgroundJobConfig<BaseScheduledService>;
+    /**
+     * @internal
+     *
+     * Returns a unique global name for the given service.
+     *
+     * @returns A string representing a unique key for this service
+     */
     static get globalName(): string;
+    /**
+     * @internal
+     *
+     * Used by PsychicApplicationWorkers during the load process
+     * for services to assign unique global names to each service
+     * based on the file name of that model.
+     */
     static setGlobalName(globalName: string): void;
     private static _globalName;
+    /**
+     * Schedules a job to be run repeatedly at a certain cron interval
+     * sending in the provided args.
+     *
+     * ```ts
+     * await MySchedulableClass.schedule('0 * * * *', 'myHourlyMethod', 'abc', 123)
+     * ```
+     * though calling background must be awaited, the resolution of the promise
+     * is an indication that the job was put in the queue, not that it has
+     * completed.
+     *
+     * NOTE: in test environments, psychic will immediately invoke the underlying
+     * method, preventing you from needing to explicitly wait for queues to flush
+     * before making assertions.
+     *
+     * @param pattern - A cron string representing the time interval you wish this to run on
+     * @param methodName - the name of the static method you wish to run in the background
+     * @param args - a variadic list of arguments to be sent to your method
+     */
     static schedule<T, MethodName extends FunctionPropertyNames<Required<T>>, MethodFunc extends T[MethodName & keyof T], MethodArgs extends MethodFunc extends (...args: any) => any ? Parameters<MethodFunc> : never>(this: T, pattern: string, methodName: MethodName, ...args: MethodArgs): Promise<void>;
+    /**
+     * types composed by psychic must be provided, since psychic-workers leverages
+     * the sync command in psychic to read your backgroundable services and extract
+     * metadata, which can be used to help provide types for the underlying methods
+     * in psychic-workers.
+     */
     get psychicTypes(): any;
 }
 export type PsychicScheduledServiceStaticMethods<T extends typeof BaseScheduledService> = Exclude<FunctionPropertyNames<Required<T>>, FunctionPropertyNames<typeof BaseScheduledService>>;

package/dist/types/src/background/helpers/nameToRedisQueueName.d.ts

@@ -0,0 +1,2 @@
+import { Redis, Cluster } from 'ioredis';
+export default function nameToRedisQueueName(queueName: string, redis: Redis | Cluster): string;

package/dist/types/src/background/index.d.ts

@@ -1,69 +1,167 @@
-import { Dream, IdType } from '@rvoh/dream';
+import { Dream } from '@rvoh/dream';
 import { Job, Queue, Worker } from 'bullmq';
-import { PsychicBackgroundNativeBullMQOptions, PsychicBackgroundSimpleOptions } from '../psychic-application-workers/index.js';
-import BaseBackgroundedService from './BaseBackgroundedService.js';
-import BaseScheduledService from './BaseScheduledService.js';
-import { Either } from './types.js';
-type JobTypes = 'BackgroundJobQueueFunctionJob' | 'BackgroundJobQueueStaticJob' | 'BackgroundJobQueueModelInstanceJob';
-export interface BackgroundJobData {
-    id?: IdType;
-    method?: string;
-    args: any;
-    filepath?: string;
-    importKey?: string;
-    globalName?: string;
-}
+import { BackgroundJobConfig, BackgroundJobData, BackgroundQueuePriority, JobTypes } from '../types/background.js';
+/**
+ * the underlying class driving the `background` singleton,
+ * available as an import from `psychic-workers`.
+ */
 export declare class Background {
+    /**
+     * returns the default queue name for your app
+     */
     static get defaultQueueName(): string;
+    /**
+     * @internal
+     *
+     * returns the provided Worker class, or the Worker class from BullMQ
+     * if no override was provided. This is providable because BullMQ also
+     * offers a pro version, which requires you to provide custom classes.
+     */
     static get Worker(): typeof Worker;
+    /**
+     * @internal
+     *
+     * returns the provided Queue class, or the Queue class from BullMQ
+     * if no override was provided. This is providable because BullMQ also
+     * offers a pro version, which requires you to provide custom classes.
+     */
     static get Queue(): typeof Queue;
     /**
+     * @internal
+     *
      * Used when adding jobs to the default queue
      */
     private defaultQueue;
     /**
+     * @internal
+     *
      * Used when adding jobs to the default transitional queue
      */
     private defaultTransitionalQueue;
     /**
+     * @internal
+     *
      * Used when adding jobs to a named queue
      */
     private namedQueues;
+    /**
+     * @internal
+     *
+     * Used when adding grouped jobs
+     */
     private groupNames;
+    /**
+     * @internal
+     *
+     * Used when adding workstreams
+     */
     private workstreamNames;
     /**
+     * @internal
+     *
      * Used when adding jobs to a named transitioanl queue
      */
     private namedTransitionalQueues;
+    /**
+     * @internal
+     *
+     * All of the workers that are currently registered
+     */
     private _workers;
+    /**
+     * @internal
+     *
+     * All of the redis connections that are currently registered
+     */
     private redisConnections;
+    /**
+     * Establishes connection to BullMQ via redis
+     */
     connect({ activateWorkers, }?: {
         activateWorkers?: boolean;
     }): void;
+    /**
+     * Returns all the queues in your application
+     */
     get queues(): Queue[];
+    /**
+     * Returns all the workers in your application
+     */
     get workers(): Worker<any, any, string>[];
     private shutdownAndExit;
+    /**
+     * Shuts down workers, closes all redis connections
+     */
     shutdown(): Promise<void>;
+    /**
+     * closes all redis connections for workers and queues
+     */
     closeAllRedisConnections(): Promise<void>;
+    /**
+     * @internal
+     *
+     * connects to BullMQ using workstream-based arguments
+     */
     private simpleConnect;
+    /**
+     * @internal
+     *
+     * connects to BullMQ using native BullMQ arguments
+     */
     private nativeBullMQConnect;
+    /**
+     * starts background workers
+     */
     work(): void;
-    staticMethod(ObjectClass: Record<'name', string>, method: string, { delaySeconds, globalName, args, jobConfig, }: {
+    /**
+     * adds the static method of a provided class to BullMQ
+     *
+     * @param ObjectClass - the class you wish to background
+     * @param method - the method you wish to background
+     * @param globalName - the globalName of the class you are processing
+     * @param args - (optional) a list of arguments to provide to your method when it is called
+     * @param delaySeconds - (optional) the number of seconds you wish to wait before allowing this job to process
+     * @param importKey - (optional) the import key for the class
+     * @param jobConfig - (optional) the background job config to use when backgrounding this method
+     */
+    staticMethod(ObjectClass: Record<'name', string>, method: string, { globalName, delaySeconds, args, jobConfig, }: {
         globalName: string;
+        args?: any[];
         filepath?: string;
         delaySeconds?: number;
         importKey?: string;
-        args?: any[];
         jobConfig?: BackgroundJobConfig<any>;
     }): Promise<void>;
+    /**
+     * adds the static method of a provided class to BullMQ,
+     * to be scheduled to run at a specified cron pattern
+     *
+     * @param ObjectClass - the class you wish to background
+     * @param pattern - the cron string you wish to use to govern the scheduling for this job
+     * @param method - the method you wish to background
+     * @param globalName - the globalName of the class you are processing
+     * @param args - (optional) a list of arguments to provide to your method when it is called
+     * @param importKey - (optional) the import key for the class
+     * @param jobConfig - (optional) the background job config to use when backgrounding this method
+     */
     scheduledMethod(ObjectClass: Record<'name', string>, pattern: string, method: string, { globalName, args, jobConfig, }: {
         globalName: string;
+        args?: any[];
         filepath?: string;
         importKey?: string;
-        args?: any[];
         jobConfig?: BackgroundJobConfig<any>;
     }): Promise<void>;
     private queueInstance;
+    /**
+     * adds the instance method of a provided dream model to BullMQ
+     *
+     * @param modelInstance - the dream model instance you wish to background
+     * @param method - the method you wish to background
+     * @param globalName - the globalName of the class you are processing
+     * @param args - (optional) a list of arguments to provide to your method when it is called
+     * @param importKey - (optional) the import key for the class
+     * @param jobConfig - (optional) the background job config to use when backgrounding this method
+     */
     modelInstanceMethod(modelInstance: Dream, method: string, { delaySeconds, args, jobConfig, }: {
         delaySeconds?: number;
         importKey?: string;
@@ -86,16 +184,3 @@ export declare class Background {
 declare const background: Background;
 export default background;
 export declare function stopBackgroundWorkers(): Promise<void>;
-export type BackgroundQueuePriority = 'default' | 'urgent' | 'not_urgent' | 'last';
-interface BaseBackgroundJobConfig {
-    priority?: BackgroundQueuePriority;
-}
-export interface WorkstreamBackgroundJobConfig<T extends BaseScheduledService | BaseBackgroundedService> extends BaseBackgroundJobConfig {
-    workstream?: T['psychicTypes']['workstreamNames'][number];
-}
-export interface QueueBackgroundJobConfig<T extends BaseScheduledService | BaseBackgroundedService, PsyTypes extends T['psychicTypes'] = T['psychicTypes'], QueueGroupMap = PsyTypes['queueGroupMap'], Queue extends keyof QueueGroupMap = keyof QueueGroupMap, Groups extends QueueGroupMap[Queue] = QueueGroupMap[Queue], GroupId = Groups[number & keyof Groups]> extends BaseBackgroundJobConfig {
-    groupId?: GroupId;
-    queue?: Queue;
-}
-export type BackgroundJobConfig<T extends BaseScheduledService | BaseBackgroundedService> = Either<WorkstreamBackgroundJobConfig<T>, QueueBackgroundJobConfig<T>>;
-export type PsychicBackgroundOptions = (PsychicBackgroundSimpleOptions & Partial<Record<Exclude<keyof PsychicBackgroundNativeBullMQOptions, keyof PsychicBackgroundSimpleOptions>, never>>) | (PsychicBackgroundNativeBullMQOptions & Partial<Record<Exclude<keyof PsychicBackgroundSimpleOptions, keyof PsychicBackgroundNativeBullMQOptions>, never>>);

package/dist/types/src/error/background/ActivatingBackgroundWorkersWithoutDefaultWorkerConnection.d.ts

@@ -0,0 +1,3 @@
+export default class ActivatingBackgroundWorkersWithoutDefaultWorkerConnection extends Error {
+    get message(): string;
+}

package/dist/types/src/error/background/ActivatingNamedQueueBackgroundWorkersWithoutWorkerConnection.d.ts

@@ -0,0 +1,5 @@
+export default class ActivatingNamedQueueBackgroundWorkersWithoutWorkerConnection extends Error {
+    private queueName;
+    constructor(queueName: string);
+    get message(): string;
+}

package/dist/types/src/error/background/DefaultBullMQNativeOptionsMissingQueueConnectionAndDefaultQueueConnection.d.ts

@@ -0,0 +1,3 @@
+export default class DefaultBullMQNativeOptionsMissingQueueConnectionAndDefaultQueueConnection extends Error {
+    get message(): string;
+}

package/dist/types/src/error/background/NamedBullMQNativeOptionsMissingQueueConnectionAndDefaultQueueConnection.d.ts

@@ -0,0 +1,5 @@
+export default class NamedBullMQNativeOptionsMissingQueueConnectionAndDefaultQueueConnection extends Error {
+    private queueName;
+    constructor(queueName: string);
+    get message(): string;
+}

package/dist/types/src/index.d.ts

@@ -1,7 +1,8 @@
-export { default as background, Background, type BackgroundJobConfig, type BackgroundQueuePriority, stopBackgroundWorkers, } from './background/index.js';
+export { default as background, Background, stopBackgroundWorkers } from './background/index.js';
+export { type BackgroundJobConfig, type BackgroundQueuePriority } from './types/background.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 { type BullMQNativeWorkerOptions, default as PsychicApplicationWorkers, type PsychicBackgroundNativeBullMQOptions, type PsychicBackgroundSimpleOptions, type PsychicBackgroundWorkstreamOptions, type QueueOptionsWithConnectionInstance, type RedisOrRedisClusterConnection, type TransitionalPsychicBackgroundSimpleOptions, } from './psychic-application-workers/index.js';
+export { default as PsychicAppWorkers, type BullMQNativeWorkerOptions, type PsychicBackgroundNativeBullMQOptions, type PsychicBackgroundSimpleOptions, type PsychicBackgroundWorkstreamOptions, type QueueOptionsWithConnectionInstance, type RedisOrRedisClusterConnection, type TransitionalPsychicBackgroundSimpleOptions, } from './psychic-app-workers/index.js';
 export { default as NoQueueForSpecifiedQueueName } from './error/background/NoQueueForSpecifiedQueueName.js';
 export { default as NoQueueForSpecifiedWorkstream } from './error/background/NoQueueForSpecifiedWorkstream.js';

package/dist/types/src/psychic-app-workers/cache.d.ts

@@ -0,0 +1,4 @@
+import PsychicAppWorkers from './index.js';
+export declare function cachePsychicWorkersApp(psychicWorkersApp: PsychicAppWorkers): void;
+export declare function getCachedPsychicWorkersApp(): PsychicAppWorkers | undefined;
+export declare function getCachedPsychicWorkersAppOrFail(): PsychicAppWorkers;