@amqp-contract/worker-nestjs 0.2.0 → 0.2.1

package/README.md

@@ -1,6 +1,14 @@
 # @amqp-contract/worker-nestjs
 
-NestJS integration for [@amqp-contract/worker](../worker). Type-safe AMQP message consumption with automatic lifecycle management.
+**NestJS integration for [@amqp-contract/worker](../worker). Type-safe AMQP message consumption with automatic lifecycle management.**
+
+[![CI](https://github.com/btravers/amqp-contract/actions/workflows/ci.yml/badge.svg)](https://github.com/btravers/amqp-contract/actions/workflows/ci.yml)
+[![npm version](https://img.shields.io/npm/v/@amqp-contract/worker-nestjs.svg?logo=npm)](https://www.npmjs.com/package/@amqp-contract/worker-nestjs)
+[![npm downloads](https://img.shields.io/npm/dm/@amqp-contract/worker-nestjs.svg)](https://www.npmjs.com/package/@amqp-contract/worker-nestjs)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.9-blue?logo=typescript)](https://www.typescriptlang.org/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+📖 **[Full documentation →](https://btravers.github.io/amqp-contract/guide/worker-nestjs-usage)**
 
 ## Installation
 
@@ -33,6 +41,10 @@ export class AppModule {}
 
 The worker automatically starts consuming messages when the module initializes and cleans up on shutdown.
 
+## Documentation
+
+📖 **[Read the full documentation →](https://btravers.github.io/amqp-contract)**
+
 ## License
 
 MIT

package/dist/index.cjs

@@ -39,21 +39,28 @@ let AmqpWorkerService = class AmqpWorkerService$1 {
 		this.options = options;
 	}
 	/**
-	* Initialize the worker when the NestJS module starts
+	* Initialize the AMQP worker when the NestJS module starts.
+	*
+	* This lifecycle hook automatically creates and starts the worker,
+	* beginning message consumption from all configured consumers.
+	* The connection will be established in the background with
+	* automatic reconnection handling.
+	*
+	* @throws Error if the worker fails to start
 	*/
 	async onModuleInit() {
-		this.worker = await _amqp_contract_worker.TypedAmqpWorker.create({
-			contract: this.options.contract,
-			handlers: this.options.handlers,
-			connection: this.options.connection
-		});
+		this.worker = await _amqp_contract_worker.TypedAmqpWorker.create(this.options).resultToPromise();
 	}
 	/**
-	* Close the worker when the NestJS module is destroyed
+	* Close the AMQP worker when the NestJS module is destroyed.
+	*
+	* This lifecycle hook ensures proper cleanup of resources when the
+	* NestJS application shuts down, gracefully stopping message consumption
+	* and closing the connection.
 	*/
 	async onModuleDestroy() {
 		if (this.worker) {
-			await this.worker.close();
+			await this.worker.close().resultToPromise();
 			this.worker = null;
 		}
 	}

package/dist/index.d.cts

@@ -1,31 +1,97 @@
 import * as _nestjs_common0 from "@nestjs/common";
 import { OnModuleDestroy, OnModuleInit } from "@nestjs/common";
-import { Options } from "amqplib";
-import { ContractDefinition, WorkerInferConsumerHandlers } from "@amqp-contract/contract";
+import { ContractDefinition } from "@amqp-contract/contract";
+import { AmqpConnectionManagerOptions, ConnectionUrl } from "amqp-connection-manager";
+import { WorkerInferConsumerHandlers } from "@amqp-contract/worker";
 
 //#region src/worker.service.d.ts
+
 /**
- * Options for creating a NestJS worker service
+ * Configuration options for the AMQP worker NestJS module.
+ *
+ * @typeParam TContract - The contract definition type
+ *
+ * @example
+ * ```typescript
+ * const options: AmqpWorkerModuleOptions<typeof contract> = {
+ *   contract: myContract,
+ *   handlers: {
+ *     processOrder: async (message) => {
+ *       console.log('Processing order:', message.orderId);
+ *     }
+ *   },
+ *   urls: ['amqp://localhost'],
+ *   connectionOptions: {
+ *     heartbeatIntervalInSeconds: 30
+ *   }
+ * };
+ * ```
  */
 interface AmqpWorkerModuleOptions<TContract extends ContractDefinition> {
+  /** The AMQP contract definition specifying consumers and their message schemas */
   contract: TContract;
+  /** Message handlers for each consumer defined in the contract */
   handlers: WorkerInferConsumerHandlers<TContract>;
-  connection: string | Options.Connect;
+  /** AMQP broker URL(s). Multiple URLs provide failover support */
+  urls: ConnectionUrl[];
+  /** Optional connection configuration (heartbeat, reconnect settings, etc.) */
+  connectionOptions?: AmqpConnectionManagerOptions | undefined;
 }
 /**
- * Type-safe AMQP worker service for NestJS
- * This service integrates @amqp-contract/worker with NestJS lifecycle
+ * Type-safe AMQP worker service for NestJS applications.
+ *
+ * This service wraps {@link TypedAmqpWorker} and integrates it with the NestJS
+ * lifecycle, automatically starting message consumption on module init and
+ * cleaning up resources on module destroy.
+ *
+ * @typeParam TContract - The contract definition type
+ *
+ * @example
+ * ```typescript
+ * // In your module
+ * import { AmqpWorkerModule } from '@amqp-contract/worker-nestjs';
+ *
+ * @Module({
+ *   imports: [
+ *     AmqpWorkerModule.forRoot({
+ *       contract: myContract,
+ *       handlers: {
+ *         processOrder: async (message) => {
+ *           console.log('Received order:', message.orderId);
+ *           // Process the order...
+ *         }
+ *       },
+ *       urls: ['amqp://localhost']
+ *     })
+ *   ]
+ * })
+ * export class AppModule {}
+ *
+ * // The worker automatically starts consuming messages when the module initializes
+ * // and stops gracefully when the application shuts down
+ * ```
  */
 declare class AmqpWorkerService<TContract extends ContractDefinition> implements OnModuleInit, OnModuleDestroy {
   private readonly options;
   private worker;
   constructor(options: AmqpWorkerModuleOptions<TContract>);
   /**
-   * Initialize the worker when the NestJS module starts
+   * Initialize the AMQP worker when the NestJS module starts.
+   *
+   * This lifecycle hook automatically creates and starts the worker,
+   * beginning message consumption from all configured consumers.
+   * The connection will be established in the background with
+   * automatic reconnection handling.
+   *
+   * @throws Error if the worker fails to start
    */
   onModuleInit(): Promise<void>;
   /**
-   * Close the worker when the NestJS module is destroyed
+   * Close the AMQP worker when the NestJS module is destroyed.
+   *
+   * This lifecycle hook ensures proper cleanup of resources when the
+   * NestJS application shuts down, gracefully stopping message consumption
+   * and closing the connection.
    */
   onModuleDestroy(): Promise<void>;
 }
@@ -35,7 +101,7 @@ declare class AmqpWorkerService<TContract extends ContractDefinition> implements
  * ConfigurableModuleBuilder for AMQP worker module
  * This creates forRoot and forRootAsync methods automatically
  */
-declare const ConfigurableModuleClass: _nestjs_common0.ConfigurableModuleCls<AmqpWorkerModuleOptions<never>, "forRoot", "create", {}>, MODULE_OPTIONS_TOKEN: string | symbol;
+declare const ConfigurableModuleClass: _nestjs_common0.ConfigurableModuleCls<AmqpWorkerModuleOptions<ContractDefinition>, "forRoot", "create", {}>, MODULE_OPTIONS_TOKEN: string | symbol;
 //#endregion
 //#region src/worker.module.d.ts
 /**

package/dist/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../src/worker.service.ts","../src/worker.module-definition.ts","../src/worker.module.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AASiB,UAAA,uBAAuB,CAAA,kBAAmB,kBAAnB,CAAA,CAAA;EAAmB,QAAA,EAC/C,SAD+C;EAC/C,QAAA,EACA,2BADA,CAC4B,SAD5B,CAAA;EAC4B,UAAA,EAAA,MAAA,GACjB,OAAA,CAAQ,OADS;;;;AAQxC;;AAQsD,cAPzC,iBAOyC,CAAA,kBAPL,kBAOK,CAAA,YANzC,YAMyC,EAN3B,eAM2B,CAAA;EAAxB,iBAAA,OAAA;EAMN,QAAA,MAAA;EAWG,WAAA,CAAA,OAAA,EAjBG,uBAiBH,CAjB2B,SAiB3B,CAAA;EAvBd;;;kBAYW;;;AC1BxB;EAAwC,eAAA,CAAA,CAAA,EDqCb,OCrCa,CAAA,IAAA,CAAA;;;;;;;;cAAzB,yBAAuB,eAAA,CAAA,sBAAA;;;;;;;;ADErB,cEIJ,gBAAA,SAAyB,uBAAA,CFJE"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/worker.service.ts","../src/worker.module-definition.ts","../src/worker.module.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;AA2BA;;;;;;;;AA6CA;;;;;;;;;;UA7CiB,0CAA0C;;ECnB5C,QAAA,EDqBH,SCrBG;EAAuB;EAAA,QAAA,EDuB1B,2BCvB0B,CDuBE,SCvBF,CAAA;EAAA;EAAA,IAAA,EDyB9B,aCzB8B,EAAA;EAAE;sBD2BlB;;;AE1BtB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cFgEa,oCAAoC,+BACpC,cAAc;;;uBAMG,wBAAwB;;;;;;;;;;;kBAa9B;;;;;;;;qBAWG;;;;;;;;cChGZ,yBAAuB,eAAA,CAAA,sBAAA,wBAAA;;;;;;;;cCKzB,gBAAA,SAAyB,uBAAA"}

package/dist/index.d.mts

@@ -1,31 +1,97 @@
 import * as _nestjs_common0 from "@nestjs/common";
 import { OnModuleDestroy, OnModuleInit } from "@nestjs/common";
-import { Options } from "amqplib";
-import { ContractDefinition, WorkerInferConsumerHandlers } from "@amqp-contract/contract";
+import { WorkerInferConsumerHandlers } from "@amqp-contract/worker";
+import { ContractDefinition } from "@amqp-contract/contract";
+import { AmqpConnectionManagerOptions, ConnectionUrl } from "amqp-connection-manager";
 
 //#region src/worker.service.d.ts
+
 /**
- * Options for creating a NestJS worker service
+ * Configuration options for the AMQP worker NestJS module.
+ *
+ * @typeParam TContract - The contract definition type
+ *
+ * @example
+ * ```typescript
+ * const options: AmqpWorkerModuleOptions<typeof contract> = {
+ *   contract: myContract,
+ *   handlers: {
+ *     processOrder: async (message) => {
+ *       console.log('Processing order:', message.orderId);
+ *     }
+ *   },
+ *   urls: ['amqp://localhost'],
+ *   connectionOptions: {
+ *     heartbeatIntervalInSeconds: 30
+ *   }
+ * };
+ * ```
  */
 interface AmqpWorkerModuleOptions<TContract extends ContractDefinition> {
+  /** The AMQP contract definition specifying consumers and their message schemas */
   contract: TContract;
+  /** Message handlers for each consumer defined in the contract */
   handlers: WorkerInferConsumerHandlers<TContract>;
-  connection: string | Options.Connect;
+  /** AMQP broker URL(s). Multiple URLs provide failover support */
+  urls: ConnectionUrl[];
+  /** Optional connection configuration (heartbeat, reconnect settings, etc.) */
+  connectionOptions?: AmqpConnectionManagerOptions | undefined;
 }
 /**
- * Type-safe AMQP worker service for NestJS
- * This service integrates @amqp-contract/worker with NestJS lifecycle
+ * Type-safe AMQP worker service for NestJS applications.
+ *
+ * This service wraps {@link TypedAmqpWorker} and integrates it with the NestJS
+ * lifecycle, automatically starting message consumption on module init and
+ * cleaning up resources on module destroy.
+ *
+ * @typeParam TContract - The contract definition type
+ *
+ * @example
+ * ```typescript
+ * // In your module
+ * import { AmqpWorkerModule } from '@amqp-contract/worker-nestjs';
+ *
+ * @Module({
+ *   imports: [
+ *     AmqpWorkerModule.forRoot({
+ *       contract: myContract,
+ *       handlers: {
+ *         processOrder: async (message) => {
+ *           console.log('Received order:', message.orderId);
+ *           // Process the order...
+ *         }
+ *       },
+ *       urls: ['amqp://localhost']
+ *     })
+ *   ]
+ * })
+ * export class AppModule {}
+ *
+ * // The worker automatically starts consuming messages when the module initializes
+ * // and stops gracefully when the application shuts down
+ * ```
  */
 declare class AmqpWorkerService<TContract extends ContractDefinition> implements OnModuleInit, OnModuleDestroy {
   private readonly options;
   private worker;
   constructor(options: AmqpWorkerModuleOptions<TContract>);
   /**
-   * Initialize the worker when the NestJS module starts
+   * Initialize the AMQP worker when the NestJS module starts.
+   *
+   * This lifecycle hook automatically creates and starts the worker,
+   * beginning message consumption from all configured consumers.
+   * The connection will be established in the background with
+   * automatic reconnection handling.
+   *
+   * @throws Error if the worker fails to start
    */
   onModuleInit(): Promise<void>;
   /**
-   * Close the worker when the NestJS module is destroyed
+   * Close the AMQP worker when the NestJS module is destroyed.
+   *
+   * This lifecycle hook ensures proper cleanup of resources when the
+   * NestJS application shuts down, gracefully stopping message consumption
+   * and closing the connection.
    */
   onModuleDestroy(): Promise<void>;
 }
@@ -35,7 +101,7 @@ declare class AmqpWorkerService<TContract extends ContractDefinition> implements
  * ConfigurableModuleBuilder for AMQP worker module
  * This creates forRoot and forRootAsync methods automatically
  */
-declare const ConfigurableModuleClass: _nestjs_common0.ConfigurableModuleCls<AmqpWorkerModuleOptions<never>, "forRoot", "create", {}>, MODULE_OPTIONS_TOKEN: string | symbol;
+declare const ConfigurableModuleClass: _nestjs_common0.ConfigurableModuleCls<AmqpWorkerModuleOptions<ContractDefinition>, "forRoot", "create", {}>, MODULE_OPTIONS_TOKEN: string | symbol;
 //#endregion
 //#region src/worker.module.d.ts
 /**

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/worker.service.ts","../src/worker.module-definition.ts","../src/worker.module.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AASiB,UAAA,uBAAuB,CAAA,kBAAmB,kBAAnB,CAAA,CAAA;EAAmB,QAAA,EAC/C,SAD+C;EAC/C,QAAA,EACA,2BADA,CAC4B,SAD5B,CAAA;EAC4B,UAAA,EAAA,MAAA,GACjB,OAAA,CAAQ,OADS;;;;AAQxC;;AAQsD,cAPzC,iBAOyC,CAAA,kBAPL,kBAOK,CAAA,YANzC,YAMyC,EAN3B,eAM2B,CAAA;EAAxB,iBAAA,OAAA;EAMN,QAAA,MAAA;EAWG,WAAA,CAAA,OAAA,EAjBG,uBAiBH,CAjB2B,SAiB3B,CAAA;EAvBd;;;kBAYW;;;AC1BxB;EAAwC,eAAA,CAAA,CAAA,EDqCb,OCrCa,CAAA,IAAA,CAAA;;;;;;;;cAAzB,yBAAuB,eAAA,CAAA,sBAAA;;;;;;;;ADErB,cEIJ,gBAAA,SAAyB,uBAAA,CFJE"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/worker.service.ts","../src/worker.module-definition.ts","../src/worker.module.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;AA2BA;;;;;;;;AA6CA;;;;;;;;;;UA7CiB,0CAA0C;;ECnB5C,QAAA,EDqBH,SCrBG;EAAuB;EAAA,QAAA,EDuB1B,2BCvB0B,CDuBE,SCvBF,CAAA;EAAA;EAAA,IAAA,EDyB9B,aCzB8B,EAAA;EAAE;sBD2BlB;;;AE1BtB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cFgEa,oCAAoC,+BACpC,cAAc;;;uBAMG,wBAAwB;;;;;;;;;;;kBAa9B;;;;;;;;qBAWG;;;;;;;;cChGZ,yBAAuB,eAAA,CAAA,sBAAA,wBAAA;;;;;;;;cCKzB,gBAAA,SAAyB,uBAAA"}

package/dist/index.mjs

@@ -39,21 +39,28 @@ let AmqpWorkerService = class AmqpWorkerService$1 {
 		this.options = options;
 	}
 	/**
-	* Initialize the worker when the NestJS module starts
+	* Initialize the AMQP worker when the NestJS module starts.
+	*
+	* This lifecycle hook automatically creates and starts the worker,
+	* beginning message consumption from all configured consumers.
+	* The connection will be established in the background with
+	* automatic reconnection handling.
+	*
+	* @throws Error if the worker fails to start
 	*/
 	async onModuleInit() {
-		this.worker = await TypedAmqpWorker.create({
-			contract: this.options.contract,
-			handlers: this.options.handlers,
-			connection: this.options.connection
-		});
+		this.worker = await TypedAmqpWorker.create(this.options).resultToPromise();
 	}
 	/**
-	* Close the worker when the NestJS module is destroyed
+	* Close the AMQP worker when the NestJS module is destroyed.
+	*
+	* This lifecycle hook ensures proper cleanup of resources when the
+	* NestJS application shuts down, gracefully stopping message consumption
+	* and closing the connection.
 	*/
 	async onModuleDestroy() {
 		if (this.worker) {
-			await this.worker.close();
+			await this.worker.close().resultToPromise();
 			this.worker = null;
 		}
 	}

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":["AmqpWorkerService","options: AmqpWorkerModuleOptions<TContract>","AmqpWorkerModule"],"sources":["../src/worker.module-definition.ts","../src/worker.service.ts","../src/worker.module.ts"],"sourcesContent":["import { ConfigurableModuleBuilder } from \"@nestjs/common\";\nimport type { AmqpWorkerModuleOptions } from \"./worker.service.js\";\n\n/**\n * ConfigurableModuleBuilder for AMQP worker module\n * This creates forRoot and forRootAsync methods automatically\n */\nexport const { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN } = new ConfigurableModuleBuilder<\n  AmqpWorkerModuleOptions<never>\n>()\n  .setClassMethodName(\"forRoot\")\n  .build();\n","import { Inject, Injectable, type OnModuleDestroy, type OnModuleInit } from \"@nestjs/common\";\nimport type { Options } from \"amqplib\";\nimport type { ContractDefinition, WorkerInferConsumerHandlers } from \"@amqp-contract/contract\";\nimport { TypedAmqpWorker } from \"@amqp-contract/worker\";\nimport { MODULE_OPTIONS_TOKEN } from \"./worker.module-definition.js\";\n\n/**\n * Options for creating a NestJS worker service\n */\nexport interface AmqpWorkerModuleOptions<TContract extends ContractDefinition> {\n  contract: TContract;\n  handlers: WorkerInferConsumerHandlers<TContract>;\n  connection: string | Options.Connect;\n}\n\n/**\n * Type-safe AMQP worker service for NestJS\n * This service integrates @amqp-contract/worker with NestJS lifecycle\n */\n@Injectable()\nexport class AmqpWorkerService<TContract extends ContractDefinition>\n  implements OnModuleInit, OnModuleDestroy\n{\n  private worker: TypedAmqpWorker<TContract> | null = null;\n\n  constructor(\n    @Inject(MODULE_OPTIONS_TOKEN)\n    private readonly options: AmqpWorkerModuleOptions<TContract>,\n  ) {}\n\n  /**\n   * Initialize the worker when the NestJS module starts\n   */\n  async onModuleInit(): Promise<void> {\n    this.worker = await TypedAmqpWorker.create({\n      contract: this.options.contract,\n      handlers: this.options.handlers,\n      connection: this.options.connection,\n    });\n  }\n\n  /**\n   * Close the worker when the NestJS module is destroyed\n   */\n  async onModuleDestroy(): Promise<void> {\n    if (this.worker) {\n      await this.worker.close();\n      this.worker = null;\n    }\n  }\n}\n","import { Module } from \"@nestjs/common\";\nimport { ConfigurableModuleClass } from \"./worker.module-definition.js\";\nimport { AmqpWorkerService } from \"./worker.service.js\";\n\n/**\n * NestJS module for AMQP worker integration\n * This module provides type-safe AMQP worker functionality using @amqp-contract/worker\n * without relying on NestJS decorators (except for dependency injection)\n */\n@Module({\n  providers: [AmqpWorkerService],\n  exports: [AmqpWorkerService],\n})\nexport class AmqpWorkerModule extends ConfigurableModuleClass {}\n"],"mappings":";;;;;;;;AAOA,MAAa,EAAE,yBAAyB,yBAAyB,IAAI,2BAElE,CACA,mBAAmB,UAAU,CAC7B,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;ACSH,8BAAMA,oBAEb;CACE,AAAQ,SAA4C;CAEpD,YACE,AACiBC,SACjB;EADiB;;;;;CAMnB,MAAM,eAA8B;AAClC,OAAK,SAAS,MAAM,gBAAgB,OAAO;GACzC,UAAU,KAAK,QAAQ;GACvB,UAAU,KAAK,QAAQ;GACvB,YAAY,KAAK,QAAQ;GAC1B,CAAC;;;;;CAMJ,MAAM,kBAAiC;AACrC,MAAI,KAAK,QAAQ;AACf,SAAM,KAAK,OAAO,OAAO;AACzB,QAAK,SAAS;;;;;CA5BnB,YAAY;oBAOR,OAAO,qBAAqB;;;;;;ACb1B,6BAAMC,2BAAyB,wBAAwB;+BAJ7D,OAAO;CACN,WAAW,CAAC,kBAAkB;CAC9B,SAAS,CAAC,kBAAkB;CAC7B,CAAC"}
+{"version":3,"file":"index.mjs","names":["AmqpWorkerService","options: AmqpWorkerModuleOptions<TContract>","AmqpWorkerModule"],"sources":["../src/worker.module-definition.ts","../src/worker.service.ts","../src/worker.module.ts"],"sourcesContent":["import { ConfigurableModuleBuilder } from \"@nestjs/common\";\nimport type { ContractDefinition } from \"@amqp-contract/contract\";\nimport type { AmqpWorkerModuleOptions } from \"./worker.service.js\";\n\n/**\n * ConfigurableModuleBuilder for AMQP worker module\n * This creates forRoot and forRootAsync methods automatically\n */\nexport const { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN } = new ConfigurableModuleBuilder<\n  AmqpWorkerModuleOptions<ContractDefinition>\n>()\n  .setClassMethodName(\"forRoot\")\n  .build();\n","import { Inject, Injectable, type OnModuleDestroy, type OnModuleInit } from \"@nestjs/common\";\nimport type { ContractDefinition } from \"@amqp-contract/contract\";\nimport type { AmqpConnectionManagerOptions, ConnectionUrl } from \"amqp-connection-manager\";\nimport { TypedAmqpWorker, type WorkerInferConsumerHandlers } from \"@amqp-contract/worker\";\nimport { MODULE_OPTIONS_TOKEN } from \"./worker.module-definition.js\";\n\n/**\n * Configuration options for the AMQP worker NestJS module.\n *\n * @typeParam TContract - The contract definition type\n *\n * @example\n * ```typescript\n * const options: AmqpWorkerModuleOptions<typeof contract> = {\n *   contract: myContract,\n *   handlers: {\n *     processOrder: async (message) => {\n *       console.log('Processing order:', message.orderId);\n *     }\n *   },\n *   urls: ['amqp://localhost'],\n *   connectionOptions: {\n *     heartbeatIntervalInSeconds: 30\n *   }\n * };\n * ```\n */\nexport interface AmqpWorkerModuleOptions<TContract extends ContractDefinition> {\n  /** The AMQP contract definition specifying consumers and their message schemas */\n  contract: TContract;\n  /** Message handlers for each consumer defined in the contract */\n  handlers: WorkerInferConsumerHandlers<TContract>;\n  /** AMQP broker URL(s). Multiple URLs provide failover support */\n  urls: ConnectionUrl[];\n  /** Optional connection configuration (heartbeat, reconnect settings, etc.) */\n  connectionOptions?: AmqpConnectionManagerOptions | undefined;\n}\n\n/**\n * Type-safe AMQP worker service for NestJS applications.\n *\n * This service wraps {@link TypedAmqpWorker} and integrates it with the NestJS\n * lifecycle, automatically starting message consumption on module init and\n * cleaning up resources on module destroy.\n *\n * @typeParam TContract - The contract definition type\n *\n * @example\n * ```typescript\n * // In your module\n * import { AmqpWorkerModule } from '@amqp-contract/worker-nestjs';\n *\n * @Module({\n *   imports: [\n *     AmqpWorkerModule.forRoot({\n *       contract: myContract,\n *       handlers: {\n *         processOrder: async (message) => {\n *           console.log('Received order:', message.orderId);\n *           // Process the order...\n *         }\n *       },\n *       urls: ['amqp://localhost']\n *     })\n *   ]\n * })\n * export class AppModule {}\n *\n * // The worker automatically starts consuming messages when the module initializes\n * // and stops gracefully when the application shuts down\n * ```\n */\n@Injectable()\nexport class AmqpWorkerService<TContract extends ContractDefinition>\n  implements OnModuleInit, OnModuleDestroy\n{\n  private worker: TypedAmqpWorker<TContract> | null = null;\n\n  constructor(\n    @Inject(MODULE_OPTIONS_TOKEN)\n    private readonly options: AmqpWorkerModuleOptions<TContract>,\n  ) {}\n\n  /**\n   * Initialize the AMQP worker when the NestJS module starts.\n   *\n   * This lifecycle hook automatically creates and starts the worker,\n   * beginning message consumption from all configured consumers.\n   * The connection will be established in the background with\n   * automatic reconnection handling.\n   *\n   * @throws Error if the worker fails to start\n   */\n  async onModuleInit(): Promise<void> {\n    this.worker = await TypedAmqpWorker.create(this.options).resultToPromise();\n  }\n\n  /**\n   * Close the AMQP worker when the NestJS module is destroyed.\n   *\n   * This lifecycle hook ensures proper cleanup of resources when the\n   * NestJS application shuts down, gracefully stopping message consumption\n   * and closing the connection.\n   */\n  async onModuleDestroy(): Promise<void> {\n    if (this.worker) {\n      await this.worker.close().resultToPromise();\n      this.worker = null;\n    }\n  }\n}\n","import { Module } from \"@nestjs/common\";\nimport { ConfigurableModuleClass } from \"./worker.module-definition.js\";\nimport { AmqpWorkerService } from \"./worker.service.js\";\n\n/**\n * NestJS module for AMQP worker integration\n * This module provides type-safe AMQP worker functionality using @amqp-contract/worker\n * without relying on NestJS decorators (except for dependency injection)\n */\n@Module({\n  providers: [AmqpWorkerService],\n  exports: [AmqpWorkerService],\n})\nexport class AmqpWorkerModule extends ConfigurableModuleClass {}\n"],"mappings":";;;;;;;;AAQA,MAAa,EAAE,yBAAyB,yBAAyB,IAAI,2BAElE,CACA,mBAAmB,UAAU,CAC7B,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;AC6DH,8BAAMA,oBAEb;CACE,AAAQ,SAA4C;CAEpD,YACE,AACiBC,SACjB;EADiB;;;;;;;;;;;;CAanB,MAAM,eAA8B;AAClC,OAAK,SAAS,MAAM,gBAAgB,OAAO,KAAK,QAAQ,CAAC,iBAAiB;;;;;;;;;CAU5E,MAAM,kBAAiC;AACrC,MAAI,KAAK,QAAQ;AACf,SAAM,KAAK,OAAO,OAAO,CAAC,iBAAiB;AAC3C,QAAK,SAAS;;;;;CAnCnB,YAAY;oBAOR,OAAO,qBAAqB;;;;;;AClE1B,6BAAMC,2BAAyB,wBAAwB;+BAJ7D,OAAO;CACN,WAAW,CAAC,kBAAkB;CAC9B,SAAS,CAAC,kBAAkB;CAC7B,CAAC"}

package/docs/index.md

@@ -0,0 +1,226 @@
+**@amqp-contract/worker-nestjs**
+
+***
+
+# @amqp-contract/worker-nestjs
+
+## Classes
+
+### AmqpWorkerModule
+
+Defined in: [packages/worker-nestjs/src/worker.module.ts:14](https://github.com/btravers/amqp-contract/blob/f0945f098387fd3a6a40beac8cbe2ed7a4de210a/packages/worker-nestjs/src/worker.module.ts#L14)
+
+NestJS module for AMQP worker integration
+This module provides type-safe AMQP worker functionality using @amqp-contract/worker
+without relying on NestJS decorators (except for dependency injection)
+
+#### Extends
+
+- `ConfigurableModuleClass`
+
+#### Indexable
+
+```ts
+[key: string]: any
+```
+
+#### Constructors
+
+##### Constructor
+
+```ts
+new AmqpWorkerModule(): AmqpWorkerModule;
+```
+
+Defined in: node\_modules/.pnpm/@nestjs+common@11.1.10\_reflect-metadata@0.2.2\_rxjs@7.8.2/node\_modules/@nestjs/common/module-utils/interfaces/configurable-module-cls.interface.d.ts:12
+
+###### Returns
+
+[`AmqpWorkerModule`](#amqpworkermodule)
+
+###### Inherited from
+
+```ts
+ConfigurableModuleClass.constructor
+```
+
+#### Properties
+
+| Property | Modifier | Type | Inherited from | Defined in |
+| ------ | ------ | ------ | ------ | ------ |
+| <a id="forroot"></a> `forRoot` | `static` | (`options`) => `DynamicModule` | `ConfigurableModuleClass.forRoot` |  |
+| <a id="forrootasync"></a> `forRootAsync` | `static` | (`options`) => `DynamicModule` | `ConfigurableModuleClass.forRootAsync` |  |
+
+***
+
+### AmqpWorkerService
+
+Defined in: [packages/worker-nestjs/src/worker.service.ts:74](https://github.com/btravers/amqp-contract/blob/f0945f098387fd3a6a40beac8cbe2ed7a4de210a/packages/worker-nestjs/src/worker.service.ts#L74)
+
+Type-safe AMQP worker service for NestJS applications.
+
+This service wraps TypedAmqpWorker and integrates it with the NestJS
+lifecycle, automatically starting message consumption on module init and
+cleaning up resources on module destroy.
+
+#### Example
+
+```typescript
+// In your module
+import { AmqpWorkerModule } from '@amqp-contract/worker-nestjs';
+
+@Module({
+  imports: [
+    AmqpWorkerModule.forRoot({
+      contract: myContract,
+      handlers: {
+        processOrder: async (message) => {
+          console.log('Received order:', message.orderId);
+          // Process the order...
+        }
+      },
+      urls: ['amqp://localhost']
+    })
+  ]
+})
+export class AppModule {}
+
+// The worker automatically starts consuming messages when the module initializes
+// and stops gracefully when the application shuts down
+```
+
+#### Type Parameters
+
+| Type Parameter | Description |
+| ------ | ------ |
+| `TContract` *extends* `ContractDefinition` | The contract definition type |
+
+#### Implements
+
+- `OnModuleInit`
+- `OnModuleDestroy`
+
+#### Constructors
+
+##### Constructor
+
+```ts
+new AmqpWorkerService<TContract>(options): AmqpWorkerService<TContract>;
+```
+
+Defined in: [packages/worker-nestjs/src/worker.service.ts:79](https://github.com/btravers/amqp-contract/blob/f0945f098387fd3a6a40beac8cbe2ed7a4de210a/packages/worker-nestjs/src/worker.service.ts#L79)
+
+###### Parameters
+
+| Parameter | Type |
+| ------ | ------ |
+| `options` | [`AmqpWorkerModuleOptions`](#amqpworkermoduleoptions)\<`TContract`\> |
+
+###### Returns
+
+[`AmqpWorkerService`](#amqpworkerservice)\<`TContract`\>
+
+#### Methods
+
+##### onModuleDestroy()
+
+```ts
+onModuleDestroy(): Promise<void>;
+```
+
+Defined in: [packages/worker-nestjs/src/worker.service.ts:105](https://github.com/btravers/amqp-contract/blob/f0945f098387fd3a6a40beac8cbe2ed7a4de210a/packages/worker-nestjs/src/worker.service.ts#L105)
+
+Close the AMQP worker when the NestJS module is destroyed.
+
+This lifecycle hook ensures proper cleanup of resources when the
+NestJS application shuts down, gracefully stopping message consumption
+and closing the connection.
+
+###### Returns
+
+`Promise`\<`void`\>
+
+###### Implementation of
+
+```ts
+OnModuleDestroy.onModuleDestroy
+```
+
+##### onModuleInit()
+
+```ts
+onModuleInit(): Promise<void>;
+```
+
+Defined in: [packages/worker-nestjs/src/worker.service.ts:94](https://github.com/btravers/amqp-contract/blob/f0945f098387fd3a6a40beac8cbe2ed7a4de210a/packages/worker-nestjs/src/worker.service.ts#L94)
+
+Initialize the AMQP worker when the NestJS module starts.
+
+This lifecycle hook automatically creates and starts the worker,
+beginning message consumption from all configured consumers.
+The connection will be established in the background with
+automatic reconnection handling.
+
+###### Returns
+
+`Promise`\<`void`\>
+
+###### Throws
+
+Error if the worker fails to start
+
+###### Implementation of
+
+```ts
+OnModuleInit.onModuleInit
+```
+
+## Interfaces
+
+### AmqpWorkerModuleOptions
+
+Defined in: [packages/worker-nestjs/src/worker.service.ts:28](https://github.com/btravers/amqp-contract/blob/f0945f098387fd3a6a40beac8cbe2ed7a4de210a/packages/worker-nestjs/src/worker.service.ts#L28)
+
+Configuration options for the AMQP worker NestJS module.
+
+#### Example
+
+```typescript
+const options: AmqpWorkerModuleOptions<typeof contract> = {
+  contract: myContract,
+  handlers: {
+    processOrder: async (message) => {
+      console.log('Processing order:', message.orderId);
+    }
+  },
+  urls: ['amqp://localhost'],
+  connectionOptions: {
+    heartbeatIntervalInSeconds: 30
+  }
+};
+```
+
+#### Type Parameters
+
+| Type Parameter | Description |
+| ------ | ------ |
+| `TContract` *extends* `ContractDefinition` | The contract definition type |
+
+#### Properties
+
+| Property | Type | Description | Defined in |
+| ------ | ------ | ------ | ------ |
+| <a id="connectionoptions"></a> `connectionOptions?` | `AmqpConnectionManagerOptions` | Optional connection configuration (heartbeat, reconnect settings, etc.) | [packages/worker-nestjs/src/worker.service.ts:36](https://github.com/btravers/amqp-contract/blob/f0945f098387fd3a6a40beac8cbe2ed7a4de210a/packages/worker-nestjs/src/worker.service.ts#L36) |
+| <a id="contract"></a> `contract` | `TContract` | The AMQP contract definition specifying consumers and their message schemas | [packages/worker-nestjs/src/worker.service.ts:30](https://github.com/btravers/amqp-contract/blob/f0945f098387fd3a6a40beac8cbe2ed7a4de210a/packages/worker-nestjs/src/worker.service.ts#L30) |
+| <a id="handlers"></a> `handlers` | `WorkerInferConsumerHandlers`\<`TContract`\> | Message handlers for each consumer defined in the contract | [packages/worker-nestjs/src/worker.service.ts:32](https://github.com/btravers/amqp-contract/blob/f0945f098387fd3a6a40beac8cbe2ed7a4de210a/packages/worker-nestjs/src/worker.service.ts#L32) |
+| <a id="urls"></a> `urls` | `ConnectionUrl`[] | AMQP broker URL(s). Multiple URLs provide failover support | [packages/worker-nestjs/src/worker.service.ts:34](https://github.com/btravers/amqp-contract/blob/f0945f098387fd3a6a40beac8cbe2ed7a4de210a/packages/worker-nestjs/src/worker.service.ts#L34) |
+
+## Variables
+
+### MODULE\_OPTIONS\_TOKEN
+
+```ts
+MODULE_OPTIONS_TOKEN: string | symbol;
+```
+
+Defined in: [packages/worker-nestjs/src/worker.module-definition.ts:9](https://github.com/btravers/amqp-contract/blob/f0945f098387fd3a6a40beac8cbe2ed7a4de210a/packages/worker-nestjs/src/worker.module-definition.ts#L9)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amqp-contract/worker-nestjs",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "NestJS integration for @amqp-contract/worker",
   "keywords": [
     "amqp",
@@ -39,35 +39,40 @@
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.mts",
   "files": [
-    "dist"
+    "dist",
+    "docs"
   ],
   "dependencies": {
-    "@amqp-contract/contract": "0.2.0",
-    "@amqp-contract/worker": "0.2.0"
+    "@amqp-contract/contract": "0.2.1",
+    "@amqp-contract/worker": "0.2.1"
   },
   "devDependencies": {
     "@nestjs/common": "11.1.10",
-    "@types/amqplib": "0.10.8",
+    "@swan-io/boxed": "3.2.1",
     "@types/node": "25.0.3",
     "@vitest/coverage-v8": "4.0.16",
+    "amqp-connection-manager": "5.0.0",
     "amqplib": "0.10.9",
     "reflect-metadata": "0.2.2",
     "rxjs": "7.8.2",
     "tsdown": "0.18.2",
+    "typedoc": "0.28.3",
+    "typedoc-plugin-markdown": "4.9.0",
     "typescript": "5.9.3",
     "vitest": "4.0.16",
     "zod": "4.2.1",
-    "@amqp-contract/tsconfig": "0.0.0"
+    "@amqp-contract/tsconfig": "0.0.0",
+    "@amqp-contract/typedoc": "0.0.1"
   },
   "peerDependencies": {
     "@nestjs/common": "^11.0.0",
     "@nestjs/core": "^11.0.0",
-    "amqplib": ">=0.10.0",
     "reflect-metadata": ">=0.1.13",
     "rxjs": ">=7.0.0"
   },
   "scripts": {
     "build": "tsdown src/index.ts --format cjs,esm --dts --clean",
+    "build:docs": "typedoc",
     "dev": "tsdown src/index.ts --format cjs,esm --dts --watch",
     "test": "vitest run --project unit",
     "test:watch": "vitest --project unit",