@monque/tsed 0.1.0 → 1.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@monque/tsed",
-	"version": "0.1.0",
+	"version": "1.0.0",
 	"description": "Ts.ED integration for Monque - A robust, type-safe MongoDB job queue for TypeScript",
 	"author": "Maurice de Bruyn <debruyn.maurice@gmail.com>",
 	"repository": {
@@ -68,11 +68,11 @@
 		"lint": "biome check ."
 	},
 	"peerDependencies": {
-		"@monque/core": "^1.1.2",
+		"@monque/core": "^1.2.0",
 		"@tsed/core": "^8.24.1",
 		"@tsed/di": "^8.24.1",
 		"@tsed/mongoose": "^8.24.1",
-		"mongodb": "^7.0.0"
+		"mongodb": "catalog:"
 	},
 	"peerDependenciesMeta": {
 		"@tsed/mongoose": {
@@ -81,18 +81,18 @@
 	},
 	"devDependencies": {
 		"@monque/core": "workspace:*",
-		"@testcontainers/mongodb": "^11.11.0",
-		"@total-typescript/ts-reset": "^0.6.1",
+		"@testcontainers/mongodb": "catalog:",
+		"@total-typescript/ts-reset": "catalog:",
 		"@tsed/core": "^8.24.1",
 		"@tsed/di": "^8.24.1",
 		"@tsed/mongoose": "^8.24.1",
 		"@tsed/platform-http": "^8.24.1",
 		"@tsed/testcontainers-mongo": "^8.24.1",
-		"@types/bun": "^1.3.7",
-		"@vitest/coverage-v8": "^4.0.18",
-		"mongodb": "^7.0.0",
+		"@types/node": "catalog:",
+		"@vitest/coverage-v8": "catalog:",
+		"mongodb": "catalog:",
 		"testcontainers": "^11.11.0",
-		"tsdown": "^0.20.1",
-		"vitest": "^4.0.18"
+		"tsdown": "catalog:",
+		"vitest": "catalog:"
 	}
 }

package/src/config/config.ts

@@ -4,6 +4,8 @@
  * Defines the configuration interface and TsED module augmentation.
  */
 
