@amqp-contract/worker-nestjs 0.9.0 → 0.11.0

package/README.md

@@ -21,6 +21,7 @@ pnpm add @amqp-contract/worker-nestjs @amqp-contract/worker @amqp-contract/contr
 ```typescript
 import { Module } from "@nestjs/common";
 import { AmqpWorkerModule } from "@amqp-contract/worker-nestjs";
+import { Future, Result } from "@swan-io/boxed";
 import { contract } from "./contract";
 
 @Module({
@@ -28,8 +29,9 @@ import { contract } from "./contract";
     AmqpWorkerModule.forRoot({
       contract,
       handlers: {
-        processOrder: async (message) => {
-          console.log("Processing order:", message.orderId);
+        processOrder: ({ payload }) => {
+          console.log("Processing order:", payload.orderId);
+          return Future.value(Result.Ok(undefined));
         },
       },
       urls: ["amqp://localhost"],

package/dist/index.d.cts

@@ -1,6 +1,6 @@
 import { AmqpConnectionManagerOptions, ConnectionUrl } from "amqp-connection-manager";
 import { DynamicModule, ModuleMetadata, OnModuleDestroy, OnModuleInit, Type } from "@nestjs/common";
-import { WorkerInferConsumerHandlers, WorkerInferSafeConsumerHandlers, defineHandler, defineHandlers } from "@amqp-contract/worker";
+import { WorkerInferSafeConsumerHandlers, WorkerInferSafeConsumerHandlers as WorkerInferSafeConsumerHandlers$1, defineHandler, defineHandlers } from "@amqp-contract/worker";
 import { ContractDefinition } from "@amqp-contract/contract";
 
 //#region src/worker.service.d.ts
@@ -12,39 +12,26 @@ import { ContractDefinition } from "@amqp-contract/contract";
  *
  * @example
  * ```typescript
- * import { defineHandlers, defineUnsafeHandlers } from '@amqp-contract/worker';
- * import { Future, Result } from '@swan-io/boxed';
- * import { RetryableError } from '@amqp-contract/worker';
+ * import { defineHandlers, RetryableError } from '@amqp-contract/worker';
+ * import { Future } from '@swan-io/boxed';
  *
- * // Using safe handlers (recommended)
  * const options: AmqpWorkerModuleOptions<typeof contract> = {
  *   contract: myContract,
  *   handlers: defineHandlers(myContract, {
- *     processOrder: (message) =>
- *       Future.fromPromise(processPayment(message))
+ *     processOrder: ({ payload }) =>
+ *       Future.fromPromise(processPayment(payload))
  *         .mapOk(() => undefined)
  *         .mapError((error) => new RetryableError('Payment failed', error))
  *   }),
  *   urls: ['amqp://localhost'],
  * };
- *
- * // Using unsafe handlers (legacy)
- * const options: AmqpWorkerModuleOptions<typeof contract> = {
- *   contract: myContract,
- *   handlers: defineUnsafeHandlers(myContract, {
- *     processOrder: async (message) => {
- *       console.log('Processing order:', message.orderId);
- *     }
- *   }),
- *   urls: ['amqp://localhost'],
- * };
  * ```
  */
 type 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. Use defineHandlers or defineUnsafeHandlers to create type-safe handlers. */
-  handlers: WorkerInferSafeConsumerHandlers<TContract>;
+  /** Message handlers for each consumer defined in the contract. Use defineHandlers to create type-safe handlers. */
+  handlers: WorkerInferSafeConsumerHandlers$1<TContract>;
   /** AMQP broker URL(s). Multiple URLs provide failover support */
   urls: ConnectionUrl[];
   /** Optional connection configuration (heartbeat, reconnect settings, etc.) */
@@ -204,5 +191,5 @@ declare class AmqpWorkerModule {
  */
 declare const MODULE_OPTIONS_TOKEN: unique symbol;
 //#endregion
-export { AmqpWorkerModule, type AmqpWorkerModuleAsyncOptions, type AmqpWorkerModuleOptions, AmqpWorkerService, MODULE_OPTIONS_TOKEN, type WorkerInferConsumerHandlers, defineHandler, defineHandlers };
+export { AmqpWorkerModule, type AmqpWorkerModuleAsyncOptions, type AmqpWorkerModuleOptions, AmqpWorkerService, MODULE_OPTIONS_TOKEN, type WorkerInferSafeConsumerHandlers, defineHandler, defineHandlers };
 //# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../src/worker.service.ts","../src/worker.module.ts","../src/worker.module-definition.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AAyCA;;;;;;;;AA6CA;;;;;;;;;;;;AC9EkE;;;;;;;;AAalE;;;;;AAeY,KDKA,uBCLA,CAAA,kBDK0C,kBCL1C,CAAA,GAAA;EAAc;EAmDb,QAAA,ED5CD,SC4CiB;EAOM;EACE,QAAA,EDlDzB,+BCkDyB,CDlDO,SCkDP,CAAA;EAAxB;EACR,IAAA,EDjDG,aCiDH,EAAA;EAoBmC;EACE,iBAAA,CAAA,EDpEpB,4BCoEoB,GAAA,SAAA;CAA7B;;;;;;ACjHb;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cFmFa,oCAAoC,+BACpC,cAAc;;;uBAMG,wBAAwB;;;;;;;;;;;kBAa9B;;;;;;;;qBAWG;;;;;;;AA7E3B,KC3BK,8BD2B8B,CAAA,kBC3BmB,kBD2BnB,CAAA,GC1B/B,uBD0B+B,CC1BP,SD0BO,CAAA,GCzB/B,ODyB+B,CCzBvB,uBDyBuB,CCzBC,SDyBD,CAAA,CAAA;;;;AAIvB,KCxBA,4BDwBA,CAAA,kBCxB+C,kBDwB/C,CAAA,GAAA;EAEJ;;;AAuCR;EACiD,UAAA,EAAA,CAAA,GAAA,IAAA,EAAA,GAAA,EAAA,EAAA,GC5Df,8BD4De,CC5DgB,SD4DhB,CAAA;EAOK;;;;EANzC,MAAA,CAAA,EAAA,CAAA,MAAA,GAAA,MAAA,GCxDiB,IDwDjB,CAAA,OAAA,CAAA,CAAA,EAAA;EAAc;;;YCpDf;;AA5BsD;;;;;;;;AAalE;;;;;;;AAiEA;;;;;;;;;;;;;AClFA;;;;;;;;;;;;;;;;;;;cDmFa,gBAAA;;;;;;;mCAOsB,6BACtB,wBAAwB,aAChC;;;;;;;wCAoBmC,6BAC3B,6BAA6B,aACrC;;;;;;;;cClHQ"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/worker.service.ts","../src/worker.module.ts","../src/worker.module-definition.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AA4BA;;;;;;;;AA6CA;;;;;;;;;;;;AC3DK,KDcO,uBCdP,CAAA,kBDciD,kBCdnB,CAAA,GAAA;EAAmB;EAC1B,QAAA,EDehB,SCfgB;EAAxB;EACgC,QAAA,EDgBxB,iCChBwB,CDgBQ,SChBR,CAAA;EAAxB;EAAR,IAAA,EDkBI,aClBJ,EAAA;EAAO;EAKC,iBAAA,CAAA,EDeU,4BCfkB,GAAA,SAAA;CAAmB;;;;;;AAiE3D;;;;;;;;;;;;;AClFA;;;;;;;;;;;;;;;;cFsEa,oCAAoC,+BACpC,cAAc;;;uBAMG,wBAAwB;;;;;;;;;;;kBAa9B;;;;;;;;qBAWG;;;;;;;AA7E3B,KCdK,8BDc8B,CAAA,kBCdmB,kBDcnB,CAAA,GCb/B,uBDa+B,CCbP,SDaO,CAAA,GCZ/B,ODY+B,CCZvB,uBDYuB,CCZC,SDYD,CAAA,CAAA;;;;AAIvB,KCXA,4BDWA,CAAA,kBCX+C,kBDW/C,CAAA,GAAA;EAEJ;;;AAuCR;EACiD,UAAA,EAAA,CAAA,GAAA,IAAA,EAAA,GAAA,EAAA,EAAA,GC/Cf,8BD+Ce,CC/CgB,SD+ChB,CAAA;EAOK;;;;EANzC,MAAA,CAAA,EAAA,CAAA,MAAA,GAAA,MAAA,GC3CiB,ID2CjB,CAAA,OAAA,CAAA,CAAA,EAAA;EAAc;;;YCvCf;;AA5BsD;;;;;;;;AAalE;;;;;;;AAiEA;;;;;;;;;;;;;AClFA;;;;;;;;;;;;;;;;;;;cDmFa,gBAAA;;;;;;;mCAOsB,6BACtB,wBAAwB,aAChC;;;;;;;wCAoBmC,6BAC3B,6BAA6B,aACrC;;;;;;;;cClHQ"}

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 import { DynamicModule, ModuleMetadata, OnModuleDestroy, OnModuleInit, Type } from "@nestjs/common";
-import { WorkerInferConsumerHandlers, WorkerInferSafeConsumerHandlers, defineHandler, defineHandlers } from "@amqp-contract/worker";
+import { WorkerInferSafeConsumerHandlers, WorkerInferSafeConsumerHandlers as WorkerInferSafeConsumerHandlers$1, defineHandler, defineHandlers } from "@amqp-contract/worker";
 import { AmqpConnectionManagerOptions, ConnectionUrl } from "amqp-connection-manager";
 import { ContractDefinition } from "@amqp-contract/contract";
 
@@ -12,39 +12,26 @@ import { ContractDefinition } from "@amqp-contract/contract";
  *
  * @example
  * ```typescript
