@amqp-contract/worker 0.2.0 → 0.2.1

package/dist/index.d.mts

@@ -1,40 +1,188 @@
-import { Options } from "amqplib";
-import { ContractDefinition, InferConsumerNames, WorkerInferConsumerHandler, WorkerInferConsumerHandlers } from "@amqp-contract/contract";
+import { Future, Result } from "@swan-io/boxed";
+import { ConsumerDefinition, ContractDefinition, InferConsumerNames } from "@amqp-contract/contract";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+import { AmqpConnectionManagerOptions, ConnectionUrl } from "amqp-connection-manager";
 
+//#region src/errors.d.ts
+/**
+ * Base error class for worker errors
+ */
+declare abstract class WorkerError extends Error {
+  protected constructor(message: string);
+}
+/**
+ * Error for technical/runtime failures in worker operations
+ * This includes validation failures, parsing failures, and processing failures
+ */
+declare class TechnicalError extends WorkerError {
+  readonly cause?: unknown | undefined;
+  constructor(message: string, cause?: unknown | undefined);
+}
+/**
+ * Error thrown when message validation fails
+ */
+declare class MessageValidationError extends WorkerError {
+  readonly consumerName: string;
+  readonly issues: unknown;
+  constructor(consumerName: string, issues: unknown);
+}
+//#endregion
+//#region src/types.d.ts
+/**
+ * Infer the TypeScript type from a schema
+ */
+type InferSchemaInput<TSchema extends StandardSchemaV1> = TSchema extends StandardSchemaV1<infer TInput> ? TInput : never;
+/**
+ * Infer consumer message input type
+ */
+type ConsumerInferInput<TConsumer extends ConsumerDefinition> = InferSchemaInput<TConsumer["message"]["payload"]>;
+/**
+ * Infer all consumers from contract
+ */
+type InferConsumers<TContract extends ContractDefinition> = NonNullable<TContract["consumers"]>;
+/**
+ * Get specific consumer definition from contract
+ */
+type InferConsumer<TContract extends ContractDefinition, TName extends InferConsumerNames<TContract>> = InferConsumers<TContract>[TName];
+/**
+ * Worker perspective types - for consuming messages
+ */
+type WorkerInferConsumerInput<TContract extends ContractDefinition, TName extends InferConsumerNames<TContract>> = ConsumerInferInput<InferConsumer<TContract, TName>>;
+/**
+ * Infer consumer handler type for a specific consumer
+ */
+type WorkerInferConsumerHandler<TContract extends ContractDefinition, TName extends InferConsumerNames<TContract>> = (message: WorkerInferConsumerInput<TContract, TName>) => Promise<void>;
+/**
+ * Infer all consumer handlers for a contract
+ */
+type WorkerInferConsumerHandlers<TContract extends ContractDefinition> = { [K in InferConsumerNames<TContract>]: WorkerInferConsumerHandler<TContract, K> };
+//#endregion
 //#region src/worker.d.ts
-
 /**
- * Options for creating a worker
+ * Options for creating a type-safe AMQP worker.
+ *
+ * @typeParam TContract - The contract definition type
+ *
+ * @example
+ * ```typescript
+ * const options: CreateWorkerOptions<typeof contract> = {
+ *   contract: myContract,
+ *   handlers: {
+ *     processOrder: async (message) => {
+ *       console.log('Processing order:', message.orderId);
+ *     }
+ *   },
+ *   urls: ['amqp://localhost'],
+ *   connectionOptions: {
+ *     heartbeatIntervalInSeconds: 30
+ *   }
+ * };
+ * ```
  */