+import { MonqueError } from '@monque/core';
+
 import type { MonqueTsedConfig } from './types.js';
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -47,13 +49,13 @@ export function validateDatabaseConfig(config: MonqueTsedConfig): void {
 	const strategies = [config.db, config.dbFactory, config.dbToken].filter(Boolean);
 
 	if (strategies.length === 0) {
-		throw new Error(
+		throw new MonqueError(
 			"MonqueTsedConfig requires exactly one of 'db', 'dbFactory', or 'dbToken' to be set",
 		);
 	}
 
 	if (strategies.length > 1) {
-		throw new Error(
+		throw new MonqueError(
 			"MonqueTsedConfig accepts only one of 'db', 'dbFactory', or 'dbToken' - multiple were provided",
 		);
 	}

package/src/config/types.ts

@@ -24,12 +24,12 @@ import type { Db } from 'mongodb';
  * export class Server {}
  * ```
  */
-export interface MonqueTsedConfig extends Omit<MonqueOptions, 'db'> {
+export interface MonqueTsedConfig extends MonqueOptions {
 	/**
 	 * Enable or disable the Monque module.
 	 *
 	 * When disabled:
-	 * - Workers are not registered
+	 * - Jobs are not registered
 	 * - Lifecycle hooks are no-ops
 	 * - MonqueService throws on access
 	 *
@@ -111,4 +111,37 @@ export interface MonqueTsedConfig extends Omit<MonqueOptions, 'db'> {
 	 * @default "default"
 	 */
 	mongooseConnectionId?: string;
+
+	/**
+	 * Disable job processing on this instance.
+	 *
+	 * When true, the module will initialize the database connection (allowing you to
+	 * enqueue jobs via MonqueService) but will NOT register jobs or start the
+	 * polling loop. Useful for "Producer-only" nodes like API servers that only
+	 * enqueue jobs but don't process them.
+	 *
+	 * @example
+	 * ```typescript
+	 * // API Server (Producer-only)
+	 * @Configuration({
+	 *   monque: {
+	 *     dbFactory: async () => client.db('myapp'),
+	 *     disableJobProcessing: true, // Only enqueue, don't process
+	 *   }
+	 * })
+	 * export class ApiServer {}
+	 *
+	 * // Job Server (Consumer)
+	 * @Configuration({
+	 *   monque: {
+	 *     dbFactory: async () => client.db('myapp'),
+	 *     // disableJobProcessing defaults to false - processes jobs
+	 *   }
+	 * })
+	 * export class JobServer {}
+	 * ```
+	 *
+	 * @default false
+	 */
+	disableJobProcessing?: boolean;
 }

package/src/constants/constants.ts

@@ -1,7 +1,7 @@
 /**
  * Symbol used to store decorator metadata on class constructors.
  *
- * Used by @WorkerController, @Worker, and @Cron decorators to attach
+ * Used by @JobController, @Job, and @Cron decorators to attach
  * metadata that is later collected by MonqueModule during initialization.
  *
  * @example

package/src/constants/types.ts

@@ -3,14 +3,14 @@
  *
  * These constants are used to categorize providers registered with Ts.ED's
  * dependency injection container, enabling MonqueModule to discover and
- * register workers automatically.
+ * register jobs automatically.
  *
  * Note: Using string constants with `as const` instead of enums per
  * Constitution guidelines.
  */
 export const ProviderTypes = {
-	/** Provider type for @WorkerController decorated classes */
-	WORKER_CONTROLLER: 'monque:worker-controller',
+	/** Provider type for @JobController decorated classes */
+	JOB_CONTROLLER: 'monque:job-controller',
 	/** Provider type for cron job handlers */
 	CRON: 'monque:cron',
 } as const;

package/src/decorators/cron.ts

@@ -1,7 +1,7 @@
 import { Store } from '@tsed/core';
 
 import { MONQUE } from '@/constants';
-import type { CronDecoratorOptions, CronMetadata, WorkerStore } from '@/decorators/types.js';
+import type { CronDecoratorOptions, CronMetadata, JobStore } from '@/decorators/types.js';
 
 /**
  * Method decorator that registers a method as a scheduled cron job.
@@ -11,8 +11,8 @@ import type { CronDecoratorOptions, CronMetadata, WorkerStore } from '@/decorato
  *
  * @example
  * ```typescript
- * @WorkerController()
- * class ReportWorkers {
+ * @JobController()
+ * class ReportJobs {
  *   @Cron("@daily", { timezone: "UTC" })
  *   async generateDailyReport() {
  *     // ...
@@ -41,9 +41,9 @@ export function Cron(pattern: string, options?: CronDecoratorOptions): MethodDec
 		const store = Store.from(targetConstructor);
 
 		// Get or initialize the MONQUE store
-		const existing = store.get<Partial<WorkerStore>>(MONQUE) || {
+		const existing = store.get<Partial<JobStore>>(MONQUE) || {
 			type: 'controller',
-			workers: [],
+			jobs: [],
 			cronJobs: [],
 		};
 

package/src/decorators/index.ts

@@ -1,10 +1,10 @@
 export { Cron } from './cron.js';
+export { Job } from './job.js';
+export { JobController } from './job-controller.js';
 export type {
 	CronDecoratorOptions,
 	CronMetadata,
-	WorkerDecoratorOptions,
-	WorkerMetadata,
-	WorkerStore,
+	JobDecoratorOptions,
+	JobMetadata,
+	JobStore,
 } from './types.js';
-export { Worker } from './worker.js';
-export { WorkerController } from './worker-controller.js';

package/src/decorators/{worker-controller.ts → job-controller.ts}

@@ -1,17 +1,17 @@
 /**
- * @WorkerController class decorator
+ * @JobController class decorator
  *
- * Marks a class as containing worker methods and registers it with the Ts.ED DI container.
- * Workers in the class will have their job names prefixed with the namespace.
+ * Marks a class as containing job methods and registers it with the Ts.ED DI container.
+ * Jobs in the class will have their job names prefixed with the namespace.
  *
  * @param namespace - Optional prefix for all job names in this controller.
  *                    When set, job names become "{namespace}.{name}".
  *
  * @example
  * ```typescript
- * @WorkerController("email")
- * export class EmailWorkers {
- *   @Worker("send")  // Registered as "email.send"
+ * @JobController("email")
+ * export class EmailJobs {
+ *   @Job("send")  // Registered as "email.send"
  *   async send(job: Job<EmailPayload>) { }
  * }
  * ```
@@ -21,35 +21,35 @@ import { Injectable } from '@tsed/di';
 
 import { MONQUE, ProviderTypes } from '@/constants';
 
-import type { WorkerStore } from './types.js';
+import type { JobStore } from './types.js';
 
 /**
- * Class decorator that registers a class as a worker controller.
+ * Class decorator that registers a class as a job controller.
  *
  * @param namespace - Optional namespace prefix for job names
  */
-export function WorkerController(namespace?: string): ClassDecorator {
+export function JobController(namespace?: string): ClassDecorator {
 	return useDecorators(
 		// Register as injectable with custom provider type
 		Injectable({
-			type: ProviderTypes.WORKER_CONTROLLER,
+			type: ProviderTypes.JOB_CONTROLLER,
 		}),
 		// Apply custom decorator to store metadata
 		(target: object) => {
 			const store = Store.from(target);
 
 			// Get existing store or create new one
-			const existing = store.get<Partial<WorkerStore>>(MONQUE) || {};
+			const existing = store.get<Partial<JobStore>>(MONQUE) || {};
 
 			// Merge with new metadata, only include namespace if defined
-			const workerStore: WorkerStore = {
+			const jobStore: JobStore = {
 				type: 'controller',
 				...(namespace !== undefined && { namespace }),
-				workers: existing.workers || [],
+				jobs: existing.jobs || [],
 				cronJobs: existing.cronJobs || [],
 			};
 
-			store.set(MONQUE, workerStore);
+			store.set(MONQUE, jobStore);
 		},
 	);
 }

package/src/decorators/{worker.ts → job.ts}

@@ -1,17 +1,17 @@
 /**
- * @Worker method decorator
+ * @Job method decorator
  *
  * Registers a method as a job handler. The method will be called when a job
  * with the matching name is picked up for processing.
  *
  * @param name - Job name (combined with controller namespace if present).
- * @param options - Worker configuration options.
+ * @param options - Job configuration options.
  *
  * @example
  * ```typescript
- * @WorkerController("notifications")
- * export class NotificationWorkers {
- *   @Worker("push", { concurrency: 10 })
+ * @JobController("notifications")
+ * export class NotificationJobs {
+ *   @Job("push", { concurrency: 10 })
  *   async sendPush(job: Job<PushPayload>) {
  *     await pushService.send(job.data);
  *   }
@@ -22,15 +22,15 @@ import { Store } from '@tsed/core';
 
 import { MONQUE } from '@/constants';
 
-import type { WorkerDecoratorOptions, WorkerMetadata, WorkerStore } from './types.js';
+import type { JobDecoratorOptions, JobMetadata, JobStore } from './types.js';
 
 /**
  * Method decorator that registers a method as a job handler.
  *
  * @param name - The job name (will be prefixed with controller namespace if present)
- * @param options - Optional worker configuration (concurrency, replace, etc.)
+ * @param options - Optional job configuration (concurrency, replace, etc.)
  */
-export function Worker(name: string, options?: WorkerDecoratorOptions): MethodDecorator {
+export function Job(name: string, options?: JobDecoratorOptions): MethodDecorator {
 	return <T>(
 		target: object,
 		propertyKey: string | symbol,
@@ -38,7 +38,7 @@ export function Worker(name: string, options?: WorkerDecoratorOptions): MethodDe
 	): void => {
 		const methodName = String(propertyKey);
 
-		const workerMetadata: WorkerMetadata = {
+		const jobMetadata: JobMetadata = {
 			name,
 			method: methodName,
 			opts: options || {},
@@ -49,18 +49,18 @@ export function Worker(name: string, options?: WorkerDecoratorOptions): MethodDe
 		const store = Store.from(targetConstructor);
 
 		// Get or initialize the MONQUE store
-		const existing = store.get<Partial<WorkerStore>>(MONQUE) || {
+		const existing = store.get<Partial<JobStore>>(MONQUE) || {
 			type: 'controller',
-			workers: [],
+			jobs: [],
 			cronJobs: [],
 		};
 
-		// Add this worker to the list
-		const workers = [...(existing.workers || []), workerMetadata];
+		// Add this job to the list
+		const jobs = [...(existing.jobs || []), jobMetadata];
 
 		store.set(MONQUE, {
 			...existing,
-			workers,
+			jobs,
 		});
 	};
 }

package/src/decorators/types.ts

@@ -5,27 +5,27 @@
 import type { WorkerOptions as CoreWorkerOptions, ScheduleOptions } from '@monque/core';
 
 // ─────────────────────────────────────────────────────────────────────────────
-// Worker Decorator Options
+// Job Decorator Options
 // ─────────────────────────────────────────────────────────────────────────────
 
 /**
- * Options for the @Worker method decorator.
+ * Options for the @Job method decorator.
  *
  * Maps to @monque/core WorkerOptions. All standard Monque worker options
  * are exposed here for decorator-based configuration.
  */
-export interface WorkerDecoratorOptions extends CoreWorkerOptions {}
+export interface JobDecoratorOptions extends CoreWorkerOptions {}
 
 // ─────────────────────────────────────────────────────────────────────────────
-// Worker Metadata
+// Job Metadata
 // ─────────────────────────────────────────────────────────────────────────────
 
 /**
- * Metadata for a single @Worker decorated method.
+ * Metadata for a single @Job decorated method.
  *
- * Stored in the WorkerStore and used by MonqueModule to register workers.
+ * Stored in the JobStore and used by MonqueModule to register workers.
  */
-export interface WorkerMetadata {
+export interface JobMetadata {
 	/**
 	 * Job name (without namespace prefix).
 	 * Combined with controller namespace to form full job name.
@@ -38,9 +38,9 @@ export interface WorkerMetadata {
 	method: string;
 
 	/**
-	 * Worker options forwarded to Monque.register().
+	 * Job options forwarded to Monque.register().
 	 */
-	opts: WorkerDecoratorOptions;
+	opts: JobDecoratorOptions;
 }
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -66,7 +66,7 @@ export interface CronDecoratorOptions extends ScheduleOptions {
 /**
  * Metadata for a single @Cron decorated method.
  *
- * Stored in the WorkerStore and used by MonqueModule to schedule cron jobs.
+ * Stored in the JobStore and used by MonqueModule to schedule cron jobs.
  */
 export interface CronMetadata {
 	/**
@@ -91,25 +91,25 @@ export interface CronMetadata {
 }
 
 // ─────────────────────────────────────────────────────────────────────────────
-// Worker Store
+// Job Store
 // ─────────────────────────────────────────────────────────────────────────────
 
 /**
- * Complete metadata structure stored on @WorkerController classes.
+ * Complete metadata structure stored on @JobController classes.
  *
  * Accessed via `Store.from(Class).get(MONQUE)`.
  *
  * @example
  * ```typescript
- * const store = Store.from(EmailWorkers).get<WorkerStore>(MONQUE);
+ * const store = Store.from(EmailJobs).get<JobStore>(MONQUE);
  * console.log(store.namespace); // "email"
- * console.log(store.workers); // [{ name: "send", method: "sendEmail", opts: {} }]
+ * console.log(store.jobs); // [{ name: "send", method: "sendEmail", opts: {} }]
  * ```
  */
-export interface WorkerStore {
+export interface JobStore {
 	/**
 	 * Type identifier for the store.
-	 * Always "controller" for WorkerController.
+	 * Always "controller" for JobController.
 	 */
 	type: 'controller';
 
@@ -120,9 +120,9 @@ export interface WorkerStore {
 	namespace?: string;
 
 	/**
-	 * Worker method registrations from @Worker decorators.
+	 * Job method registrations from @Job decorators.
 	 */
-	workers: WorkerMetadata[];
+	jobs: JobMetadata[];
 
 	/**
 	 * Cron job registrations from @Cron decorators.

package/src/index.ts

@@ -3,18 +3,18 @@ export { MONQUE, type ProviderType, ProviderTypes } from './constants';
 export type {
 	CronDecoratorOptions,
 	CronMetadata,
-	WorkerDecoratorOptions,
-	WorkerMetadata,
-	WorkerStore,
+	JobDecoratorOptions,
+	JobMetadata,
+	JobStore,
 } from './decorators';
-export { Cron, Worker, WorkerController } from './decorators';
+export { Cron, Job, JobController } from './decorators';
 export { MonqueModule } from './monque-module.js';
 export { MonqueService } from './services';
 export {
 	buildJobName,
-	type CollectedWorkerMetadata,
-	collectWorkerMetadata,
-	getWorkerToken,
+	type CollectedJobMetadata,
+	collectJobMetadata,
+	getJobToken,
 	type InjectorFn,
 	resolveDatabase,
 } from './utils';

package/src/monque-module.ts

@@ -2,15 +2,17 @@
  * MonqueModule - Main Integration Module
  *
  * Orchestrates the integration between Monque and Ts.ED.
- * Handles lifecycle hooks, configuration resolution, and worker registration.
+ * Handles lifecycle hooks, configuration resolution, and job registration.
  */
 
 import {
 	type Job,
 	Monque,
+	MonqueError,
 	type MonqueOptions,
 	type ScheduleOptions,
 	type WorkerOptions,
+	WorkerRegistrationError,
 } from '@monque/core';
 import {
 	Configuration,
@@ -29,7 +31,7 @@ import {
 import { type MonqueTsedConfig, validateDatabaseConfig } from '@/config';
 import { ProviderTypes } from '@/constants';
 import { MonqueService } from '@/services';
-import { collectWorkerMetadata, resolveDatabase } from '@/utils';
+import { collectJobMetadata, resolveDatabase } from '@/utils';
 
 @Module({
 	imports: [MonqueService],
@@ -80,11 +82,13 @@ export class MonqueModule implements OnInit, OnDestroy {
 			this.logger.info('Monque: Connecting to MongoDB...');
 			await this.monque.initialize();
 
-			await this.registerWorkers();
-
-			await this.monque.start();
-
-			this.logger.info('Monque: Started successfully');
+			if (config.disableJobProcessing) {
+				this.logger.info('Monque: Job processing is disabled for this instance');
+			} else {
+				await this.registerJobs();
+				await this.monque.start();
+				this.logger.info('Monque: Started successfully');
+			}
 		} catch (error) {
 			this.logger.error({
 				event: 'MONQUE_INIT_ERROR',
@@ -107,22 +111,22 @@ export class MonqueModule implements OnInit, OnDestroy {
 	}
 
 	/**
-	 * Discover and register all workers from @WorkerController providers
+	 * Discover and register all jobs from @JobController providers
 	 */
-	protected async registerWorkers(): Promise<void> {
+	protected async registerJobs(): Promise<void> {
 		if (!this.monque) {
-			throw new Error('Monque instance not initialized');
+			throw new MonqueError('Monque instance not initialized');
 		}
 
 		const monque = this.monque;
-		const workerControllers = this.injector.getProviders(ProviderTypes.WORKER_CONTROLLER);
+		const jobControllers = this.injector.getProviders(ProviderTypes.JOB_CONTROLLER);
 		const registeredJobs = new Set<string>();
 
-		this.logger.info(`Monque: Found ${workerControllers.length} worker controllers`);
+		this.logger.info(`Monque: Found ${jobControllers.length} job controllers`);
 
-		for (const provider of workerControllers) {
+		for (const provider of jobControllers) {
 			const useClass = provider.useClass;
-			const workers = collectWorkerMetadata(useClass);
+			const jobs = collectJobMetadata(useClass);
 			// Try to resolve singleton instance immediately
 			const instance = this.injector.get(provider.token);
 
@@ -134,12 +138,13 @@ export class MonqueModule implements OnInit, OnDestroy {
 				continue;
 			}
 
-			for (const worker of workers) {
-				const { fullName, method, opts, isCron, cronPattern } = worker;
+			for (const job of jobs) {
+				const { fullName, method, opts, isCron, cronPattern } = job;
 
 				if (registeredJobs.has(fullName)) {
-					throw new Error(
+					throw new WorkerRegistrationError(
 						`Monque: Duplicate job registration detected. Job "${fullName}" is already registered.`,
+						fullName,
 					);
 				}
 
@@ -188,7 +193,7 @@ export class MonqueModule implements OnInit, OnDestroy {
 					monque.register(fullName, handler, opts as WorkerOptions);
 					await monque.schedule(cronPattern, fullName, {}, opts as ScheduleOptions);
 				} else {
-					this.logger.debug(`Monque: Registering worker "${fullName}"`);
+					this.logger.debug(`Monque: Registering job "${fullName}"`);
 					monque.register(fullName, handler, opts as WorkerOptions);
 				}
 			}

package/src/utils/build-job-name.ts

@@ -1,8 +1,8 @@
 /**
  * Build the full job name by combining namespace and name.
  *
- * @param namespace - Optional namespace from @WorkerController
- * @param name - Job name from @Worker or @Cron
+ * @param namespace - Optional namespace from @JobController
+ * @param name - Job name from @Job or @Cron
  * @returns Full job name (e.g., "email.send" or just "send")
  *
  * @example