- * import { defineHandlers, defineUnsafeHandlers } from '@amqp-contract/worker';
- * import { Future, Result } from '@swan-io/boxed';
- * import { RetryableError } from '@amqp-contract/worker';
+ * import { defineHandlers, RetryableError } from '@amqp-contract/worker';
+ * import { Future } from '@swan-io/boxed';
  *
- * // Using safe handlers (recommended)
  * const options: AmqpWorkerModuleOptions<typeof contract> = {
  *   contract: myContract,
  *   handlers: defineHandlers(myContract, {
- *     processOrder: (message) =>
- *       Future.fromPromise(processPayment(message))
+ *     processOrder: ({ payload }) =>
+ *       Future.fromPromise(processPayment(payload))
  *         .mapOk(() => undefined)
  *         .mapError((error) => new RetryableError('Payment failed', error))
  *   }),
  *   urls: ['amqp://localhost'],
  * };
- *
- * // Using unsafe handlers (legacy)
- * const options: AmqpWorkerModuleOptions<typeof contract> = {
- *   contract: myContract,
- *   handlers: defineUnsafeHandlers(myContract, {
- *     processOrder: async (message) => {
- *       console.log('Processing order:', message.orderId);
- *     }
- *   }),
- *   urls: ['amqp://localhost'],
- * };
  * ```
  */
 type 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. Use defineHandlers or defineUnsafeHandlers to create type-safe handlers. */
-  handlers: WorkerInferSafeConsumerHandlers<TContract>;
+  /** Message handlers for each consumer defined in the contract. Use defineHandlers to create type-safe handlers. */
+  handlers: WorkerInferSafeConsumerHandlers$1<TContract>;
   /** AMQP broker URL(s). Multiple URLs provide failover support */
   urls: ConnectionUrl[];
   /** Optional connection configuration (heartbeat, reconnect settings, etc.) */
@@ -204,5 +191,5 @@ declare class AmqpWorkerModule {
  */
 declare const MODULE_OPTIONS_TOKEN: unique symbol;
 //#endregion
-export { AmqpWorkerModule, type AmqpWorkerModuleAsyncOptions, type AmqpWorkerModuleOptions, AmqpWorkerService, MODULE_OPTIONS_TOKEN, type WorkerInferConsumerHandlers, defineHandler, defineHandlers };
+export { AmqpWorkerModule, type AmqpWorkerModuleAsyncOptions, type AmqpWorkerModuleOptions, AmqpWorkerService, MODULE_OPTIONS_TOKEN, type WorkerInferSafeConsumerHandlers, defineHandler, defineHandlers };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/worker.service.ts","../src/worker.module.ts","../src/worker.module-definition.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AAyCA;;;;;;;;AA6CA;;;;;;;;;;;;AC9EkE;;;;;;;;AAalE;;;;;AAeY,KDKA,uBCLA,CAAA,kBDK0C,kBCL1C,CAAA,GAAA;EAAc;EAmDb,QAAA,ED5CD,SC4CiB;EAOM;EACE,QAAA,EDlDzB,+BCkDyB,CDlDO,SCkDP,CAAA;EAAxB;EACR,IAAA,EDjDG,aCiDH,EAAA;EAoBmC;EACE,iBAAA,CAAA,EDpEpB,4BCoEoB,GAAA,SAAA;CAA7B;;;;;;ACjHb;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cFmFa,oCAAoC,+BACpC,cAAc;;;uBAMG,wBAAwB;;;;;;;;;;;kBAa9B;;;;;;;;qBAWG;;;;;;;AA7E3B,KC3BK,8BD2B8B,CAAA,kBC3BmB,kBD2BnB,CAAA,GC1B/B,uBD0B+B,CC1BP,SD0BO,CAAA,GCzB/B,ODyB+B,CCzBvB,uBDyBuB,CCzBC,SDyBD,CAAA,CAAA;;;;AAIvB,KCxBA,4BDwBA,CAAA,kBCxB+C,kBDwB/C,CAAA,GAAA;EAEJ;;;AAuCR;EACiD,UAAA,EAAA,CAAA,GAAA,IAAA,EAAA,GAAA,EAAA,EAAA,GC5Df,8BD4De,CC5DgB,SD4DhB,CAAA;EAOK;;;;EANzC,MAAA,CAAA,EAAA,CAAA,MAAA,GAAA,MAAA,GCxDiB,IDwDjB,CAAA,OAAA,CAAA,CAAA,EAAA;EAAc;;;YCpDf;;AA5BsD;;;;;;;;AAalE;;;;;;;AAiEA;;;;;;;;;;;;;AClFA;;;;;;;;;;;;;;;;;;;cDmFa,gBAAA;;;;;;;mCAOsB,6BACtB,wBAAwB,aAChC;;;;;;;wCAoBmC,6BAC3B,6BAA6B,aACrC;;;;;;;;cClHQ"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/worker.service.ts","../src/worker.module.ts","../src/worker.module-definition.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AA4BA;;;;;;;;AA6CA;;;;;;;;;;;;AC3DK,KDcO,uBCdP,CAAA,kBDciD,kBCdnB,CAAA,GAAA;EAAmB;EAC1B,QAAA,EDehB,SCfgB;EAAxB;EACgC,QAAA,EDgBxB,iCChBwB,CDgBQ,SChBR,CAAA;EAAxB;EAAR,IAAA,EDkBI,aClBJ,EAAA;EAAO;EAKC,iBAAA,CAAA,EDeU,4BCfkB,GAAA,SAAA;CAAmB;;;;;;AAiE3D;;;;;;;;;;;;;AClFA;;;;;;;;;;;;;;;;cFsEa,oCAAoC,+BACpC,cAAc;;;uBAMG,wBAAwB;;;;;;;;;;;kBAa9B;;;;;;;;qBAWG;;;;;;;AA7E3B,KCdK,8BDc8B,CAAA,kBCdmB,kBDcnB,CAAA,GCb/B,uBDa+B,CCbP,SDaO,CAAA,GCZ/B,ODY+B,CCZvB,uBDYuB,CCZC,SDYD,CAAA,CAAA;;;;AAIvB,KCXA,4BDWA,CAAA,kBCX+C,kBDW/C,CAAA,GAAA;EAEJ;;;AAuCR;EACiD,UAAA,EAAA,CAAA,GAAA,IAAA,EAAA,GAAA,EAAA,EAAA,GC/Cf,8BD+Ce,CC/CgB,SD+ChB,CAAA;EAOK;;;;EANzC,MAAA,CAAA,EAAA,CAAA,MAAA,GAAA,MAAA,GC3CiB,ID2CjB,CAAA,OAAA,CAAA,CAAA,EAAA;EAAc;;;YCvCf;;AA5BsD;;;;;;;;AAalE;;;;;;;AAiEA;;;;;;;;;;;;;AClFA;;;;;;;;;;;;;;;;;;;cDmFa,gBAAA;;;;;;;mCAOsB,6BACtB,wBAAwB,aAChC;;;;;;;wCAoBmC,6BAC3B,6BAA6B,aACrC;;;;;;;;cClHQ"}

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":["AmqpWorkerService","AmqpWorkerModule"],"sources":["../src/worker.module-definition.ts","../src/worker.service.ts","../src/worker.module.ts"],"sourcesContent":["/**\n * Injection token for AMQP worker module options\n * Used by NestJS DI system to inject configuration into AmqpWorkerService\n */\nexport const MODULE_OPTIONS_TOKEN = Symbol(\"AMQP_WORKER_MODULE_OPTIONS\");\n","import type { AmqpConnectionManagerOptions, ConnectionUrl } from \"amqp-connection-manager\";\nimport { Inject, Injectable, type OnModuleDestroy, type OnModuleInit } from \"@nestjs/common\";\nimport { TypedAmqpWorker, type WorkerInferSafeConsumerHandlers } from \"@amqp-contract/worker\";\nimport type { ContractDefinition } from \"@amqp-contract/contract\";\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 * import { defineHandlers, defineUnsafeHandlers } from '@amqp-contract/worker';\n * import { Future, Result } from '@swan-io/boxed';\n * import { RetryableError } from '@amqp-contract/worker';\n *\n * // Using safe handlers (recommended)\n * const options: AmqpWorkerModuleOptions<typeof contract> = {\n *   contract: myContract,\n *   handlers: defineHandlers(myContract, {\n *     processOrder: (message) =>\n *       Future.fromPromise(processPayment(message))\n *         .mapOk(() => undefined)\n *         .mapError((error) => new RetryableError('Payment failed', error))\n *   }),\n *   urls: ['amqp://localhost'],\n * };\n *\n * // Using unsafe handlers (legacy)\n * const options: AmqpWorkerModuleOptions<typeof contract> = {\n *   contract: myContract,\n *   handlers: defineUnsafeHandlers(myContract, {\n *     processOrder: async (message) => {\n *       console.log('Processing order:', message.orderId);\n *     }\n *   }),\n *   urls: ['amqp://localhost'],\n * };\n * ```\n */\nexport type 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. Use defineHandlers or defineUnsafeHandlers to create type-safe handlers. */\n  handlers: WorkerInferSafeConsumerHandlers<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 { type AmqpWorkerModuleOptions, AmqpWorkerService } from \"./worker.service.js\";\nimport {\n  type DynamicModule,\n  Module,\n  type ModuleMetadata,\n  type Provider,\n  type Type,\n} from \"@nestjs/common\";\nimport type { ContractDefinition } from \"@amqp-contract/contract\";\nimport { MODULE_OPTIONS_TOKEN } from \"./worker.module-definition.js\";\n\n/**\n * Factory function return type for async module configuration\n */\ntype AmqpWorkerModuleOptionsFactory<TContract extends ContractDefinition> =\n  | AmqpWorkerModuleOptions<TContract>\n  | Promise<AmqpWorkerModuleOptions<TContract>>;\n\n/**\n * Options for async module configuration using factory pattern\n */\nexport type AmqpWorkerModuleAsyncOptions<TContract extends ContractDefinition> = {\n  /**\n   * Factory function that returns the module options.\n   * Can use injected dependencies to create configuration.\n   */\n  // oxlint-disable-next-line no-explicit-any\n  useFactory: (...args: any[]) => AmqpWorkerModuleOptionsFactory<TContract>;\n  /**\n   * Optional dependencies to inject into the factory function.\n   * Can be a token (string/symbol) a class or a reference to a provider.\n   */\n  inject?: (string | symbol | Type<unknown>)[];\n  /**\n   * Optional list of imported modules that export providers needed by the factory\n   */\n  imports?: ModuleMetadata[\"imports\"];\n};\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 * @typeParam TContract - The contract definition type for type-safe handlers\n *\n * @example\n * ```typescript\n * // Synchronous configuration\n * @Module({\n *   imports: [\n *     AmqpWorkerModule.forRoot({\n *       contract: myContract,\n *       handlers: {\n *         processOrder: async (message) => {\n *           // message is fully typed based on the contract\n *           console.log('Order:', message.orderId);\n *         }\n *       },\n *       urls: ['amqp://localhost']\n *     })\n *   ]\n * })\n * export class AppModule {}\n *\n * // Asynchronous configuration\n * @Module({\n *   imports: [\n *     AmqpWorkerModule.forRootAsync({\n *       imports: [ConfigModule],\n *       useFactory: (configService: ConfigService) => ({\n *         contract: myContract,\n *         handlers: {\n *           processOrder: async (message) => {\n *             console.log('Order:', message.orderId);\n *           }\n *         },\n *         urls: configService.get('AMQP_URLS')\n *       }),\n *       inject: [ConfigService]\n *     })\n *   ]\n * })\n * export class AppModule {}\n * ```\n */\n@Module({})\nexport class AmqpWorkerModule {\n  /**\n   * Register the AMQP worker module with synchronous configuration\n   *\n   * @param options - The worker configuration options with contract and handlers\n   * @returns A dynamic module for NestJS\n   */\n  static forRoot<TContract extends ContractDefinition>(\n    options: AmqpWorkerModuleOptions<TContract>,\n  ): DynamicModule {\n    return {\n      module: AmqpWorkerModule,\n      providers: [\n        {\n          provide: MODULE_OPTIONS_TOKEN,\n          useValue: options,\n        },\n        AmqpWorkerService,\n      ],\n      exports: [AmqpWorkerService],\n    };\n  }\n\n  /**\n   * Register the AMQP worker module with asynchronous configuration\n   *\n   * @param options - Async configuration options with factory function\n   * @returns A dynamic module for NestJS\n   */\n  static forRootAsync<TContract extends ContractDefinition>(\n    options: AmqpWorkerModuleAsyncOptions<TContract>,\n  ): DynamicModule {\n    const providers: Provider[] = [\n      {\n        provide: MODULE_OPTIONS_TOKEN,\n        useFactory: options.useFactory,\n        inject: options.inject ?? [],\n      },\n      AmqpWorkerService,\n    ];\n\n    return {\n      module: AmqpWorkerModule,\n      imports: options.imports ?? [],\n      providers,\n      exports: [AmqpWorkerService],\n    };\n  }\n}\n"],"mappings":";;;;;;;;AAIA,MAAa,uBAAuB,OAAO,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;ACmFjE,8BAAMA,oBAEb;CACE,AAAQ,SAA4C;CAEpD,YACE,AACiB,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;;;;;;;ACN1B,iDAAMC,mBAAiB;;;;;;;CAO5B,OAAO,QACL,SACe;AACf,SAAO;GACL;GACA,WAAW,CACT;IACE,SAAS;IACT,UAAU;IACX,EACD,kBACD;GACD,SAAS,CAAC,kBAAkB;GAC7B;;;;;;;;CASH,OAAO,aACL,SACe;EACf,MAAM,YAAwB,CAC5B;GACE,SAAS;GACT,YAAY,QAAQ;GACpB,QAAQ,QAAQ,UAAU,EAAE;GAC7B,EACD,kBACD;AAED,SAAO;GACL;GACA,SAAS,QAAQ,WAAW,EAAE;GAC9B;GACA,SAAS,CAAC,kBAAkB;GAC7B;;;mDA/CJ,OAAO,EAAE,CAAC"}
+{"version":3,"file":"index.mjs","names":["AmqpWorkerService","AmqpWorkerModule"],"sources":["../src/worker.module-definition.ts","../src/worker.service.ts","../src/worker.module.ts"],"sourcesContent":["/**\n * Injection token for AMQP worker module options\n * Used by NestJS DI system to inject configuration into AmqpWorkerService\n */\nexport const MODULE_OPTIONS_TOKEN = Symbol(\"AMQP_WORKER_MODULE_OPTIONS\");\n","import type { AmqpConnectionManagerOptions, ConnectionUrl } from \"amqp-connection-manager\";\nimport { Inject, Injectable, type OnModuleDestroy, type OnModuleInit } from \"@nestjs/common\";\nimport { TypedAmqpWorker, type WorkerInferSafeConsumerHandlers } from \"@amqp-contract/worker\";\nimport type { ContractDefinition } from \"@amqp-contract/contract\";\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 * import { defineHandlers, RetryableError } from '@amqp-contract/worker';\n * import { Future } from '@swan-io/boxed';\n *\n * const options: AmqpWorkerModuleOptions<typeof contract> = {\n *   contract: myContract,\n *   handlers: defineHandlers(myContract, {\n *     processOrder: ({ payload }) =>\n *       Future.fromPromise(processPayment(payload))\n *         .mapOk(() => undefined)\n *         .mapError((error) => new RetryableError('Payment failed', error))\n *   }),\n *   urls: ['amqp://localhost'],\n * };\n * ```\n */\nexport type 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. Use defineHandlers to create type-safe handlers. */\n  handlers: WorkerInferSafeConsumerHandlers<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 { type AmqpWorkerModuleOptions, AmqpWorkerService } from \"./worker.service.js\";\nimport {\n  type DynamicModule,\n  Module,\n  type ModuleMetadata,\n  type Provider,\n  type Type,\n} from \"@nestjs/common\";\nimport type { ContractDefinition } from \"@amqp-contract/contract\";\nimport { MODULE_OPTIONS_TOKEN } from \"./worker.module-definition.js\";\n\n/**\n * Factory function return type for async module configuration\n */\ntype AmqpWorkerModuleOptionsFactory<TContract extends ContractDefinition> =\n  | AmqpWorkerModuleOptions<TContract>\n  | Promise<AmqpWorkerModuleOptions<TContract>>;\n\n/**\n * Options for async module configuration using factory pattern\n */\nexport type AmqpWorkerModuleAsyncOptions<TContract extends ContractDefinition> = {\n  /**\n   * Factory function that returns the module options.\n   * Can use injected dependencies to create configuration.\n   */\n  // oxlint-disable-next-line no-explicit-any\n  useFactory: (...args: any[]) => AmqpWorkerModuleOptionsFactory<TContract>;\n  /**\n   * Optional dependencies to inject into the factory function.\n   * Can be a token (string/symbol) a class or a reference to a provider.\n   */\n  inject?: (string | symbol | Type<unknown>)[];\n  /**\n   * Optional list of imported modules that export providers needed by the factory\n   */\n  imports?: ModuleMetadata[\"imports\"];\n};\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 * @typeParam TContract - The contract definition type for type-safe handlers\n *\n * @example\n * ```typescript\n * // Synchronous configuration\n * @Module({\n *   imports: [\n *     AmqpWorkerModule.forRoot({\n *       contract: myContract,\n *       handlers: {\n *         processOrder: async (message) => {\n *           // message is fully typed based on the contract\n *           console.log('Order:', message.orderId);\n *         }\n *       },\n *       urls: ['amqp://localhost']\n *     })\n *   ]\n * })\n * export class AppModule {}\n *\n * // Asynchronous configuration\n * @Module({\n *   imports: [\n *     AmqpWorkerModule.forRootAsync({\n *       imports: [ConfigModule],\n *       useFactory: (configService: ConfigService) => ({\n *         contract: myContract,\n *         handlers: {\n *           processOrder: async (message) => {\n *             console.log('Order:', message.orderId);\n *           }\n *         },\n *         urls: configService.get('AMQP_URLS')\n *       }),\n *       inject: [ConfigService]\n *     })\n *   ]\n * })\n * export class AppModule {}\n * ```\n */\n@Module({})\nexport class AmqpWorkerModule {\n  /**\n   * Register the AMQP worker module with synchronous configuration\n   *\n   * @param options - The worker configuration options with contract and handlers\n   * @returns A dynamic module for NestJS\n   */\n  static forRoot<TContract extends ContractDefinition>(\n    options: AmqpWorkerModuleOptions<TContract>,\n  ): DynamicModule {\n    return {\n      module: AmqpWorkerModule,\n      providers: [\n        {\n          provide: MODULE_OPTIONS_TOKEN,\n          useValue: options,\n        },\n        AmqpWorkerService,\n      ],\n      exports: [AmqpWorkerService],\n    };\n  }\n\n  /**\n   * Register the AMQP worker module with asynchronous configuration\n   *\n   * @param options - Async configuration options with factory function\n   * @returns A dynamic module for NestJS\n   */\n  static forRootAsync<TContract extends ContractDefinition>(\n    options: AmqpWorkerModuleAsyncOptions<TContract>,\n  ): DynamicModule {\n    const providers: Provider[] = [\n      {\n        provide: MODULE_OPTIONS_TOKEN,\n        useFactory: options.useFactory,\n        inject: options.inject ?? [],\n      },\n      AmqpWorkerService,\n    ];\n\n    return {\n      module: AmqpWorkerModule,\n      imports: options.imports ?? [],\n      providers,\n      exports: [AmqpWorkerService],\n    };\n  }\n}\n"],"mappings":";;;;;;;;AAIA,MAAa,uBAAuB,OAAO,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;ACsEjE,8BAAMA,oBAEb;CACE,AAAQ,SAA4C;CAEpD,YACE,AACiB,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;;;;;;;ACO1B,iDAAMC,mBAAiB;;;;;;;CAO5B,OAAO,QACL,SACe;AACf,SAAO;GACL;GACA,WAAW,CACT;IACE,SAAS;IACT,UAAU;IACX,EACD,kBACD;GACD,SAAS,CAAC,kBAAkB;GAC7B;;;;;;;;CASH,OAAO,aACL,SACe;EACf,MAAM,YAAwB,CAC5B;GACE,SAAS;GACT,YAAY,QAAQ;GACpB,QAAQ,QAAQ,UAAU,EAAE;GAC7B,EACD,kBACD;AAED,SAAO;GACL;GACA,SAAS,QAAQ,WAAW,EAAE;GAC9B;GACA,SAAS,CAAC,kBAAkB;GAC7B;;;mDA/CJ,OAAO,EAAE,CAAC"}

