@amqp-contract/worker 0.1.4 → 0.2.0

package/README.md

@@ -39,6 +39,10 @@ const worker = await TypedAmqpWorker.create({
 // await worker.close();
 ```
 
+## Defining Handlers Externally
+
+You can define handlers outside of the worker creation using `defineHandler` and `defineHandlers` for better code organization. See the [Worker API documentation](https://btravers.github.io/amqp-contract/api/worker) for details.
+
 ## Error Handling
 
 Worker handlers use standard Promise-based async/await pattern:
@@ -70,61 +74,7 @@ These errors are logged but **handlers don't need to use them** - just throw sta
 
 ## API
 
-### `TypedAmqpWorker.create(options)`
-
-Create a type-safe AMQP worker from a contract with message handlers. Automatically connects and starts consuming all messages.
-
-**Parameters:**
-
-- `options.contract` - Contract definition
-- `options.handlers` - Object with async handler functions for each consumer
-- `options.connection` - AMQP connection URL (string) or connection options (Options.Connect)
-
-**Returns:** `Promise<TypedAmqpWorker>`
-
-**Example:**
-
-```typescript
-const worker = await TypedAmqpWorker.create({
-  contract,
-  handlers: {
-    // Each handler receives type-checked message
-    processOrder: async (message) => {
-      // message.orderId is type-checked
-      console.log(message.orderId);
-    },
-    processPayment: async (message) => {
-      // Different message type for this consumer
-      await handlePayment(message);
-    },
-  },
-  connection: {
-    hostname: 'localhost',
-    port: 5672,
-    username: 'guest',
-    password: 'guest',
-  },
-});
-```
-
-### Handler Signature
-
-```typescript
-type Handler<T> = (message: T) => Promise<void>
-```
-
-Handlers are simple async functions that:
-
-- Receive type-checked message as parameter
-- Return `Promise<void>`
-- Can throw exceptions (message will be requeued)
-- Message is acknowledged automatically on success
-
-### `TypedAmqpWorker.close()`
-
-Stop consuming and close the channel and connection.
-
-**Returns:** `Promise<void>`
+See the [Worker API documentation](https://btravers.github.io/amqp-contract/api/worker) for complete API reference.
 
 ## License
 

package/dist/index.cjs

@@ -1,4 +1,5 @@
 let amqplib = require("amqplib");
+let _amqp_contract_core = require("@amqp-contract/core");
 let _swan_io_boxed = require("@swan-io/boxed");
 
 //#region src/errors.ts
@@ -80,22 +81,7 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 	async init() {
 		this.connection = await (0, amqplib.connect)(this.connectionOptions);
 		this.channel = await this.connection.createChannel();
-		if (this.contract.exchanges) for (const exchange of Object.values(this.contract.exchanges)) await this.channel.assertExchange(exchange.name, exchange.type, {
-			durable: exchange.durable,
-			autoDelete: exchange.autoDelete,
-			internal: exchange.internal,
-			arguments: exchange.arguments
-		});
-		if (this.contract.queues) for (const queue of Object.values(this.contract.queues)) await this.channel.assertQueue(queue.name, {
-			durable: queue.durable,
-			exclusive: queue.exclusive,
-			autoDelete: queue.autoDelete,
-			arguments: queue.arguments
-		});
-		if (this.contract.bindings) {
-			for (const binding of Object.values(this.contract.bindings)) if (binding.type === "queue") await this.channel.bindQueue(binding.queue, binding.exchange, binding.routingKey ?? "", binding.arguments);
-			else if (binding.type === "exchange") await this.channel.bindExchange(binding.destination, binding.source, binding.routingKey ?? "", binding.arguments);
-		}
+		await (0, _amqp_contract_core.setupInfra)(this.channel, this.contract);
 	}
 	/**
 	* Start consuming messages for all consumers
@@ -122,7 +108,7 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 		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, async (msg) => {
+		const result = await this.channel.consume(consumerDef.queue.name, async (msg) => {
 			if (!msg) return;
 			const parseResult = _swan_io_boxed.Result.fromExecution(() => JSON.parse(msg.content.toString()));
 			if (parseResult.isError()) {
@@ -131,7 +117,7 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 				return;
 			}
 			const content = parseResult.value;
-			const rawValidation = consumerDef.message["~standard"].validate(content);
+			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 ? _swan_io_boxed.Result.Error(new MessageValidationError(String(consumerName), resolvedValidation.issues)) : _swan_io_boxed.Result.Ok(typeof resolvedValidation === "object" && resolvedValidation !== null && "value" in resolvedValidation ? resolvedValidation.value : content);
 			if (validationResult.isError()) {
@@ -160,7 +146,155 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 	}
 };
 
+//#endregion
+//#region src/handlers.ts
+/**
+* Define a type-safe handler for a specific consumer in a contract.
+*
+* This utility allows you to define handlers outside of the worker creation,
+* providing better code organization and reusability.
+*
+* @template TContract - The contract definition type
+* @template TName - The consumer name from the contract
+* @param contract - The contract definition containing the consumer
+* @param consumerName - The name of the consumer from the contract
+* @param handler - The async handler function that processes messages
+* @returns A type-safe handler that can be used with TypedAmqpWorker
+*
+* @example
+* ```typescript
+* import { defineHandler } from '@amqp-contract/worker';
+* import { orderContract } from './contract';
+*
+* // Define handler outside of worker creation
+* const processOrderHandler = defineHandler(
+*   orderContract,
+*   'processOrder',
+*   async (message) => {
+*     // message is fully typed based on the contract
+*     console.log('Processing order:', message.orderId);
+*     await processPayment(message);
+*   }
+* );
+*
+* // Use the handler in worker
+* const worker = await TypedAmqpWorker.create({
+*   contract: orderContract,
+*   handlers: {
+*     processOrder: processOrderHandler,
+*   },
+*   connection: 'amqp://localhost',
+* });
+* ```
+*
+* @example
+* ```typescript
+* // Define multiple handlers
+* const processOrderHandler = defineHandler(
+*   orderContract,
+*   'processOrder',
+*   async (message) => {
+*     await processOrder(message);
+*   }
+* );
+*
+* const notifyOrderHandler = defineHandler(
+*   orderContract,
+*   'notifyOrder',
+*   async (message) => {
+*     await sendNotification(message);
+*   }
+* );
+*
+* // Compose handlers
+* const worker = await TypedAmqpWorker.create({
+*   contract: orderContract,
+*   handlers: {
+*     processOrder: processOrderHandler,
+*     notifyOrder: notifyOrderHandler,
+*   },
+*   connection: 'amqp://localhost',
+* });
+* ```
+*/
+function defineHandler(contract, consumerName, handler) {
+	const consumers = contract.consumers;
+	if (!consumers || !(consumerName in consumers)) {
+		const availableConsumers = consumers ? Object.keys(consumers) : [];
+		const available = availableConsumers.length > 0 ? availableConsumers.join(", ") : "none";
+		throw new Error(`Consumer "${String(consumerName)}" not found in contract. Available consumers: ${available}`);
+	}
+	return handler;
+}
+/**
+* Define multiple type-safe handlers for consumers in a contract.
+*
+* This utility allows you to define all handlers at once outside of the worker creation,
+* ensuring type safety and providing better code organization.
+*
+* @template TContract - The contract definition type
+* @param contract - The contract definition containing the consumers
+* @param handlers - An object with async handler functions for each consumer
+* @returns A type-safe handlers object that can be used with TypedAmqpWorker
+*
+* @example
+* ```typescript
+* import { defineHandlers } from '@amqp-contract/worker';
+* import { orderContract } from './contract';
+*
+* // Define all handlers at once
+* const handlers = defineHandlers(orderContract, {
+*   processOrder: async (message) => {
+*     // message is fully typed based on the contract
+*     console.log('Processing order:', message.orderId);
+*     await processPayment(message);
+*   },
+*   notifyOrder: async (message) => {
+*     await sendNotification(message);
+*   },
+*   shipOrder: async (message) => {
+*     await prepareShipment(message);
+*   },
+* });
+*
+* // Use the handlers in worker
+* const worker = await TypedAmqpWorker.create({
+*   contract: orderContract,
+*   handlers,
+*   connection: 'amqp://localhost',
+* });
+* ```
+*
+* @example
+* ```typescript
+* // Separate handler definitions for better organization
+* async function handleProcessOrder(message: WorkerInferConsumerInput<typeof orderContract, 'processOrder'>) {
+*   await processOrder(message);
+* }
+*
+* async function handleNotifyOrder(message: WorkerInferConsumerInput<typeof orderContract, 'notifyOrder'>) {
+*   await sendNotification(message);
+* }
+*
+* const handlers = defineHandlers(orderContract, {
+*   processOrder: handleProcessOrder,
+*   notifyOrder: handleNotifyOrder,
+* });
+* ```
+*/
+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}`);
+	}
+	return handlers;
+}
+
 //#endregion
 exports.MessageValidationError = MessageValidationError;
 exports.TechnicalError = TechnicalError;