-interface CreateWorkerOptions<TContract extends ContractDefinition> {
+type CreateWorkerOptions<TContract extends ContractDefinition> = {
+  /** The AMQP contract definition specifying consumers and their message schemas */
   contract: TContract;
+  /** 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 for consuming messages
+ * Type-safe AMQP worker for consuming messages from RabbitMQ.
+ *
+ * This class provides automatic message validation, connection management,
+ * and error handling for consuming messages based on a contract definition.
+ *
+ * @typeParam TContract - The contract definition type
+ *
+ * @example
+ * ```typescript
+ * import { TypedAmqpWorker } from '@amqp-contract/worker';
+ * import { z } from 'zod';
+ *
+ * const contract = defineContract({
+ *   queues: {
+ *     orderProcessing: defineQueue('order-processing', { durable: true })
+ *   },
+ *   consumers: {
+ *     processOrder: defineConsumer('order-processing', z.object({
+ *       orderId: z.string(),
+ *       amount: z.number()
+ *     }))
+ *   }
+ * });
+ *
+ * const worker = await TypedAmqpWorker.create({
+ *   contract,
+ *   handlers: {
+ *     processOrder: async (message) => {
+ *       console.log('Processing order', message.orderId);
+ *       // Process the order...
+ *     }
+ *   },
+ *   urls: ['amqp://localhost']
+ * }).resultToPromise();
+ *
+ * // Close when done
+ * await worker.close().resultToPromise();
+ * ```
  */
 declare class TypedAmqpWorker<TContract extends ContractDefinition> {
   private readonly contract;
+  private readonly amqpClient;
   private readonly handlers;
-  private readonly connectionOptions;
-  private channel;
-  private connection;
-  private consumerTags;
   private constructor();
   /**
-   * Create a type-safe AMQP worker from a contract
-   * The worker will automatically connect and start consuming all messages
+   * Create a type-safe AMQP worker from a contract.
+   *
+   * Connection management (including automatic reconnection) is handled internally
+   * by amqp-connection-manager via the {@link AmqpClient}. The worker will set up
+   * consumers for all contract-defined handlers asynchronously in the background
+   * once the underlying connection and channels are ready.
+   *
+   * @param options - Configuration options for the worker
+   * @returns A Future that resolves to a Result containing the worker or an error
+   *
+   * @example
+   * ```typescript
+   * const workerResult = await TypedAmqpWorker.create({
+   *   contract: myContract,
+   *   handlers: {
+   *     processOrder: async (msg) => console.log('Order:', msg.orderId)
+   *   },
+   *   urls: ['amqp://localhost']
+   * }).resultToPromise();
+   *
+   * if (workerResult.isError()) {
+   *   console.error('Failed to create worker:', workerResult.error);
+   * }
+   * ```
    */
-  static create<TContract extends ContractDefinition>(options: CreateWorkerOptions<TContract>): Promise<TypedAmqpWorker<TContract>>;
+  static create<TContract extends ContractDefinition>({
+    contract,
+    handlers,
+    urls,
+    connectionOptions
+  }: CreateWorkerOptions<TContract>): Future<Result<TypedAmqpWorker<TContract>, TechnicalError>>;
   /**
-   * Close the connection
+   * Close the AMQP channel and connection.
+   *
+   * This gracefully closes the connection to the AMQP broker,
+   * stopping all message consumption and cleaning up resources.
+   *
+   * @returns A Future that resolves to a Result indicating success or failure
+   *
+   * @example
+   * ```typescript
+   * const closeResult = await worker.close().resultToPromise();
+   * if (closeResult.isOk()) {
+   *   console.log('Worker closed successfully');
+   * }
+   * ```
    */
-  close(): Promise<void>;
-  /**
-   * Connect to AMQP broker
-   */
-  private init;
+  close(): Future<Result<void, TechnicalError>>;
   /**
    * Start consuming messages for all consumers
    */
@@ -43,34 +191,6 @@ declare class TypedAmqpWorker<TContract extends ContractDefinition> {
    * Start consuming messages for a specific consumer
    */
   private consume;
-  /**
-   * Stop consuming messages
-   */
-  private stopConsuming;
-}
-//#endregion
-//#region src/errors.d.ts
-/**
- * Base error class for worker errors
- */
-declare abstract class WorkerError extends Error {
-  protected constructor(message: string);
-}
-/**
- * Error for technical/runtime failures in worker operations
- * This includes validation failures, parsing failures, and processing failures
- */
-declare class TechnicalError extends WorkerError {
-  readonly cause?: unknown | undefined;
-  constructor(message: string, cause?: unknown | undefined);
-}
-/**
- * Error thrown when message validation fails
- */
-declare class MessageValidationError extends WorkerError {
-  readonly consumerName: string;
-  readonly issues: unknown;
-  constructor(consumerName: string, issues: unknown);
 }
 //#endregion
 //#region src/handlers.d.ts
@@ -202,5 +322,5 @@ declare function defineHandler<TContract extends ContractDefinition, TName exten
  */
 declare function defineHandlers<TContract extends ContractDefinition>(contract: TContract, handlers: WorkerInferConsumerHandlers<TContract>): WorkerInferConsumerHandlers<TContract>;
 //#endregion
-export { type CreateWorkerOptions, MessageValidationError, TechnicalError, TypedAmqpWorker, defineHandler, defineHandlers };
+export { type CreateWorkerOptions, MessageValidationError, TechnicalError, TypedAmqpWorker, type WorkerInferConsumerHandler, type WorkerInferConsumerHandlers, type WorkerInferConsumerInput, 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.ts","../src/errors.ts","../src/handlers.ts"],"sourcesContent":[],"mappings":";;;;;;;AAeA;AAAuD,UAAtC,mBAAsC,CAAA,kBAAA,kBAAA,CAAA,CAAA;EAC3C,QAAA,EAAA,SAAA;EAC4B,QAAA,EAA5B,2BAA4B,CAAA,SAAA,CAAA;EAA5B,UAAA,EAAA,MAAA,GACW,OAAA,CAAQ,OADnB;;;AAOZ;;AAewC,cAf3B,eAe2B,CAAA,kBAfO,kBAeP,CAAA,CAAA;EACP,iBAAA,QAAA;EAApB,iBAAA,QAAA;EACgB,iBAAA,iBAAA;EAAhB,QAAA,OAAA;EAAR,QAAA,UAAA;EAUY,QAAA,YAAA;EAAO,QAAA,WAAA,CAAA;;;;;EC9BX,OAAA,MAAA,CAAA,kBDkB2B,kBClBO,CAAA,CAAA,OAAA,EDmBlC,mBCnBkC,CDmBd,SCnBc,CAAA,CAAA,EDoB1C,OCpB0C,CDoBlC,eCpBkC,CDoBlB,SCpBkB,CAAA,CAAA;EAalC;;;WDiBI;EEyBD;;;EAEA,QAAA,IAAA;EAEJ;;;EAEqC,QAAA,UAAA;EAAtC;;;EACR,QAAA,OAAA;EAA0B;AAuE7B;;EACY,QAAA,aAAA;;;;;;;uBDxJG,WAAA,SAAoB,KAAA;EDYlB,UAAA,WAAA,CAAmB,OAAA,EAAA,MAAA;;;;;;AAGE,cCGzB,cAAA,SAAuB,WAAA,CDHE;EAMzB,SAAA,KAAA,CAAA,EAAA,OAAe,GAAA,SAAA;EAAmB,WAAA,CAAA,OAAA,EAAA,MAAA,EAAA,KAAA,CAAA,EAAA,OAAA,GAAA,SAAA;;;;;AAiBlC,cCPA,sBAAA,SAA+B,WAAA,CDO/B;EAAR,SAAA,YAAA,EAAA,MAAA;EAUY,SAAA,MAAA,EAAA,OAAA;EAAO,WAAA,CAAA,YAAA,EAAA,MAAA,EAAA,MAAA,EAAA,OAAA;;;;;;;AApCxB;;;;;;;AASA;;;;;;;;;;;;;;ACHA;AAaA;;;;AC0CA;;;;;;;;;;;;;AA8EA;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA9EgB,gCACI,kCACJ,mBAAmB,sBAEvB,yBACI,gBACL,2BAA2B,WAAW,SAC9C,2BAA2B,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuEzB,iCAAiC,8BACrC,qBACA,4BAA4B,aACrC,4BAA4B"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/errors.ts","../src/types.ts","../src/worker.ts","../src/handlers.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/index.mjs

@@ -1,6 +1,5 @@
-import { connect } from "amqplib";
-import { setupInfra } from "@amqp-contract/core";
-import { Result } from "@swan-io/boxed";
+import { AmqpClient } from "@amqp-contract/core";
+import { Future, Result } from "@swan-io/boxed";
 
 //#region src/errors.ts
 /**
@@ -40,109 +39,146 @@ var MessageValidationError = class extends WorkerError {
 //#endregion
 //#region src/worker.ts
 /**
-* Type-safe AMQP worker for consuming messages
+* Type-safe AMQP worker for consuming messages from RabbitMQ.
+*
+* This class provides automatic message validation, connection management,
+* and error handling for consuming messages based on a contract definition.
+*
+* @typeParam TContract - The contract definition type
+*
+* @example
+* ```typescript
+* import { TypedAmqpWorker } from '@amqp-contract/worker';
+* import { z } from 'zod';
+*
+* const contract = defineContract({
+*   queues: {
+*     orderProcessing: defineQueue('order-processing', { durable: true })
+*   },
+*   consumers: {
+*     processOrder: defineConsumer('order-processing', z.object({
+*       orderId: z.string(),
+*       amount: z.number()
+*     }))
+*   }
+* });
+*
+* const worker = await TypedAmqpWorker.create({
+*   contract,
+*   handlers: {
+*     processOrder: async (message) => {
+*       console.log('Processing order', message.orderId);
+*       // Process the order...
+*     }
+*   },
+*   urls: ['amqp://localhost']
+* }).resultToPromise();
+*
+* // Close when done
+* await worker.close().resultToPromise();
+* ```
 */
 var TypedAmqpWorker = class TypedAmqpWorker {
-	channel = null;
-	connection = null;
-	consumerTags = [];
-	constructor(contract, handlers, connectionOptions) {
+	constructor(contract, amqpClient, handlers) {
 		this.contract = contract;
+		this.amqpClient = amqpClient;
 		this.handlers = handlers;
-		this.connectionOptions = connectionOptions;
 	}
 	/**
-	* Create a type-safe AMQP worker from a contract
-	* The worker will automatically connect and start consuming all messages
+	* Create a type-safe AMQP worker from a contract.
+	*
+	* Connection management (including automatic reconnection) is handled internally
+	* by amqp-connection-manager via the {@link AmqpClient}. The worker will set up
+	* consumers for all contract-defined handlers asynchronously in the background
+	* once the underlying connection and channels are ready.
+	*
+	* @param options - Configuration options for the worker
+	* @returns A Future that resolves to a Result containing the worker or an error
+	*
+	* @example
+	* ```typescript
+	* const workerResult = await TypedAmqpWorker.create({
+	*   contract: myContract,
+	*   handlers: {
+	*     processOrder: async (msg) => console.log('Order:', msg.orderId)
+	*   },
+	*   urls: ['amqp://localhost']
+	* }).resultToPromise();
+	*
+	* if (workerResult.isError()) {
+	*   console.error('Failed to create worker:', workerResult.error);
+	* }
+	* ```
 	*/
-	static async create(options) {
-		const worker = new TypedAmqpWorker(options.contract, options.handlers, options.connection);
-		await worker.init();
-		await worker.consumeAll();
-		return worker;
+	static create({ contract, handlers, urls, connectionOptions }) {
+		const worker = new TypedAmqpWorker(contract, new AmqpClient(contract, {
+			urls,
+			connectionOptions
+		}), handlers);
+		return worker.consumeAll().mapOk(() => worker);
 	}
 	/**
-	* Close the connection
+	* Close the AMQP channel and connection.
+	*
+	* This gracefully closes the connection to the AMQP broker,
+	* stopping all message consumption and cleaning up resources.
+	*
+	* @returns A Future that resolves to a Result indicating success or failure
+	*
+	* @example
+	* ```typescript
+	* const closeResult = await worker.close().resultToPromise();
+	* if (closeResult.isOk()) {
+	*   console.log('Worker closed successfully');
+	* }
+	* ```
 	*/
-	async close() {
-		await this.stopConsuming();
-		if (this.channel) {
-			await this.channel.close();
-			this.channel = null;
-		}
-		if (this.connection) {
-			await this.connection.close();
-			this.connection = null;
-		}
-	}
-	/**
-	* Connect to AMQP broker
-	*/
-	async init() {
-		this.connection = await connect(this.connectionOptions);
-		this.channel = await this.connection.createChannel();
-		await setupInfra(this.channel, this.contract);
+	close() {
+		return Future.fromPromise(this.amqpClient.close()).mapError((error) => new TechnicalError("Failed to close AMQP connection", error)).mapOk(() => void 0);
 	}
 	/**
 	* Start consuming messages for all consumers
 	*/
-	async consumeAll() {
-		if (!this.contract.consumers) throw new Error("No consumers defined in contract");
+	consumeAll() {
+		if (!this.contract.consumers) return Future.value(Result.Error(new TechnicalError("No consumers defined in contract")));
 		const consumerNames = Object.keys(this.contract.consumers);
-		for (const consumerName of consumerNames) await this.consume(consumerName);
+		return Future.all(consumerNames.map((consumerName) => this.consume(consumerName))).map(Result.all).mapOk(() => void 0);
 	}
 	/**
 	* Start consuming messages for a specific consumer
 	*/
-	async consume(consumerName) {
-		if (!this.channel) throw new Error("Worker not initialized. Use TypedAmqpWorker.create() to obtain an initialized worker instance.");
+	consume(consumerName) {
 		const consumers = this.contract.consumers;
-		if (!consumers) throw new Error("No consumers defined in contract");
+		if (!consumers) return Future.value(Result.Error(new TechnicalError("No consumers defined in contract")));
 		const consumer = consumers[consumerName];
-		if (!consumer || typeof consumer !== "object") {
+		if (!consumer) {
 			const availableConsumers = Object.keys(consumers);
 			const available = availableConsumers.length > 0 ? availableConsumers.join(", ") : "none";
-			throw new Error(`Consumer not found: "${String(consumerName)}". Available consumers: ${available}`);
+			return Future.value(Result.Error(new TechnicalError(`Consumer not found: "${String(consumerName)}". Available consumers: ${available}`)));
 		}
-		const consumerDef = consumer;
 		const handler = this.handlers[consumerName];
-		if (!handler) throw new Error(`Handler for "${String(consumerName)}" not provided`);
-		if (consumerDef.prefetch !== void 0) await this.channel.prefetch(consumerDef.prefetch);
-		const result = await this.channel.consume(consumerDef.queue.name, async (msg) => {
-			if (!msg) return;
+		if (!handler) return Future.value(Result.Error(new TechnicalError(`Handler for "${String(consumerName)}" not provided`)));
+		return Future.fromPromise(this.amqpClient.channel.consume(consumer.queue.name, async (msg) => {
 			const parseResult = Result.fromExecution(() => JSON.parse(msg.content.toString()));
 			if (parseResult.isError()) {
 				console.error(new TechnicalError(`Error parsing message for consumer "${String(consumerName)}"`, parseResult.error));
-				this.channel?.nack(msg, false, false);
-				return;
-			}
-			const content = parseResult.value;
-			const rawValidation = consumerDef.message.payload["~standard"].validate(content);
-			const resolvedValidation = rawValidation instanceof Promise ? await rawValidation : rawValidation;
-			const validationResult = typeof resolvedValidation === "object" && resolvedValidation !== null && "issues" in resolvedValidation && resolvedValidation.issues ? Result.Error(new MessageValidationError(String(consumerName), resolvedValidation.issues)) : Result.Ok(typeof resolvedValidation === "object" && resolvedValidation !== null && "value" in resolvedValidation ? resolvedValidation.value : content);
-			if (validationResult.isError()) {
-				console.error(validationResult.error);
-				this.channel?.nack(msg, false, false);
+				this.amqpClient.channel.nack(msg, false, false);
 				return;
 			}
-			const validatedMessage = validationResult.value;
-			try {
-				await handler(validatedMessage);
-				if (!consumerDef.noAck) this.channel?.ack(msg);
-			} catch (error) {
+			const rawValidation = consumer.message.payload["~standard"].validate(parseResult.value);
+			await Future.fromPromise(rawValidation instanceof Promise ? rawValidation : Promise.resolve(rawValidation)).mapOkToResult((validationResult) => {
+				if (validationResult.issues) return Result.Error(new MessageValidationError(String(consumerName), validationResult.issues));
+				return Result.Ok(validationResult.value);
+			}).tapError((error) => {
+				console.error(error);
+				this.amqpClient.channel.nack(msg, false, false);
+			}).flatMapOk((validatedMessage) => Future.fromPromise(handler(validatedMessage)).tapError((error) => {
 				console.error(new TechnicalError(`Error processing message for consumer "${String(consumerName)}"`, error));
-				this.channel?.nack(msg, false, true);
-			}
-		}, { noAck: consumerDef.noAck ?? false });
-		this.consumerTags.push(result.consumerTag);
-	}
-	/**
-	* Stop consuming messages
-	*/
-	async stopConsuming() {
-		if (!this.channel) return;
-		for (const tag of this.consumerTags) await this.channel.cancel(tag);
-		this.consumerTags = [];
+				this.amqpClient.channel.nack(msg, false, true);
+			})).tapOk(() => {
+				this.amqpClient.channel.ack(msg);
+			}).toPromise();
+		})).mapError((error) => new TechnicalError(`Failed to start consuming for "${String(consumerName)}"`, error)).mapOk(() => void 0);
 	}
 };
 
@@ -284,11 +320,9 @@ function defineHandler(contract, consumerName, handler) {
 */
 function defineHandlers(contract, handlers) {
 	const consumers = contract.consumers;
-	const availableConsumers = consumers ? Object.keys(consumers) : [];
-	for (const handlerName of Object.keys(handlers)) if (!consumers || !(handlerName in consumers)) {
-		const available = availableConsumers.length > 0 ? availableConsumers.join(", ") : "none";
-		throw new Error(`Consumer "${handlerName}" not found in contract. Available consumers: ${available}`);
-	}
+	const availableConsumers = Object.keys(consumers ?? {});
+	const availableConsumerNames = availableConsumers.length > 0 ? availableConsumers.join(", ") : "none";
+	for (const handlerName of Object.keys(handlers)) if (!consumers || !(handlerName in consumers)) throw new Error(`Consumer "${handlerName}" not found in contract. Available consumers: ${availableConsumerNames}`);
 	return handlers;
 }
 

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":["cause?: unknown","consumerName: string","issues: unknown","contract: TContract","handlers: WorkerInferConsumerHandlers<TContract>","connectionOptions: string | Options.Connect","validationResult: Result<unknown, MessageValidationError>"],"sources":["../src/errors.ts","../src/worker.ts","../src/handlers.ts"],"sourcesContent":["/**\n * Base error class for worker errors\n */\nabstract class WorkerError extends Error {\n  protected constructor(message: string) {\n    super(message);\n    this.name = \"WorkerError\";\n    // Node.js specific stack trace capture\n    const ErrorConstructor = Error as unknown as {\n      captureStackTrace?: (target: object, constructor: Function) => void;\n    };\n    if (typeof ErrorConstructor.captureStackTrace === \"function\") {\n      ErrorConstructor.captureStackTrace(this, this.constructor);\n    }\n  }\n}\n\n/**\n * Error for technical/runtime failures in worker operations\n * This includes validation failures, parsing failures, and processing failures\n */\nexport class TechnicalError extends WorkerError {\n  constructor(\n    message: string,\n    public override readonly cause?: unknown,\n  ) {\n    super(message);\n    this.name = \"TechnicalError\";\n  }\n}\n\n/**\n * Error thrown when message validation fails\n */\nexport class MessageValidationError extends WorkerError {\n  constructor(\n    public readonly consumerName: string,\n    public readonly issues: unknown,\n  ) {\n    super(`Message validation failed for consumer \"${consumerName}\"`);\n    this.name = \"MessageValidationError\";\n  }\n}\n","import { connect } from \"amqplib\";\nimport type { Channel, ChannelModel, ConsumeMessage, Options } from \"amqplib\";\nimport type {\n  ContractDefinition,\n  InferConsumerNames,\n  WorkerInferConsumerHandlers,\n  WorkerInferConsumerInput,\n} from \"@amqp-contract/contract\";\nimport { setupInfra } from \"@amqp-contract/core\";\nimport { Result } from \"@swan-io/boxed\";\nimport { MessageValidationError, TechnicalError } from \"./errors.js\";\n\n/**\n * Options for creating a worker\n */\nexport interface CreateWorkerOptions<TContract extends ContractDefinition> {\n  contract: TContract;\n  handlers: WorkerInferConsumerHandlers<TContract>;\n  connection: string | Options.Connect;\n}\n\n/**\n * Type-safe AMQP worker for consuming messages\n */\nexport class TypedAmqpWorker<TContract extends ContractDefinition> {\n  private channel: Channel | null = null;\n  private connection: ChannelModel | null = null;\n  private consumerTags: string[] = [];\n\n  private constructor(\n    private readonly contract: TContract,\n    private readonly handlers: WorkerInferConsumerHandlers<TContract>,\n    private readonly connectionOptions: string | Options.Connect,\n  ) {}\n\n  /**\n   * Create a type-safe AMQP worker from a contract\n   * The worker will automatically connect and start consuming all messages\n   */\n  static async create<TContract extends ContractDefinition>(\n    options: CreateWorkerOptions<TContract>,\n  ): Promise<TypedAmqpWorker<TContract>> {\n    const worker = new TypedAmqpWorker(options.contract, options.handlers, options.connection);\n    await worker.init();\n    await worker.consumeAll();\n    return worker;\n  }\n\n  /**\n   * Close the connection\n   */\n  async close(): Promise<void> {\n    await this.stopConsuming();\n\n    if (this.channel) {\n      await this.channel.close();\n      this.channel = null;\n    }\n\n    if (this.connection) {\n      await this.connection.close();\n      this.connection = null;\n    }\n  }\n\n  /**\n   * Connect to AMQP broker\n   */\n  private async init(): Promise<void> {\n    this.connection = await connect(this.connectionOptions);\n    this.channel = await this.connection.createChannel();\n\n    // Setup exchanges, queues, and bindings\n    await setupInfra(this.channel, this.contract);\n  }\n\n  /**\n   * Start consuming messages for all consumers\n   */\n  private async consumeAll(): Promise<void> {\n    if (!this.contract.consumers) {\n      throw new Error(\"No consumers defined in contract\");\n    }\n\n    const consumerNames = Object.keys(this.contract.consumers) as InferConsumerNames<TContract>[];\n\n    for (const consumerName of consumerNames) {\n      await this.consume(consumerName);\n    }\n  }\n\n  /**\n   * Start consuming messages for a specific consumer\n   */\n  private async consume<TName extends InferConsumerNames<TContract>>(\n    consumerName: TName,\n  ): Promise<void> {\n    if (!this.channel) {\n      throw new Error(\n        \"Worker not initialized. Use TypedAmqpWorker.create() to obtain an initialized worker instance.\",\n      );\n    }\n\n    const consumers = this.contract.consumers as Record<string, unknown>;\n    if (!consumers) {\n      throw new Error(\"No consumers defined in contract\");\n    }\n\n    const consumer = consumers[consumerName as string];\n    if (!consumer || typeof consumer !== \"object\") {\n      const availableConsumers = Object.keys(consumers);\n      const available = availableConsumers.length > 0 ? availableConsumers.join(\", \") : \"none\";\n      throw new Error(\n        `Consumer not found: \"${String(consumerName)}\". Available consumers: ${available}`,\n      );\n    }\n\n    const consumerDef = consumer as {\n      queue: { name: string };\n      message: { payload: { \"~standard\": { validate: (value: unknown) => unknown } } };\n      prefetch?: number;\n      noAck?: boolean;\n    };\n\n    const handler = this.handlers[consumerName];\n    if (!handler) {\n      throw new Error(`Handler for \"${String(consumerName)}\" not provided`);\n    }\n\n    // Set prefetch if specified\n    if (consumerDef.prefetch !== undefined) {\n      await this.channel.prefetch(consumerDef.prefetch);\n    }\n\n    // Start consuming\n    const result = await this.channel.consume(\n      consumerDef.queue.name,\n      async (msg: ConsumeMessage | null) => {\n        if (!msg) {\n          return;\n        }\n\n        // Parse message\n        const parseResult = Result.fromExecution(() => JSON.parse(msg.content.toString()));\n\n        if (parseResult.isError()) {\n          console.error(\n            new TechnicalError(\n              `Error parsing message for consumer \"${String(consumerName)}\"`,\n              parseResult.error,\n            ),\n          );\n          // Reject message with no requeue (malformed JSON)\n          this.channel?.nack(msg, false, false);\n          return;\n        }\n\n        const content = parseResult.value;\n\n        // Validate message using schema (supports sync and async validators)\n        const rawValidation = consumerDef.message.payload[\"~standard\"].validate(content);\n        const resolvedValidation =\n          rawValidation instanceof Promise ? await rawValidation : rawValidation;\n        const validationResult: Result<unknown, MessageValidationError> =\n          typeof resolvedValidation === \"object\" &&\n          resolvedValidation !== null &&\n          \"issues\" in resolvedValidation &&\n          resolvedValidation.issues\n            ? Result.Error(\n                new MessageValidationError(String(consumerName), resolvedValidation.issues),\n              )\n            : Result.Ok(\n                typeof resolvedValidation === \"object\" &&\n                  resolvedValidation !== null &&\n                  \"value\" in resolvedValidation\n                  ? resolvedValidation.value\n                  : content,\n              );\n\n        if (validationResult.isError()) {\n          console.error(validationResult.error);\n          // Reject message with no requeue (validation failed)\n          this.channel?.nack(msg, false, false);\n          return;\n        }\n\n        const validatedMessage = validationResult.value as WorkerInferConsumerInput<\n          TContract,\n          TName\n        >;\n\n        // Call handler and wait for Promise to resolve\n        try {\n          await handler(validatedMessage);\n\n          // Acknowledge message if not in noAck mode\n          if (!consumerDef.noAck) {\n            this.channel?.ack(msg);\n          }\n        } catch (error) {\n          console.error(\n            new TechnicalError(\n              `Error processing message for consumer \"${String(consumerName)}\"`,\n              error,\n            ),\n          );\n          // Reject message and requeue (handler failed)\n          this.channel?.nack(msg, false, true);\n        }\n      },\n      {\n        noAck: consumerDef.noAck ?? false,\n      },\n    );\n\n    this.consumerTags.push(result.consumerTag);\n  }\n\n  /**\n   * Stop consuming messages\n   */\n  private async stopConsuming(): Promise<void> {\n    if (!this.channel) {\n      return;\n    }\n\n    for (const tag of this.consumerTags) {\n      await this.channel.cancel(tag);\n    }\n\n    this.consumerTags = [];\n  }\n}\n","import type {\n  ContractDefinition,\n  InferConsumerNames,\n  WorkerInferConsumerHandler,\n  WorkerInferConsumerHandlers,\n} from \"@amqp-contract/contract\";\n\n/**\n * Define a type-safe handler for a specific consumer in a contract.\n *\n * This utility allows you to define handlers outside of the worker creation,\n * providing better code organization and reusability.\n *\n * @template TContract - The contract definition type\n * @template TName - The consumer name from the contract\n * @param contract - The contract definition containing the consumer\n * @param consumerName - The name of the consumer from the contract\n * @param handler - The async handler function that processes messages\n * @returns A type-safe handler that can be used with TypedAmqpWorker\n *\n * @example\n * ```typescript\n * import { defineHandler } from '@amqp-contract/worker';\n * import { orderContract } from './contract';\n *\n * // Define handler outside of worker creation\n * const processOrderHandler = defineHandler(\n *   orderContract,\n *   'processOrder',\n *   async (message) => {\n *     // message is fully typed based on the contract\n *     console.log('Processing order:', message.orderId);\n *     await processPayment(message);\n *   }\n * );\n *\n * // Use the handler in worker\n * const worker = await TypedAmqpWorker.create({\n *   contract: orderContract,\n *   handlers: {\n *     processOrder: processOrderHandler,\n *   },\n *   connection: 'amqp://localhost',\n * });\n * ```\n *\n * @example\n * ```typescript\n * // Define multiple handlers\n * const processOrderHandler = defineHandler(\n *   orderContract,\n *   'processOrder',\n *   async (message) => {\n *     await processOrder(message);\n *   }\n * );\n *\n * const notifyOrderHandler = defineHandler(\n *   orderContract,\n *   'notifyOrder',\n *   async (message) => {\n *     await sendNotification(message);\n *   }\n * );\n *\n * // Compose handlers\n * const worker = await TypedAmqpWorker.create({\n *   contract: orderContract,\n *   handlers: {\n *     processOrder: processOrderHandler,\n *     notifyOrder: notifyOrderHandler,\n *   },\n *   connection: 'amqp://localhost',\n * });\n * ```\n */\nexport function defineHandler<\n  TContract extends ContractDefinition,\n  TName extends InferConsumerNames<TContract>,\n>(\n  contract: TContract,\n  consumerName: TName,\n  handler: WorkerInferConsumerHandler<TContract, TName>,\n): WorkerInferConsumerHandler<TContract, TName> {\n  // Validate that the consumer exists in the contract\n  const consumers = contract.consumers as Record<string, unknown> | undefined;\n  if (!consumers || !((consumerName as string) in consumers)) {\n    const availableConsumers = consumers ? Object.keys(consumers) : [];\n    const available = availableConsumers.length > 0 ? availableConsumers.join(\", \") : \"none\";\n    throw new Error(\n      `Consumer \"${String(consumerName)}\" not found in contract. Available consumers: ${available}`,\n    );\n  }\n\n  // Return the handler as-is, with type checking enforced\n  return handler;\n}\n\n/**\n * Define multiple type-safe handlers for consumers in a contract.\n *\n * This utility allows you to define all handlers at once outside of the worker creation,\n * ensuring type safety and providing better code organization.\n *\n * @template TContract - The contract definition type\n * @param contract - The contract definition containing the consumers\n * @param handlers - An object with async handler functions for each consumer\n * @returns A type-safe handlers object that can be used with TypedAmqpWorker\n *\n * @example\n * ```typescript\n * import { defineHandlers } from '@amqp-contract/worker';\n * import { orderContract } from './contract';\n *\n * // Define all handlers at once\n * const handlers = defineHandlers(orderContract, {\n *   processOrder: async (message) => {\n *     // message is fully typed based on the contract\n *     console.log('Processing order:', message.orderId);\n *     await processPayment(message);\n *   },\n *   notifyOrder: async (message) => {\n *     await sendNotification(message);\n *   },\n *   shipOrder: async (message) => {\n *     await prepareShipment(message);\n *   },\n * });\n *\n * // Use the handlers in worker\n * const worker = await TypedAmqpWorker.create({\n *   contract: orderContract,\n *   handlers,\n *   connection: 'amqp://localhost',\n * });\n * ```\n *\n * @example\n * ```typescript\n * // Separate handler definitions for better organization\n * async function handleProcessOrder(message: WorkerInferConsumerInput<typeof orderContract, 'processOrder'>) {\n *   await processOrder(message);\n * }\n *\n * async function handleNotifyOrder(message: WorkerInferConsumerInput<typeof orderContract, 'notifyOrder'>) {\n *   await sendNotification(message);\n * }\n *\n * const handlers = defineHandlers(orderContract, {\n *   processOrder: handleProcessOrder,\n *   notifyOrder: handleNotifyOrder,\n * });\n * ```\n */\nexport function defineHandlers<TContract extends ContractDefinition>(\n  contract: TContract,\n  handlers: WorkerInferConsumerHandlers<TContract>,\n): WorkerInferConsumerHandlers<TContract> {\n  // Validate that all consumers in handlers exist in the contract\n  const consumers = contract.consumers as Record<string, unknown> | undefined;\n  const availableConsumers = consumers ? Object.keys(consumers) : [];\n\n  for (const handlerName of Object.keys(handlers)) {\n    if (!consumers || !(handlerName in consumers)) {\n      const available = availableConsumers.length > 0 ? availableConsumers.join(\", \") : \"none\";\n      throw new Error(\n        `Consumer \"${handlerName}\" not found in contract. Available consumers: ${available}`,\n      );\n    }\n  }\n\n  // Return the handlers as-is, with type checking enforced\n  return handlers;\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.mjs","names":["cause?: unknown","consumerName: string","issues: unknown","contract: TContract","amqpClient: AmqpClient","handlers: WorkerInferConsumerHandlers<TContract>"],"sources":["../src/errors.ts","../src/worker.ts","../src/handlers.ts"],"sourcesContent":["/**\n * Base error class for worker errors\n */\nabstract class WorkerError extends Error {\n  protected constructor(message: string) {\n    super(message);\n    this.name = \"WorkerError\";\n    // Node.js specific stack trace capture\n    const ErrorConstructor = Error as unknown as {\n      captureStackTrace?: (target: object, constructor: Function) => void;\n    };\n    if (typeof ErrorConstructor.captureStackTrace === \"function\") {\n      ErrorConstructor.captureStackTrace(this, this.constructor);\n    }\n  }\n}\n\n/**\n * Error for technical/runtime failures in worker operations\n * This includes validation failures, parsing failures, and processing failures\n */\nexport class TechnicalError extends WorkerError {\n  constructor(\n    message: string,\n    public override readonly cause?: unknown,\n  ) {\n    super(message);\n    this.name = \"TechnicalError\";\n  }\n}\n\n/**\n * Error thrown when message validation fails\n */\nexport class MessageValidationError extends WorkerError {\n  constructor(\n    public readonly consumerName: string,\n    public readonly issues: unknown,\n  ) {\n    super(`Message validation failed for consumer \"${consumerName}\"`);\n    this.name = \"MessageValidationError\";\n  }\n}\n","import type { ContractDefinition, InferConsumerNames } from \"@amqp-contract/contract\";\nimport { AmqpClient } from \"@amqp-contract/core\";\nimport { Future, Result } from \"@swan-io/boxed\";\nimport { MessageValidationError, TechnicalError } from \"./errors.js\";\nimport type { WorkerInferConsumerHandlers, WorkerInferConsumerInput } from \"./types.js\";\nimport type { AmqpConnectionManagerOptions, ConnectionUrl } from \"amqp-connection-manager\";\n\n/**\n * Options for creating a type-safe AMQP worker.\n *\n * @typeParam TContract - The contract definition type\n *\n * @example\n * ```typescript\n * const options: CreateWorkerOptions<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 type CreateWorkerOptions<TContract extends ContractDefinition> = {\n  /** The AMQP contract definition specifying consumers and their message schemas */\n  contract: TContract;\n  /** 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 for consuming messages from RabbitMQ.\n *\n * This class provides automatic message validation, connection management,\n * and error handling for consuming messages based on a contract definition.\n *\n * @typeParam TContract - The contract definition type\n *\n * @example\n * ```typescript\n * import { TypedAmqpWorker } from '@amqp-contract/worker';\n * import { z } from 'zod';\n *\n * const contract = defineContract({\n *   queues: {\n *     orderProcessing: defineQueue('order-processing', { durable: true })\n *   },\n *   consumers: {\n *     processOrder: defineConsumer('order-processing', z.object({\n *       orderId: z.string(),\n *       amount: z.number()\n *     }))\n *   }\n * });\n *\n * const worker = await TypedAmqpWorker.create({\n *   contract,\n *   handlers: {\n *     processOrder: async (message) => {\n *       console.log('Processing order', message.orderId);\n *       // Process the order...\n *     }\n *   },\n *   urls: ['amqp://localhost']\n * }).resultToPromise();\n *\n * // Close when done\n * await worker.close().resultToPromise();\n * ```\n */\nexport class TypedAmqpWorker<TContract extends ContractDefinition> {\n  private constructor(\n    private readonly contract: TContract,\n    private readonly amqpClient: AmqpClient,\n    private readonly handlers: WorkerInferConsumerHandlers<TContract>,\n  ) {}\n\n  /**\n   * Create a type-safe AMQP worker from a contract.\n   *\n   * Connection management (including automatic reconnection) is handled internally\n   * by amqp-connection-manager via the {@link AmqpClient}. The worker will set up\n   * consumers for all contract-defined handlers asynchronously in the background\n   * once the underlying connection and channels are ready.\n   *\n   * @param options - Configuration options for the worker\n   * @returns A Future that resolves to a Result containing the worker or an error\n   *\n   * @example\n   * ```typescript\n   * const workerResult = await TypedAmqpWorker.create({\n   *   contract: myContract,\n   *   handlers: {\n   *     processOrder: async (msg) => console.log('Order:', msg.orderId)\n   *   },\n   *   urls: ['amqp://localhost']\n   * }).resultToPromise();\n   *\n   * if (workerResult.isError()) {\n   *   console.error('Failed to create worker:', workerResult.error);\n   * }\n   * ```\n   */\n  static create<TContract extends ContractDefinition>({\n    contract,\n    handlers,\n    urls,\n    connectionOptions,\n  }: CreateWorkerOptions<TContract>): Future<Result<TypedAmqpWorker<TContract>, TechnicalError>> {\n    const worker = new TypedAmqpWorker(\n      contract,\n      new AmqpClient(contract, {\n        urls,\n        connectionOptions,\n      }),\n      handlers,\n    );\n    return worker.consumeAll().mapOk(() => worker);\n  }\n\n  /**\n   * Close the AMQP channel and connection.\n   *\n   * This gracefully closes the connection to the AMQP broker,\n   * stopping all message consumption and cleaning up resources.\n   *\n   * @returns A Future that resolves to a Result indicating success or failure\n   *\n   * @example\n   * ```typescript\n   * const closeResult = await worker.close().resultToPromise();\n   * if (closeResult.isOk()) {\n   *   console.log('Worker closed successfully');\n   * }\n   * ```\n   */\n  close(): Future<Result<void, TechnicalError>> {\n    return Future.fromPromise(this.amqpClient.close())\n      .mapError((error) => new TechnicalError(\"Failed to close AMQP connection\", error))\n      .mapOk(() => undefined);\n  }\n\n  /**\n   * Start consuming messages for all consumers\n   */\n  private consumeAll(): Future<Result<void, TechnicalError>> {\n    if (!this.contract.consumers) {\n      return Future.value(Result.Error(new TechnicalError(\"No consumers defined in contract\")));\n    }\n\n    const consumerNames = Object.keys(this.contract.consumers) as InferConsumerNames<TContract>[];\n\n    return Future.all(consumerNames.map((consumerName) => this.consume(consumerName)))\n      .map(Result.all)\n      .mapOk(() => undefined);\n  }\n\n  /**\n   * Start consuming messages for a specific consumer\n   */\n  private consume<TName extends InferConsumerNames<TContract>>(\n    consumerName: TName,\n  ): Future<Result<void, TechnicalError>> {\n    const consumers = this.contract.consumers;\n    if (!consumers) {\n      return Future.value(Result.Error(new TechnicalError(\"No consumers defined in contract\")));\n    }\n\n    const consumer = consumers[consumerName as string];\n    if (!consumer) {\n      const availableConsumers = Object.keys(consumers);\n      const available = availableConsumers.length > 0 ? availableConsumers.join(\", \") : \"none\";\n      return Future.value(\n        Result.Error(\n          new TechnicalError(\n            `Consumer not found: \"${String(consumerName)}\". Available consumers: ${available}`,\n          ),\n        ),\n      );\n    }\n\n    const handler = this.handlers[consumerName];\n    if (!handler) {\n      return Future.value(\n        Result.Error(new TechnicalError(`Handler for \"${String(consumerName)}\" not provided`)),\n      );\n    }\n\n    // Start consuming\n    return Future.fromPromise(\n      this.amqpClient.channel.consume(consumer.queue.name, async (msg) => {\n        // Parse message\n        const parseResult = Result.fromExecution(() => JSON.parse(msg.content.toString()));\n        if (parseResult.isError()) {\n          // fixme: define a proper logging mechanism\n          // fixme: do not log just an error, use a proper logging mechanism\n          console.error(\n            new TechnicalError(\n              `Error parsing message for consumer \"${String(consumerName)}\"`,\n              parseResult.error,\n            ),\n          );\n\n          // fixme proper error handling strategy\n          // Reject message with no requeue (malformed JSON)\n          this.amqpClient.channel.nack(msg, false, false);\n          return;\n        }\n\n        const rawValidation = consumer.message.payload[\"~standard\"].validate(parseResult.value);\n        await Future.fromPromise(\n          rawValidation instanceof Promise ? rawValidation : Promise.resolve(rawValidation),\n        )\n          .mapOkToResult((validationResult) => {\n            if (validationResult.issues) {\n              return Result.Error(\n                new MessageValidationError(String(consumerName), validationResult.issues),\n              );\n            }\n\n            return Result.Ok(validationResult.value as WorkerInferConsumerInput<TContract, TName>);\n          })\n          .tapError((error) => {\n            // fixme: define a proper logging mechanism\n            // fixme: do not log just an error, use a proper logging mechanism\n            console.error(error);\n\n            // fixme proper error handling strategy\n            // Reject message with no requeue (validation failed)\n            this.amqpClient.channel.nack(msg, false, false);\n          })\n          .flatMapOk((validatedMessage) =>\n            Future.fromPromise(handler(validatedMessage)).tapError((error) => {\n              // fixme: define a proper logging mechanism\n              // fixme: do not log just an error, use a proper logging mechanism\n              console.error(\n                new TechnicalError(\n                  `Error processing message for consumer \"${String(consumerName)}\"`,\n                  error,\n                ),\n              );\n\n              // fixme proper error handling strategy\n              // Reject message and requeue (handler failed)\n              this.amqpClient.channel.nack(msg, false, true);\n            }),\n          )\n          .tapOk(() => {\n            // Acknowledge message\n            this.amqpClient.channel.ack(msg);\n          })\n          .toPromise();\n      }),\n    )\n      .mapError(\n        (error) =>\n          new TechnicalError(`Failed to start consuming for \"${String(consumerName)}\"`, error),\n      )\n      .mapOk(() => undefined);\n  }\n}\n","import type { ContractDefinition, InferConsumerNames } from \"@amqp-contract/contract\";\nimport type { WorkerInferConsumerHandler, WorkerInferConsumerHandlers } from \"./types.js\";\n\n/**\n * Define a type-safe handler for a specific consumer in a contract.\n *\n * This utility allows you to define handlers outside of the worker creation,\n * providing better code organization and reusability.\n *\n * @template TContract - The contract definition type\n * @template TName - The consumer name from the contract\n * @param contract - The contract definition containing the consumer\n * @param consumerName - The name of the consumer from the contract\n * @param handler - The async handler function that processes messages\n * @returns A type-safe handler that can be used with TypedAmqpWorker\n *\n * @example\n * ```typescript\n * import { defineHandler } from '@amqp-contract/worker';\n * import { orderContract } from './contract';\n *\n * // Define handler outside of worker creation\n * const processOrderHandler = defineHandler(\n *   orderContract,\n *   'processOrder',\n *   async (message) => {\n *     // message is fully typed based on the contract\n *     console.log('Processing order:', message.orderId);\n *     await processPayment(message);\n *   }\n * );\n *\n * // Use the handler in worker\n * const worker = await TypedAmqpWorker.create({\n *   contract: orderContract,\n *   handlers: {\n *     processOrder: processOrderHandler,\n *   },\n *   connection: 'amqp://localhost',\n * });\n * ```\n *\n * @example\n * ```typescript\n * // Define multiple handlers\n * const processOrderHandler = defineHandler(\n *   orderContract,\n *   'processOrder',\n *   async (message) => {\n *     await processOrder(message);\n *   }\n * );\n *\n * const notifyOrderHandler = defineHandler(\n *   orderContract,\n *   'notifyOrder',\n *   async (message) => {\n *     await sendNotification(message);\n *   }\n * );\n *\n * // Compose handlers\n * const worker = await TypedAmqpWorker.create({\n *   contract: orderContract,\n *   handlers: {\n *     processOrder: processOrderHandler,\n *     notifyOrder: notifyOrderHandler,\n *   },\n *   connection: 'amqp://localhost',\n * });\n * ```\n */\nexport function defineHandler<\n  TContract extends ContractDefinition,\n  TName extends InferConsumerNames<TContract>,\n>(\n  contract: TContract,\n  consumerName: TName,\n  handler: WorkerInferConsumerHandler<TContract, TName>,\n): WorkerInferConsumerHandler<TContract, TName> {\n  // Validate that the consumer exists in the contract\n  const consumers = contract.consumers;\n\n  if (!consumers || !(consumerName in consumers)) {\n    const availableConsumers = consumers ? Object.keys(consumers) : [];\n    const available = availableConsumers.length > 0 ? availableConsumers.join(\", \") : \"none\";\n    throw new Error(\n      `Consumer \"${String(consumerName)}\" not found in contract. Available consumers: ${available}`,\n    );\n  }\n\n  // Return the handler as-is, with type checking enforced\n  return handler;\n}\n\n/**\n * Define multiple type-safe handlers for consumers in a contract.\n *\n * This utility allows you to define all handlers at once outside of the worker creation,\n * ensuring type safety and providing better code organization.\n *\n * @template TContract - The contract definition type\n * @param contract - The contract definition containing the consumers\n * @param handlers - An object with async handler functions for each consumer\n * @returns A type-safe handlers object that can be used with TypedAmqpWorker\n *\n * @example\n * ```typescript\n * import { defineHandlers } from '@amqp-contract/worker';\n * import { orderContract } from './contract';\n *\n * // Define all handlers at once\n * const handlers = defineHandlers(orderContract, {\n *   processOrder: async (message) => {\n *     // message is fully typed based on the contract\n *     console.log('Processing order:', message.orderId);\n *     await processPayment(message);\n *   },\n *   notifyOrder: async (message) => {\n *     await sendNotification(message);\n *   },\n *   shipOrder: async (message) => {\n *     await prepareShipment(message);\n *   },\n * });\n *\n * // Use the handlers in worker\n * const worker = await TypedAmqpWorker.create({\n *   contract: orderContract,\n *   handlers,\n *   connection: 'amqp://localhost',\n * });\n * ```\n *\n * @example\n * ```typescript\n * // Separate handler definitions for better organization\n * async function handleProcessOrder(message: WorkerInferConsumerInput<typeof orderContract, 'processOrder'>) {\n *   await processOrder(message);\n * }\n *\n * async function handleNotifyOrder(message: WorkerInferConsumerInput<typeof orderContract, 'notifyOrder'>) {\n *   await sendNotification(message);\n * }\n *\n * const handlers = defineHandlers(orderContract, {\n *   processOrder: handleProcessOrder,\n *   notifyOrder: handleNotifyOrder,\n * });\n * ```\n */\nexport function defineHandlers<TContract extends ContractDefinition>(\n  contract: TContract,\n  handlers: WorkerInferConsumerHandlers<TContract>,\n): WorkerInferConsumerHandlers<TContract> {\n  // Validate that all consumers in handlers exist in the contract\n  const consumers = contract.consumers;\n  const availableConsumers = Object.keys(consumers ?? {});\n  const availableConsumerNames =\n    availableConsumers.length > 0 ? availableConsumers.join(\", \") : \"none\";\n\n  for (const handlerName of Object.keys(handlers)) {\n    if (!consumers || !(handlerName in consumers)) {\n      throw new Error(\n        `Consumer \"${handlerName}\" not found in contract. Available consumers: ${availableConsumerNames}`,\n      );\n    }\n  }\n\n  // Return the handlers as-is, with type checking enforced\n  return handlers;\n}\n"],"mappings":";;;;;;;AAGA,IAAe,cAAf,cAAmC,MAAM;CACvC,AAAU,YAAY,SAAiB;AACrC,QAAM,QAAQ;AACd,OAAK,OAAO;EAEZ,MAAM,mBAAmB;AAGzB,MAAI,OAAO,iBAAiB,sBAAsB,WAChD,kBAAiB,kBAAkB,MAAM,KAAK,YAAY;;;;;;;AAShE,IAAa,iBAAb,cAAoC,YAAY;CAC9C,YACE,SACA,AAAyBA,OACzB;AACA,QAAM,QAAQ;EAFW;AAGzB,OAAK,OAAO;;;;;;AAOhB,IAAa,yBAAb,cAA4C,YAAY;CACtD,YACE,AAAgBC,cAChB,AAAgBC,QAChB;AACA,QAAM,2CAA2C,aAAa,GAAG;EAHjD;EACA;AAGhB,OAAK,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACuChB,IAAa,kBAAb,MAAa,gBAAsD;CACjE,AAAQ,YACN,AAAiBC,UACjB,AAAiBC,YACjB,AAAiBC,UACjB;EAHiB;EACA;EACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BnB,OAAO,OAA6C,EAClD,UACA,UACA,MACA,qBAC6F;EAC7F,MAAM,SAAS,IAAI,gBACjB,UACA,IAAI,WAAW,UAAU;GACvB;GACA;GACD,CAAC,EACF,SACD;AACD,SAAO,OAAO,YAAY,CAAC,YAAY,OAAO;;;;;;;;;;;;;;;;;;CAmBhD,QAA8C;AAC5C,SAAO,OAAO,YAAY,KAAK,WAAW,OAAO,CAAC,CAC/C,UAAU,UAAU,IAAI,eAAe,mCAAmC,MAAM,CAAC,CACjF,YAAY,OAAU;;;;;CAM3B,AAAQ,aAAmD;AACzD,MAAI,CAAC,KAAK,SAAS,UACjB,QAAO,OAAO,MAAM,OAAO,MAAM,IAAI,eAAe,mCAAmC,CAAC,CAAC;EAG3F,MAAM,gBAAgB,OAAO,KAAK,KAAK,SAAS,UAAU;AAE1D,SAAO,OAAO,IAAI,cAAc,KAAK,iBAAiB,KAAK,QAAQ,aAAa,CAAC,CAAC,CAC/E,IAAI,OAAO,IAAI,CACf,YAAY,OAAU;;;;;CAM3B,AAAQ,QACN,cACsC;EACtC,MAAM,YAAY,KAAK,SAAS;AAChC,MAAI,CAAC,UACH,QAAO,OAAO,MAAM,OAAO,MAAM,IAAI,eAAe,mCAAmC,CAAC,CAAC;EAG3F,MAAM,WAAW,UAAU;AAC3B,MAAI,CAAC,UAAU;GACb,MAAM,qBAAqB,OAAO,KAAK,UAAU;GACjD,MAAM,YAAY,mBAAmB,SAAS,IAAI,mBAAmB,KAAK,KAAK,GAAG;AAClF,UAAO,OAAO,MACZ,OAAO,MACL,IAAI,eACF,wBAAwB,OAAO,aAAa,CAAC,0BAA0B,YACxE,CACF,CACF;;EAGH,MAAM,UAAU,KAAK,SAAS;AAC9B,MAAI,CAAC,QACH,QAAO,OAAO,MACZ,OAAO,MAAM,IAAI,eAAe,gBAAgB,OAAO,aAAa,CAAC,gBAAgB,CAAC,CACvF;AAIH,SAAO,OAAO,YACZ,KAAK,WAAW,QAAQ,QAAQ,SAAS,MAAM,MAAM,OAAO,QAAQ;GAElE,MAAM,cAAc,OAAO,oBAAoB,KAAK,MAAM,IAAI,QAAQ,UAAU,CAAC,CAAC;AAClF,OAAI,YAAY,SAAS,EAAE;AAGzB,YAAQ,MACN,IAAI,eACF,uCAAuC,OAAO,aAAa,CAAC,IAC5D,YAAY,MACb,CACF;AAID,SAAK,WAAW,QAAQ,KAAK,KAAK,OAAO,MAAM;AAC/C;;GAGF,MAAM,gBAAgB,SAAS,QAAQ,QAAQ,aAAa,SAAS,YAAY,MAAM;AACvF,SAAM,OAAO,YACX,yBAAyB,UAAU,gBAAgB,QAAQ,QAAQ,cAAc,CAClF,CACE,eAAe,qBAAqB;AACnC,QAAI,iBAAiB,OACnB,QAAO,OAAO,MACZ,IAAI,uBAAuB,OAAO,aAAa,EAAE,iBAAiB,OAAO,CAC1E;AAGH,WAAO,OAAO,GAAG,iBAAiB,MAAoD;KACtF,CACD,UAAU,UAAU;AAGnB,YAAQ,MAAM,MAAM;AAIpB,SAAK,WAAW,QAAQ,KAAK,KAAK,OAAO,MAAM;KAC/C,CACD,WAAW,qBACV,OAAO,YAAY,QAAQ,iBAAiB,CAAC,CAAC,UAAU,UAAU;AAGhE,YAAQ,MACN,IAAI,eACF,0CAA0C,OAAO,aAAa,CAAC,IAC/D,MACD,CACF;AAID,SAAK,WAAW,QAAQ,KAAK,KAAK,OAAO,KAAK;KAC9C,CACH,CACA,YAAY;AAEX,SAAK,WAAW,QAAQ,IAAI,IAAI;KAChC,CACD,WAAW;IACd,CACH,CACE,UACE,UACC,IAAI,eAAe,kCAAkC,OAAO,aAAa,CAAC,IAAI,MAAM,CACvF,CACA,YAAY,OAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACnM7B,SAAgB,cAId,UACA,cACA,SAC8C;CAE9C,MAAM,YAAY,SAAS;AAE3B,KAAI,CAAC,aAAa,EAAE,gBAAgB,YAAY;EAC9C,MAAM,qBAAqB,YAAY,OAAO,KAAK,UAAU,GAAG,EAAE;EAClE,MAAM,YAAY,mBAAmB,SAAS,IAAI,mBAAmB,KAAK,KAAK,GAAG;AAClF,QAAM,IAAI,MACR,aAAa,OAAO,aAAa,CAAC,gDAAgD,YACnF;;AAIH,QAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2DT,SAAgB,eACd,UACA,UACwC;CAExC,MAAM,YAAY,SAAS;CAC3B,MAAM,qBAAqB,OAAO,KAAK,aAAa,EAAE,CAAC;CACvD,MAAM,yBACJ,mBAAmB,SAAS,IAAI,mBAAmB,KAAK,KAAK,GAAG;AAElE,MAAK,MAAM,eAAe,OAAO,KAAK,SAAS,CAC7C,KAAI,CAAC,aAAa,EAAE,eAAe,WACjC,OAAM,IAAI,MACR,aAAa,YAAY,gDAAgD,yBAC1E;AAKL,QAAO"}