package/docs/index.md

@@ -8,7 +8,7 @@
 
 ### AmqpWorkerModule
 
-Defined in: [worker-nestjs/src/worker.module.ts:88](https://github.com/btravers/amqp-contract/blob/f058a24938d9644a82812e57d7995cb683cfd6b5/packages/worker-nestjs/src/worker.module.ts#L88)
+Defined in: [worker-nestjs/src/worker.module.ts:88](https://github.com/btravers/amqp-contract/blob/ed05e43c04fa526b751d45622ccc1ac53b2e96f9/packages/worker-nestjs/src/worker.module.ts#L88)
 
 NestJS module for AMQP worker integration
 This module provides type-safe AMQP worker functionality using @amqp-contract/worker
@@ -79,7 +79,7 @@ new AmqpWorkerModule(): AmqpWorkerModule;
 static forRoot<TContract>(options): DynamicModule;
 ```
 
-Defined in: [worker-nestjs/src/worker.module.ts:95](https://github.com/btravers/amqp-contract/blob/f058a24938d9644a82812e57d7995cb683cfd6b5/packages/worker-nestjs/src/worker.module.ts#L95)
+Defined in: [worker-nestjs/src/worker.module.ts:95](https://github.com/btravers/amqp-contract/blob/ed05e43c04fa526b751d45622ccc1ac53b2e96f9/packages/worker-nestjs/src/worker.module.ts#L95)
 
 Register the AMQP worker module with synchronous configuration
 
@@ -107,7 +107,7 @@ A dynamic module for NestJS
 static forRootAsync<TContract>(options): DynamicModule;
 ```
 
-Defined in: [worker-nestjs/src/worker.module.ts:117](https://github.com/btravers/amqp-contract/blob/f058a24938d9644a82812e57d7995cb683cfd6b5/packages/worker-nestjs/src/worker.module.ts#L117)
+Defined in: [worker-nestjs/src/worker.module.ts:117](https://github.com/btravers/amqp-contract/blob/ed05e43c04fa526b751d45622ccc1ac53b2e96f9/packages/worker-nestjs/src/worker.module.ts#L117)
 
 Register the AMQP worker module with asynchronous configuration
 
@@ -133,7 +133,7 @@ A dynamic module for NestJS
 
 ### AmqpWorkerService
 
-Defined in: [worker-nestjs/src/worker.service.ts:88](https://github.com/btravers/amqp-contract/blob/f058a24938d9644a82812e57d7995cb683cfd6b5/packages/worker-nestjs/src/worker.service.ts#L88)
+Defined in: [worker-nestjs/src/worker.service.ts:75](https://github.com/btravers/amqp-contract/blob/ed05e43c04fa526b751d45622ccc1ac53b2e96f9/packages/worker-nestjs/src/worker.service.ts#L75)
 
 Type-safe AMQP worker service for NestJS applications.
 
@@ -186,7 +186,7 @@ export class AppModule {}
 new AmqpWorkerService<TContract>(options): AmqpWorkerService<TContract>;
 ```
 
-Defined in: [worker-nestjs/src/worker.service.ts:93](https://github.com/btravers/amqp-contract/blob/f058a24938d9644a82812e57d7995cb683cfd6b5/packages/worker-nestjs/src/worker.service.ts#L93)
+Defined in: [worker-nestjs/src/worker.service.ts:80](https://github.com/btravers/amqp-contract/blob/ed05e43c04fa526b751d45622ccc1ac53b2e96f9/packages/worker-nestjs/src/worker.service.ts#L80)
 
 ###### Parameters
 
@@ -206,7 +206,7 @@ Defined in: [worker-nestjs/src/worker.service.ts:93](https://github.com/btravers
 onModuleDestroy(): Promise<void>;
 ```
 
-Defined in: [worker-nestjs/src/worker.service.ts:119](https://github.com/btravers/amqp-contract/blob/f058a24938d9644a82812e57d7995cb683cfd6b5/packages/worker-nestjs/src/worker.service.ts#L119)
+Defined in: [worker-nestjs/src/worker.service.ts:106](https://github.com/btravers/amqp-contract/blob/ed05e43c04fa526b751d45622ccc1ac53b2e96f9/packages/worker-nestjs/src/worker.service.ts#L106)
 
 Close the AMQP worker when the NestJS module is destroyed.
 
@@ -230,7 +230,7 @@ OnModuleDestroy.onModuleDestroy
 onModuleInit(): Promise<void>;
 ```
 
-Defined in: [worker-nestjs/src/worker.service.ts:108](https://github.com/btravers/amqp-contract/blob/f058a24938d9644a82812e57d7995cb683cfd6b5/packages/worker-nestjs/src/worker.service.ts#L108)
+Defined in: [worker-nestjs/src/worker.service.ts:95](https://github.com/btravers/amqp-contract/blob/ed05e43c04fa526b751d45622ccc1ac53b2e96f9/packages/worker-nestjs/src/worker.service.ts#L95)
 
 Initialize the AMQP worker when the NestJS module starts.
 
@@ -261,7 +261,7 @@ OnModuleInit.onModuleInit
 type AmqpWorkerModuleAsyncOptions<TContract> = object;
 ```
 
-Defined in: [worker-nestjs/src/worker.module.ts:22](https://github.com/btravers/amqp-contract/blob/f058a24938d9644a82812e57d7995cb683cfd6b5/packages/worker-nestjs/src/worker.module.ts#L22)
+Defined in: [worker-nestjs/src/worker.module.ts:22](https://github.com/btravers/amqp-contract/blob/ed05e43c04fa526b751d45622ccc1ac53b2e96f9/packages/worker-nestjs/src/worker.module.ts#L22)
 
 Options for async module configuration using factory pattern
 
@@ -275,9 +275,9 @@ Options for async module configuration using factory pattern
 
 | Property | Type | Description | Defined in |
 | ------ | ------ | ------ | ------ |
-| <a id="imports"></a> `imports?` | `ModuleMetadata`\[`"imports"`\] | Optional list of imported modules that export providers needed by the factory | [worker-nestjs/src/worker.module.ts:37](https://github.com/btravers/amqp-contract/blob/f058a24938d9644a82812e57d7995cb683cfd6b5/packages/worker-nestjs/src/worker.module.ts#L37) |
-| <a id="inject"></a> `inject?` | (`string` \| `symbol` \| `Type`\<`unknown`\>)[] | Optional dependencies to inject into the factory function. Can be a token (string/symbol) a class or a reference to a provider. | [worker-nestjs/src/worker.module.ts:33](https://github.com/btravers/amqp-contract/blob/f058a24938d9644a82812e57d7995cb683cfd6b5/packages/worker-nestjs/src/worker.module.ts#L33) |
-| <a id="usefactory"></a> `useFactory` | (...`args`) => `AmqpWorkerModuleOptionsFactory`\<`TContract`\> | Factory function that returns the module options. Can use injected dependencies to create configuration. | [worker-nestjs/src/worker.module.ts:28](https://github.com/btravers/amqp-contract/blob/f058a24938d9644a82812e57d7995cb683cfd6b5/packages/worker-nestjs/src/worker.module.ts#L28) |
+| <a id="imports"></a> `imports?` | `ModuleMetadata`\[`"imports"`\] | Optional list of imported modules that export providers needed by the factory | [worker-nestjs/src/worker.module.ts:37](https://github.com/btravers/amqp-contract/blob/ed05e43c04fa526b751d45622ccc1ac53b2e96f9/packages/worker-nestjs/src/worker.module.ts#L37) |
+| <a id="inject"></a> `inject?` | (`string` \| `symbol` \| `Type`\<`unknown`\>)[] | Optional dependencies to inject into the factory function. Can be a token (string/symbol) a class or a reference to a provider. | [worker-nestjs/src/worker.module.ts:33](https://github.com/btravers/amqp-contract/blob/ed05e43c04fa526b751d45622ccc1ac53b2e96f9/packages/worker-nestjs/src/worker.module.ts#L33) |
+| <a id="usefactory"></a> `useFactory` | (...`args`) => `AmqpWorkerModuleOptionsFactory`\<`TContract`\> | Factory function that returns the module options. Can use injected dependencies to create configuration. | [worker-nestjs/src/worker.module.ts:28](https://github.com/btravers/amqp-contract/blob/ed05e43c04fa526b751d45622ccc1ac53b2e96f9/packages/worker-nestjs/src/worker.module.ts#L28) |
 
 ***
 
@@ -287,39 +287,26 @@ Options for async module configuration using factory pattern
 type AmqpWorkerModuleOptions<TContract> = object;
 ```
 
-Defined in: [worker-nestjs/src/worker.service.ts:42](https://github.com/btravers/amqp-contract/blob/f058a24938d9644a82812e57d7995cb683cfd6b5/packages/worker-nestjs/src/worker.service.ts#L42)
+Defined in: [worker-nestjs/src/worker.service.ts:29](https://github.com/btravers/amqp-contract/blob/ed05e43c04fa526b751d45622ccc1ac53b2e96f9/packages/worker-nestjs/src/worker.service.ts#L29)
 
 Configuration options for the AMQP worker NestJS module.
 
 #### Example
 
 ```typescript
-import { defineHandlers, defineUnsafeHandlers } from '@amqp-contract/worker';
-import { Future, Result } from '@swan-io/boxed';
-import { RetryableError } from '@amqp-contract/worker';
+import { defineHandlers, RetryableError } from '@amqp-contract/worker';
+import { Future } from '@swan-io/boxed';
 
-// Using safe handlers (recommended)
 const options: AmqpWorkerModuleOptions<typeof contract> = {
   contract: myContract,
   handlers: defineHandlers(myContract, {
-    processOrder: (message) =>
-      Future.fromPromise(processPayment(message))
+    processOrder: ({ payload }) =>
+      Future.fromPromise(processPayment(payload))
         .mapOk(() => undefined)
         .mapError((error) => new RetryableError('Payment failed', error))
   }),
   urls: ['amqp://localhost'],
 };
-
-// Using unsafe handlers (legacy)
-const options: AmqpWorkerModuleOptions<typeof contract> = {
-  contract: myContract,
-  handlers: defineUnsafeHandlers(myContract, {
-    processOrder: async (message) => {
-      console.log('Processing order:', message.orderId);
-    }
-  }),
-  urls: ['amqp://localhost'],
-};
 ```
 
 #### Type Parameters
@@ -332,20 +319,23 @@ const options: AmqpWorkerModuleOptions<typeof contract> = {
 
 | Property | Type | Description | Defined in |
 | ------ | ------ | ------ | ------ |
-| <a id="connectionoptions"></a> `connectionOptions?` | `AmqpConnectionManagerOptions` | Optional connection configuration (heartbeat, reconnect settings, etc.) | [worker-nestjs/src/worker.service.ts:50](https://github.com/btravers/amqp-contract/blob/f058a24938d9644a82812e57d7995cb683cfd6b5/packages/worker-nestjs/src/worker.service.ts#L50) |
-| <a id="contract"></a> `contract` | `TContract` | The AMQP contract definition specifying consumers and their message schemas | [worker-nestjs/src/worker.service.ts:44](https://github.com/btravers/amqp-contract/blob/f058a24938d9644a82812e57d7995cb683cfd6b5/packages/worker-nestjs/src/worker.service.ts#L44) |
-| <a id="handlers"></a> `handlers` | `WorkerInferSafeConsumerHandlers`\<`TContract`\> | Message handlers for each consumer defined in the contract. Use defineHandlers or defineUnsafeHandlers to create type-safe handlers. | [worker-nestjs/src/worker.service.ts:46](https://github.com/btravers/amqp-contract/blob/f058a24938d9644a82812e57d7995cb683cfd6b5/packages/worker-nestjs/src/worker.service.ts#L46) |
-| <a id="urls"></a> `urls` | `ConnectionUrl`[] | AMQP broker URL(s). Multiple URLs provide failover support | [worker-nestjs/src/worker.service.ts:48](https://github.com/btravers/amqp-contract/blob/f058a24938d9644a82812e57d7995cb683cfd6b5/packages/worker-nestjs/src/worker.service.ts#L48) |
+| <a id="connectionoptions"></a> `connectionOptions?` | `AmqpConnectionManagerOptions` | Optional connection configuration (heartbeat, reconnect settings, etc.) | [worker-nestjs/src/worker.service.ts:37](https://github.com/btravers/amqp-contract/blob/ed05e43c04fa526b751d45622ccc1ac53b2e96f9/packages/worker-nestjs/src/worker.service.ts#L37) |
+| <a id="contract"></a> `contract` | `TContract` | The AMQP contract definition specifying consumers and their message schemas | [worker-nestjs/src/worker.service.ts:31](https://github.com/btravers/amqp-contract/blob/ed05e43c04fa526b751d45622ccc1ac53b2e96f9/packages/worker-nestjs/src/worker.service.ts#L31) |
+| <a id="handlers"></a> `handlers` | [`WorkerInferSafeConsumerHandlers`](#workerinfersafeconsumerhandlers)\<`TContract`\> | Message handlers for each consumer defined in the contract. Use defineHandlers to create type-safe handlers. | [worker-nestjs/src/worker.service.ts:33](https://github.com/btravers/amqp-contract/blob/ed05e43c04fa526b751d45622ccc1ac53b2e96f9/packages/worker-nestjs/src/worker.service.ts#L33) |
+| <a id="urls"></a> `urls` | `ConnectionUrl`[] | AMQP broker URL(s). Multiple URLs provide failover support | [worker-nestjs/src/worker.service.ts:35](https://github.com/btravers/amqp-contract/blob/ed05e43c04fa526b751d45622ccc1ac53b2e96f9/packages/worker-nestjs/src/worker.service.ts#L35) |
 
 ***
 
-### ~~WorkerInferConsumerHandlers~~
+### WorkerInferSafeConsumerHandlers
 
 ```ts
-type WorkerInferConsumerHandlers<TContract> = WorkerInferUnsafeConsumerHandlers<TContract>;
+type WorkerInferSafeConsumerHandlers<TContract> = { [K in InferConsumerNames<TContract>]: WorkerInferSafeConsumerHandlerEntry<TContract, K> };
 ```
 
-Defined in: worker/dist/index.d.mts:182
+Defined in: worker/dist/index.d.mts:160
+
+Safe consumer handlers for a contract.
+All handlers return `Future<Result<void, HandlerError>>` for explicit error control.
 
 #### Type Parameters
 
@@ -353,10 +343,6 @@ Defined in: worker/dist/index.d.mts:182
 | ------ |
 | `TContract` *extends* `ContractDefinition` |
 
-#### Deprecated
-
-Use WorkerInferUnsafeConsumerHandlers instead
-
 ## Variables
 
 ### MODULE\_OPTIONS\_TOKEN
@@ -365,7 +351,7 @@ Use WorkerInferUnsafeConsumerHandlers instead
 const MODULE_OPTIONS_TOKEN: typeof MODULE_OPTIONS_TOKEN;
 ```
 
-Defined in: [worker-nestjs/src/worker.module-definition.ts:5](https://github.com/btravers/amqp-contract/blob/f058a24938d9644a82812e57d7995cb683cfd6b5/packages/worker-nestjs/src/worker.module-definition.ts#L5)
+Defined in: [worker-nestjs/src/worker.module-definition.ts:5](https://github.com/btravers/amqp-contract/blob/ed05e43c04fa526b751d45622ccc1ac53b2e96f9/packages/worker-nestjs/src/worker.module-definition.ts#L5)
 
 Injection token for AMQP worker module options
 Used by NestJS DI system to inject configuration into AmqpWorkerService
@@ -383,17 +369,16 @@ function defineHandler<TContract, TName>(
 handler): WorkerInferSafeConsumerHandlerEntry<TContract, TName>;
 ```
 
-Defined in: worker/dist/index.d.mts:511
+Defined in: worker/dist/index.d.mts:486
 
 Define a type-safe handler for a specific consumer in a contract.
 
 **Recommended:** This function creates handlers that return `Future<Result<void, HandlerError>>`,
 providing explicit error handling and better control over retry behavior.
 
-Supports three patterns:
-1. Simple handler: just the function (single message handler)
-2. Handler with prefetch: [handler, { prefetch: 10 }] (single message handler with config)
-3. Batch handler: [batchHandler, { batchSize: 5, batchTimeout: 1000 }] (REQUIRES batchSize config)
+Supports two patterns:
+1. Simple handler: just the function
+2. Handler with options: [handler, { prefetch: 10 }]
 
 ##### Type Parameters
 
@@ -427,8 +412,8 @@ import { orderContract } from './contract';
 const processOrderHandler = defineHandler(
   orderContract,
   'processOrder',
-  (message) =>
-    Future.fromPromise(processPayment(message))
+  ({ payload }) =>
+    Future.fromPromise(processPayment(payload))
       .mapOk(() => undefined)
       .mapError((error) => new RetryableError('Payment failed', error))
 );
@@ -437,8 +422,8 @@ const processOrderHandler = defineHandler(
 const validateOrderHandler = defineHandler(
   orderContract,
   'validateOrder',
-  (message) => {
-    if (message.amount < 1) {
+  ({ payload }) => {
+    if (payload.amount < 1) {
       // Won't be retried - goes directly to DLQ
       return Future.value(Result.Error(new NonRetryableError('Invalid order amount')));
     }
@@ -457,17 +442,16 @@ function defineHandler<TContract, TName>(
 options): WorkerInferSafeConsumerHandlerEntry<TContract, TName>;
 ```
 
-Defined in: worker/dist/index.d.mts:512
+Defined in: worker/dist/index.d.mts:487
 
 Define a type-safe handler for a specific consumer in a contract.
 
 **Recommended:** This function creates handlers that return `Future<Result<void, HandlerError>>`,
 providing explicit error handling and better control over retry behavior.
 
-Supports three patterns:
-1. Simple handler: just the function (single message handler)
-2. Handler with prefetch: [handler, { prefetch: 10 }] (single message handler with config)
-3. Batch handler: [batchHandler, { batchSize: 5, batchTimeout: 1000 }] (REQUIRES batchSize config)
+Supports two patterns:
+1. Simple handler: just the function
+2. Handler with options: [handler, { prefetch: 10 }]
 
 ##### Type Parameters
 
@@ -483,87 +467,7 @@ Supports three patterns:
 | `contract` | `TContract` | The contract definition containing the consumer |
 | `consumerName` | `TName` | The name of the consumer from the contract |
 | `handler` | `WorkerInferSafeConsumerHandler`\<`TContract`, `TName`\> | The handler function that returns `Future<Result<void, HandlerError>>` |
-| `options` | \{ `batchSize?`: `undefined`; `batchTimeout?`: `undefined`; `prefetch?`: `number`; \} | Optional consumer options (prefetch, batchSize, batchTimeout) |
-| `options.batchSize?` | `undefined` | - |
-| `options.batchTimeout?` | `undefined` | - |
-| `options.prefetch?` | `number` | - |
-
-##### Returns
-
-`WorkerInferSafeConsumerHandlerEntry`\<`TContract`, `TName`\>
-
-A type-safe handler that can be used with TypedAmqpWorker
-
-##### Example
-
-```typescript
-import { defineHandler, RetryableError, NonRetryableError } from '@amqp-contract/worker';
-import { Future, Result } from '@swan-io/boxed';
-import { orderContract } from './contract';
-
-// Simple handler with explicit error handling using mapError
-const processOrderHandler = defineHandler(
-  orderContract,
-  'processOrder',
-  (message) =>
-    Future.fromPromise(processPayment(message))
-      .mapOk(() => undefined)
-      .mapError((error) => new RetryableError('Payment failed', error))
-);
-
-// Handler with validation (non-retryable error)
-const validateOrderHandler = defineHandler(
-  orderContract,
-  'validateOrder',
-  (message) => {
-    if (message.amount < 1) {
-      // Won't be retried - goes directly to DLQ
-      return Future.value(Result.Error(new NonRetryableError('Invalid order amount')));
-    }
-    return Future.value(Result.Ok(undefined));
-  }
-);
-```
-
-#### Call Signature
-
-```ts
-function defineHandler<TContract, TName>(
-   contract, 
-   consumerName, 
-   handler, 
-options): WorkerInferSafeConsumerHandlerEntry<TContract, TName>;
-```
-
-Defined in: worker/dist/index.d.mts:517
-
-Define a type-safe handler for a specific consumer in a contract.
-
-**Recommended:** This function creates handlers that return `Future<Result<void, HandlerError>>`,
-providing explicit error handling and better control over retry behavior.
-
-Supports three patterns:
-1. Simple handler: just the function (single message handler)
-2. Handler with prefetch: [handler, { prefetch: 10 }] (single message handler with config)
-3. Batch handler: [batchHandler, { batchSize: 5, batchTimeout: 1000 }] (REQUIRES batchSize config)
-
-##### Type Parameters
-
-| Type Parameter | Description |
-| ------ | ------ |
-| `TContract` *extends* `ContractDefinition` | The contract definition type |
-| `TName` *extends* `string` \| `number` \| `symbol` | The consumer name from the contract |
-
-##### Parameters
-
-| Parameter | Type | Description |
-| ------ | ------ | ------ |
-| `contract` | `TContract` | The contract definition containing the consumer |
-| `consumerName` | `TName` | The name of the consumer from the contract |
-| `handler` | `WorkerInferSafeConsumerBatchHandler`\<`TContract`, `TName`\> | The handler function that returns `Future<Result<void, HandlerError>>` |
-| `options` | \{ `batchSize`: `number`; `batchTimeout?`: `number`; `prefetch?`: `number`; \} | Optional consumer options (prefetch, batchSize, batchTimeout) |
-| `options.batchSize` | `number` | - |
-| `options.batchTimeout?` | `number` | - |
+| `options` | \{ `prefetch?`: `number`; \} | Optional consumer options (prefetch) |
 | `options.prefetch?` | `number` | - |
 
 ##### Returns
@@ -583,8 +487,8 @@ import { orderContract } from './contract';
 const processOrderHandler = defineHandler(
   orderContract,
   'processOrder',
-  (message) =>
-    Future.fromPromise(processPayment(message))
+  ({ payload }) =>
+    Future.fromPromise(processPayment(payload))
       .mapOk(() => undefined)
       .mapError((error) => new RetryableError('Payment failed', error))
 );
@@ -593,8 +497,8 @@ const processOrderHandler = defineHandler(
 const validateOrderHandler = defineHandler(
   orderContract,
   'validateOrder',
-  (message) => {
-    if (message.amount < 1) {
+  ({ payload }) => {
+    if (payload.amount < 1) {
       // Won't be retried - goes directly to DLQ
       return Future.value(Result.Error(new NonRetryableError('Invalid order amount')));
     }
@@ -611,7 +515,7 @@ const validateOrderHandler = defineHandler(
 function defineHandlers<TContract>(contract, handlers): WorkerInferSafeConsumerHandlers<TContract>;
 ```
 
-Defined in: worker/dist/index.d.mts:551
+Defined in: worker/dist/index.d.mts:519
 
 Define multiple type-safe handlers for consumers in a contract.
 
@@ -629,11 +533,11 @@ providing explicit error handling and better control over retry behavior.
 | Parameter | Type | Description |
 | ------ | ------ | ------ |
 | `contract` | `TContract` | The contract definition containing the consumers |
-| `handlers` | `WorkerInferSafeConsumerHandlers`\<`TContract`\> | An object with handler functions for each consumer |
+| `handlers` | [`WorkerInferSafeConsumerHandlers`](#workerinfersafeconsumerhandlers)\<`TContract`\> | An object with handler functions for each consumer |
 
 #### Returns
 
-`WorkerInferSafeConsumerHandlers`\<`TContract`\>
+[`WorkerInferSafeConsumerHandlers`](#workerinfersafeconsumerhandlers)\<`TContract`\>
 
 A type-safe handlers object that can be used with TypedAmqpWorker
 
@@ -645,12 +549,12 @@ import { Future } from '@swan-io/boxed';
 import { orderContract } from './contract';
 
 const handlers = defineHandlers(orderContract, {
-  processOrder: (message) =>
-    Future.fromPromise(processPayment(message))
+  processOrder: ({ payload }) =>
+    Future.fromPromise(processPayment(payload))
       .mapOk(() => undefined)
       .mapError((error) => new RetryableError('Payment failed', error)),
-  notifyOrder: (message) =>
-    Future.fromPromise(sendNotification(message))
+  notifyOrder: ({ payload }) =>
+    Future.fromPromise(sendNotification(payload))
       .mapOk(() => undefined)
       .mapError((error) => new RetryableError('Notification failed', error)),
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amqp-contract/worker-nestjs",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "description": "NestJS integration for @amqp-contract/worker",
   "keywords": [
     "amqp",
@@ -52,27 +52,27 @@
     "docs"
   ],
   "dependencies": {
-    "@amqp-contract/contract": "0.9.0",
-    "@amqp-contract/worker": "0.9.0"
+    "@amqp-contract/contract": "0.11.0",
+    "@amqp-contract/worker": "0.11.0"
   },
   "devDependencies": {
-    "@nestjs/common": "11.1.11",
-    "@nestjs/core": "11.1.11",
-    "@nestjs/testing": "11.1.11",
+    "@nestjs/common": "11.1.12",
+    "@nestjs/core": "11.1.12",
+    "@nestjs/testing": "11.1.12",
     "@swan-io/boxed": "3.2.1",
-    "@types/node": "25.0.5",
-    "@vitest/coverage-v8": "4.0.16",
+    "@types/node": "25.0.9",
+    "@vitest/coverage-v8": "4.0.17",
     "amqp-connection-manager": "5.0.0",
     "amqplib": "0.10.9",
     "reflect-metadata": "0.2.2",
     "rxjs": "7.8.2",
     "tsdown": "0.19.0",
-    "typedoc": "0.28.15",
+    "typedoc": "0.28.16",
     "typedoc-plugin-markdown": "4.9.0",
     "typescript": "5.9.3",
-    "vitest": "4.0.16",
+    "vitest": "4.0.17",
     "zod": "4.3.5",
-    "@amqp-contract/testing": "0.9.0",
+    "@amqp-contract/testing": "0.11.0",
     "@amqp-contract/tsconfig": "0.1.0",
     "@amqp-contract/typedoc": "0.1.0"
   },