-exports.TypedAmqpWorker = TypedAmqpWorker;
+exports.TypedAmqpWorker = TypedAmqpWorker;
+exports.defineHandler = defineHandler;
+exports.defineHandlers = defineHandlers;

package/dist/index.d.cts

@@ -1,5 +1,5 @@
 import { Options } from "amqplib";
-import { ContractDefinition, WorkerInferConsumerHandlers } from "@amqp-contract/contract";
+import { ContractDefinition, InferConsumerNames, WorkerInferConsumerHandler, WorkerInferConsumerHandlers } from "@amqp-contract/contract";
 
 //#region src/worker.d.ts
 
@@ -73,5 +73,134 @@ declare class MessageValidationError extends WorkerError {
   constructor(consumerName: string, issues: unknown);
 }
 //#endregion
-export { type CreateWorkerOptions, MessageValidationError, TechnicalError, TypedAmqpWorker };
+//#region src/handlers.d.ts
+/**
+ * Define a type-safe handler for a specific consumer in a contract.
+ *
+ * This utility allows you to define handlers outside of the worker creation,
+ * providing better code organization and reusability.
+ *
+ * @template TContract - The contract definition type
+ * @template TName - The consumer name from the contract
+ * @param contract - The contract definition containing the consumer
+ * @param consumerName - The name of the consumer from the contract
+ * @param handler - The async handler function that processes messages
+ * @returns A type-safe handler that can be used with TypedAmqpWorker
+ *
+ * @example
+ * ```typescript
+ * import { defineHandler } from '@amqp-contract/worker';
+ * import { orderContract } from './contract';
+ *
+ * // Define handler outside of worker creation
+ * const processOrderHandler = defineHandler(
+ *   orderContract,
+ *   'processOrder',
+ *   async (message) => {
+ *     // message is fully typed based on the contract
+ *     console.log('Processing order:', message.orderId);
+ *     await processPayment(message);
+ *   }
+ * );
+ *
+ * // Use the handler in worker
+ * const worker = await TypedAmqpWorker.create({
+ *   contract: orderContract,
+ *   handlers: {
+ *     processOrder: processOrderHandler,
+ *   },
+ *   connection: 'amqp://localhost',
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Define multiple handlers
+ * const processOrderHandler = defineHandler(
+ *   orderContract,
+ *   'processOrder',
+ *   async (message) => {
+ *     await processOrder(message);
+ *   }
+ * );
+ *
+ * const notifyOrderHandler = defineHandler(
+ *   orderContract,
+ *   'notifyOrder',
+ *   async (message) => {
+ *     await sendNotification(message);
+ *   }
+ * );
+ *
+ * // Compose handlers
+ * const worker = await TypedAmqpWorker.create({
+ *   contract: orderContract,
+ *   handlers: {
+ *     processOrder: processOrderHandler,
+ *     notifyOrder: notifyOrderHandler,
+ *   },
+ *   connection: 'amqp://localhost',
+ * });
+ * ```
+ */
+declare function defineHandler<TContract extends ContractDefinition, TName extends InferConsumerNames<TContract>>(contract: TContract, consumerName: TName, handler: WorkerInferConsumerHandler<TContract, TName>): WorkerInferConsumerHandler<TContract, TName>;
+/**
+ * Define multiple type-safe handlers for consumers in a contract.
+ *
+ * This utility allows you to define all handlers at once outside of the worker creation,
+ * ensuring type safety and providing better code organization.
+ *
+ * @template TContract - The contract definition type
+ * @param contract - The contract definition containing the consumers
+ * @param handlers - An object with async handler functions for each consumer
+ * @returns A type-safe handlers object that can be used with TypedAmqpWorker
+ *
+ * @example
+ * ```typescript
+ * import { defineHandlers } from '@amqp-contract/worker';
+ * import { orderContract } from './contract';
+ *
+ * // Define all handlers at once
+ * const handlers = defineHandlers(orderContract, {
+ *   processOrder: async (message) => {
+ *     // message is fully typed based on the contract
+ *     console.log('Processing order:', message.orderId);
+ *     await processPayment(message);
+ *   },
+ *   notifyOrder: async (message) => {
+ *     await sendNotification(message);
+ *   },
+ *   shipOrder: async (message) => {
+ *     await prepareShipment(message);
+ *   },
+ * });
+ *
+ * // Use the handlers in worker
+ * const worker = await TypedAmqpWorker.create({
+ *   contract: orderContract,
+ *   handlers,
+ *   connection: 'amqp://localhost',
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Separate handler definitions for better organization
+ * async function handleProcessOrder(message: WorkerInferConsumerInput<typeof orderContract, 'processOrder'>) {
+ *   await processOrder(message);
+ * }
+ *
+ * async function handleNotifyOrder(message: WorkerInferConsumerInput<typeof orderContract, 'notifyOrder'>) {
+ *   await sendNotification(message);
+ * }
+ *
+ * const handlers = defineHandlers(orderContract, {
+ *   processOrder: handleProcessOrder,
+ *   notifyOrder: handleNotifyOrder,
+ * });
+ * ```
+ */
+declare function defineHandlers<TContract extends ContractDefinition>(contract: TContract, handlers: WorkerInferConsumerHandlers<TContract>): WorkerInferConsumerHandlers<TContract>;
+//#endregion
+export { type CreateWorkerOptions, MessageValidationError, TechnicalError, TypedAmqpWorker, 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.ts","../src/errors.ts"],"sourcesContent":[],"mappings":";;;;;;;AAcA;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;;;;;EC7BX,OAAA,MAAA,CAAA,kBDiB2B,kBCjBO,CAAA,CAAA,OAAA,EDkBlC,mBClBkC,CDkBd,SClBc,CAAA,CAAA,EDmB1C,OCnB0C,CDmBlC,eCnBkC,CDmBlB,SCnBkB,CAAA,CAAA;EAalC;;;WDgBI;;;;;;;;;;;;;;;;;;;;;;;uBC/CF,WAAA,SAAoB,KAAA;EDWlB,UAAA,WAAA,CAAmB,OAAA,EAAA,MAAA;;;;;;AAGE,cCIzB,cAAA,SAAuB,WAAA,CDJE;EAMzB,SAAA,KAAA,CAAA,EAAA,OAAe,GAAA,SAAA;EAAmB,WAAA,CAAA,OAAA,EAAA,MAAA,EAAA,KAAA,CAAA,EAAA,OAAA,GAAA,SAAA;;;;;AAiBlC,cCNA,sBAAA,SAA+B,WAAA,CDM/B;EAAR,SAAA,YAAA,EAAA,MAAA;EAUY,SAAA,MAAA,EAAA,OAAA;EAAO,WAAA,CAAA,YAAA,EAAA,MAAA,EAAA,MAAA,EAAA,OAAA"}
+{"version":3,"file":"index.d.cts","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"}

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 import { Options } from "amqplib";
-import { ContractDefinition, WorkerInferConsumerHandlers } from "@amqp-contract/contract";
+import { ContractDefinition, InferConsumerNames, WorkerInferConsumerHandler, WorkerInferConsumerHandlers } from "@amqp-contract/contract";
 
 //#region src/worker.d.ts
 
@@ -73,5 +73,134 @@ declare class MessageValidationError extends WorkerError {
   constructor(consumerName: string, issues: unknown);
 }
 //#endregion
-export { type CreateWorkerOptions, MessageValidationError, TechnicalError, TypedAmqpWorker };
+//#region src/handlers.d.ts
+/**
+ * Define a type-safe handler for a specific consumer in a contract.
+ *
+ * This utility allows you to define handlers outside of the worker creation,
+ * providing better code organization and reusability.
+ *
+ * @template TContract - The contract definition type
+ * @template TName - The consumer name from the contract
+ * @param contract - The contract definition containing the consumer
+ * @param consumerName - The name of the consumer from the contract
+ * @param handler - The async handler function that processes messages
+ * @returns A type-safe handler that can be used with TypedAmqpWorker
+ *
+ * @example
+ * ```typescript
+ * import { defineHandler } from '@amqp-contract/worker';
+ * import { orderContract } from './contract';
+ *
+ * // Define handler outside of worker creation
+ * const processOrderHandler = defineHandler(
+ *   orderContract,
+ *   'processOrder',
+ *   async (message) => {
+ *     // message is fully typed based on the contract
+ *     console.log('Processing order:', message.orderId);
+ *     await processPayment(message);
+ *   }
+ * );
+ *
+ * // Use the handler in worker
+ * const worker = await TypedAmqpWorker.create({
+ *   contract: orderContract,
+ *   handlers: {
+ *     processOrder: processOrderHandler,
+ *   },
+ *   connection: 'amqp://localhost',
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Define multiple handlers
+ * const processOrderHandler = defineHandler(
+ *   orderContract,
+ *   'processOrder',
+ *   async (message) => {
+ *     await processOrder(message);
+ *   }
+ * );
+ *
+ * const notifyOrderHandler = defineHandler(
+ *   orderContract,
+ *   'notifyOrder',
+ *   async (message) => {
+ *     await sendNotification(message);
+ *   }
+ * );
+ *
+ * // Compose handlers
+ * const worker = await TypedAmqpWorker.create({
+ *   contract: orderContract,
+ *   handlers: {
+ *     processOrder: processOrderHandler,
+ *     notifyOrder: notifyOrderHandler,
+ *   },
+ *   connection: 'amqp://localhost',
+ * });
+ * ```
+ */
+declare function defineHandler<TContract extends ContractDefinition, TName extends InferConsumerNames<TContract>>(contract: TContract, consumerName: TName, handler: WorkerInferConsumerHandler<TContract, TName>): WorkerInferConsumerHandler<TContract, TName>;
+/**
+ * Define multiple type-safe handlers for consumers in a contract.
+ *
+ * This utility allows you to define all handlers at once outside of the worker creation,
+ * ensuring type safety and providing better code organization.
+ *
+ * @template TContract - The contract definition type
+ * @param contract - The contract definition containing the consumers
+ * @param handlers - An object with async handler functions for each consumer
+ * @returns A type-safe handlers object that can be used with TypedAmqpWorker
+ *
+ * @example
+ * ```typescript
+ * import { defineHandlers } from '@amqp-contract/worker';
+ * import { orderContract } from './contract';
+ *
+ * // Define all handlers at once
+ * const handlers = defineHandlers(orderContract, {
+ *   processOrder: async (message) => {
+ *     // message is fully typed based on the contract
+ *     console.log('Processing order:', message.orderId);
+ *     await processPayment(message);
+ *   },
+ *   notifyOrder: async (message) => {
+ *     await sendNotification(message);
+ *   },
+ *   shipOrder: async (message) => {
+ *     await prepareShipment(message);
+ *   },
+ * });
+ *
+ * // Use the handlers in worker
+ * const worker = await TypedAmqpWorker.create({
+ *   contract: orderContract,
+ *   handlers,
+ *   connection: 'amqp://localhost',
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Separate handler definitions for better organization
+ * async function handleProcessOrder(message: WorkerInferConsumerInput<typeof orderContract, 'processOrder'>) {
+ *   await processOrder(message);
+ * }
+ *
+ * async function handleNotifyOrder(message: WorkerInferConsumerInput<typeof orderContract, 'notifyOrder'>) {
+ *   await sendNotification(message);
+ * }
+ *
+ * const handlers = defineHandlers(orderContract, {
+ *   processOrder: handleProcessOrder,
+ *   notifyOrder: handleNotifyOrder,
+ * });
+ * ```
+ */
+declare function defineHandlers<TContract extends ContractDefinition>(contract: TContract, handlers: WorkerInferConsumerHandlers<TContract>): WorkerInferConsumerHandlers<TContract>;
+//#endregion
+export { type CreateWorkerOptions, MessageValidationError, TechnicalError, TypedAmqpWorker, 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"],"sourcesContent":[],"mappings":";;;;;;;AAcA;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;;;;;EC7BX,OAAA,MAAA,CAAA,kBDiB2B,kBCjBO,CAAA,CAAA,OAAA,EDkBlC,mBClBkC,CDkBd,SClBc,CAAA,CAAA,EDmB1C,OCnB0C,CDmBlC,eCnBkC,CDmBlB,SCnBkB,CAAA,CAAA;EAalC;;;WDgBI;;;;;;;;;;;;;;;;;;;;;;;uBC/CF,WAAA,SAAoB,KAAA;EDWlB,UAAA,WAAA,CAAmB,OAAA,EAAA,MAAA;;;;;;AAGE,cCIzB,cAAA,SAAuB,WAAA,CDJE;EAMzB,SAAA,KAAA,CAAA,EAAA,OAAe,GAAA,SAAA;EAAmB,WAAA,CAAA,OAAA,EAAA,MAAA,EAAA,KAAA,CAAA,EAAA,OAAA,GAAA,SAAA;;;;;AAiBlC,cCNA,sBAAA,SAA+B,WAAA,CDM/B;EAAR,SAAA,YAAA,EAAA,MAAA;EAUY,SAAA,MAAA,EAAA,OAAA;EAAO,WAAA,CAAA,YAAA,EAAA,MAAA,EAAA,MAAA,EAAA,OAAA"}
+{"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"}

package/dist/index.mjs

@@ -1,4 +1,5 @@
 import { connect } from "amqplib";
+import { setupInfra } from "@amqp-contract/core";
 import { Result } from "@swan-io/boxed";
 
 //#region src/errors.ts
@@ -80,22 +81,7 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 	async init() {
 		this.connection = await connect(this.connectionOptions);
 		this.channel = await this.connection.createChannel();
-		if (this.contract.exchanges) for (const exchange of Object.values(this.contract.exchanges)) await this.channel.assertExchange(exchange.name, exchange.type, {
-			durable: exchange.durable,
-			autoDelete: exchange.autoDelete,
-			internal: exchange.internal,
-			arguments: exchange.arguments
-		});
-		if (this.contract.queues) for (const queue of Object.values(this.contract.queues)) await this.channel.assertQueue(queue.name, {
-			durable: queue.durable,
-			exclusive: queue.exclusive,
-			autoDelete: queue.autoDelete,
-			arguments: queue.arguments
-		});
-		if (this.contract.bindings) {
-			for (const binding of Object.values(this.contract.bindings)) if (binding.type === "queue") await this.channel.bindQueue(binding.queue, binding.exchange, binding.routingKey ?? "", binding.arguments);
-			else if (binding.type === "exchange") await this.channel.bindExchange(binding.destination, binding.source, binding.routingKey ?? "", binding.arguments);
-		}
+		await setupInfra(this.channel, this.contract);
 	}
 	/**
 	* Start consuming messages for all consumers
@@ -122,7 +108,7 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 		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, async (msg) => {
+		const result = await this.channel.consume(consumerDef.queue.name, async (msg) => {
 			if (!msg) return;
 			const parseResult = Result.fromExecution(() => JSON.parse(msg.content.toString()));
 			if (parseResult.isError()) {
@@ -131,7 +117,7 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 				return;
 			}
 			const content = parseResult.value;
-			const rawValidation = consumerDef.message["~standard"].validate(content);
+			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()) {
@@ -161,5 +147,151 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 };
 
 //#endregion
-export { MessageValidationError, TechnicalError, TypedAmqpWorker };
+//#region src/handlers.ts
+/**
+* Define a type-safe handler for a specific consumer in a contract.
+*
+* This utility allows you to define handlers outside of the worker creation,
+* providing better code organization and reusability.
+*
+* @template TContract - The contract definition type
+* @template TName - The consumer name from the contract
+* @param contract - The contract definition containing the consumer
+* @param consumerName - The name of the consumer from the contract
+* @param handler - The async handler function that processes messages
+* @returns A type-safe handler that can be used with TypedAmqpWorker
+*
+* @example
+* ```typescript
+* import { defineHandler } from '@amqp-contract/worker';
+* import { orderContract } from './contract';
+*
+* // Define handler outside of worker creation
+* const processOrderHandler = defineHandler(
+*   orderContract,
+*   'processOrder',
+*   async (message) => {
+*     // message is fully typed based on the contract
+*     console.log('Processing order:', message.orderId);
+*     await processPayment(message);
+*   }
+* );
+*
+* // Use the handler in worker
+* const worker = await TypedAmqpWorker.create({
+*   contract: orderContract,
+*   handlers: {
+*     processOrder: processOrderHandler,
+*   },
+*   connection: 'amqp://localhost',
+* });
+* ```
+*
+* @example
+* ```typescript
+* // Define multiple handlers
+* const processOrderHandler = defineHandler(
+*   orderContract,
+*   'processOrder',
+*   async (message) => {
+*     await processOrder(message);
+*   }
+* );
+*
+* const notifyOrderHandler = defineHandler(
+*   orderContract,
+*   'notifyOrder',
+*   async (message) => {
+*     await sendNotification(message);
+*   }
+* );
+*
+* // Compose handlers
+* const worker = await TypedAmqpWorker.create({
+*   contract: orderContract,
+*   handlers: {
+*     processOrder: processOrderHandler,
+*     notifyOrder: notifyOrderHandler,
+*   },
+*   connection: 'amqp://localhost',
+* });
+* ```
+*/
+function defineHandler(contract, consumerName, handler) {
+	const consumers = contract.consumers;
+	if (!consumers || !(consumerName in consumers)) {
+		const availableConsumers = consumers ? Object.keys(consumers) : [];
+		const available = availableConsumers.length > 0 ? availableConsumers.join(", ") : "none";
+		throw new Error(`Consumer "${String(consumerName)}" not found in contract. Available consumers: ${available}`);
+	}
+	return handler;
+}
+/**
+* Define multiple type-safe handlers for consumers in a contract.
+*
+* This utility allows you to define all handlers at once outside of the worker creation,
+* ensuring type safety and providing better code organization.
+*
+* @template TContract - The contract definition type
+* @param contract - The contract definition containing the consumers
+* @param handlers - An object with async handler functions for each consumer
+* @returns A type-safe handlers object that can be used with TypedAmqpWorker
+*
+* @example
+* ```typescript
+* import { defineHandlers } from '@amqp-contract/worker';
+* import { orderContract } from './contract';
+*
+* // Define all handlers at once
+* const handlers = defineHandlers(orderContract, {
+*   processOrder: async (message) => {
+*     // message is fully typed based on the contract
+*     console.log('Processing order:', message.orderId);
+*     await processPayment(message);
+*   },
+*   notifyOrder: async (message) => {
+*     await sendNotification(message);
+*   },
+*   shipOrder: async (message) => {
+*     await prepareShipment(message);
+*   },
+* });
+*
+* // Use the handlers in worker
+* const worker = await TypedAmqpWorker.create({
+*   contract: orderContract,
+*   handlers,
+*   connection: 'amqp://localhost',
+* });
+* ```
+*
+* @example
+* ```typescript
+* // Separate handler definitions for better organization
+* async function handleProcessOrder(message: WorkerInferConsumerInput<typeof orderContract, 'processOrder'>) {
+*   await processOrder(message);
+* }
+*
+* async function handleNotifyOrder(message: WorkerInferConsumerInput<typeof orderContract, 'notifyOrder'>) {
+*   await sendNotification(message);
+* }
+*
+* const handlers = defineHandlers(orderContract, {
+*   processOrder: handleProcessOrder,
+*   notifyOrder: handleNotifyOrder,
+* });
+* ```
+*/
+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}`);
+	}
+	return handlers;
+}
+
+//#endregion
+export { MessageValidationError, TechnicalError, TypedAmqpWorker, defineHandler, defineHandlers };
 //# sourceMappingURL=index.mjs.map

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"],"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 { 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\n    if (this.contract.exchanges) {\n      for (const exchange of Object.values(this.contract.exchanges)) {\n        await this.channel.assertExchange(exchange.name, exchange.type, {\n          durable: exchange.durable,\n          autoDelete: exchange.autoDelete,\n          internal: exchange.internal,\n          arguments: exchange.arguments,\n        });\n      }\n    }\n\n    // Setup queues\n    if (this.contract.queues) {\n      for (const queue of Object.values(this.contract.queues)) {\n        await this.channel.assertQueue(queue.name, {\n          durable: queue.durable,\n          exclusive: queue.exclusive,\n          autoDelete: queue.autoDelete,\n          arguments: queue.arguments,\n        });\n      }\n    }\n\n    // Setup bindings\n    if (this.contract.bindings) {\n      for (const binding of Object.values(this.contract.bindings)) {\n        if (binding.type === \"queue\") {\n          await this.channel.bindQueue(\n            binding.queue,\n            binding.exchange,\n            binding.routingKey ?? \"\",\n            binding.arguments,\n          );\n        } else if (binding.type === \"exchange\") {\n          await this.channel.bindExchange(\n            binding.destination,\n            binding.source,\n            binding.routingKey ?? \"\",\n            binding.arguments,\n          );\n        }\n      }\n    }\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: string;\n      message: { \"~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,\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[\"~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"],"mappings":"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"}
+{"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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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amqp-contract/worker",
-  "version": "0.1.4",
+  "version": "0.2.0",
   "description": "Worker utilities for consuming messages using amqp-contract",
   "keywords": [
     "amqp",
@@ -42,7 +42,8 @@
   ],
   "dependencies": {
     "@swan-io/boxed": "3.2.1",
-    "@amqp-contract/contract": "0.1.4"
+    "@amqp-contract/contract": "0.2.0",
+    "@amqp-contract/core": "0.2.0"
   },
   "devDependencies": {
     "@types/amqplib": "0.10.8",
@@ -53,8 +54,8 @@
     "typescript": "5.9.3",
     "vitest": "4.0.16",
     "zod": "4.2.1",
-    "@amqp-contract/client": "0.1.4",
-    "@amqp-contract/testing": "0.1.4",
+    "@amqp-contract/client": "0.2.0",
+    "@amqp-contract/testing": "0.2.0",
     "@amqp-contract/tsconfig": "0.0.0"
   },
   "peerDependencies": {