@amqp-contract/worker 0.6.0 → 0.8.0

package/dist/index.mjs

@@ -1,5 +1,7 @@
 import { AmqpClient } from "@amqp-contract/core";
 import { Future, Result } from "@swan-io/boxed";
+import { gunzip, inflate } from "node:zlib";
+import { promisify } from "node:util";
 
 //#region src/errors.ts
 /**
@@ -35,6 +37,57 @@ var MessageValidationError = class extends WorkerError {
 		this.name = "MessageValidationError";
 	}
 };
+/**
+* Retryable errors - transient failures that may succeed on retry
+* Examples: network timeouts, rate limiting, temporary service unavailability
+*
+* Use this error type when the operation might succeed if retried.
+* The worker will apply exponential backoff and retry the message.
+*/
+var RetryableError = class extends WorkerError {
+	constructor(message, cause) {
+		super(message);
+		this.cause = cause;
+		this.name = "RetryableError";
+	}
+};
+/**
+* Non-retryable errors - permanent failures that should not be retried
+* Examples: invalid data, business rule violations, permanent external failures
+*
+* Use this error type when retrying would not help - the message will be
+* immediately sent to the dead letter queue (DLQ) if configured.
+*/
+var NonRetryableError = class extends WorkerError {
+	constructor(message, cause) {
+		super(message);
+		this.cause = cause;
+		this.name = "NonRetryableError";
+	}
+};
+
+//#endregion
+//#region src/decompression.ts
+const gunzipAsync = promisify(gunzip);
+const inflateAsync = promisify(inflate);
+/**
+* Decompress a buffer based on the content-encoding header.
+*
+* @param buffer - The buffer to decompress
+* @param contentEncoding - The content-encoding header value (e.g., 'gzip', 'deflate')
+* @returns A promise that resolves to the decompressed buffer
+* @throws Error if decompression fails or if the encoding is unsupported
+*
+* @internal
+*/
+async function decompressBuffer(buffer, contentEncoding) {
+	if (!contentEncoding) return buffer;
+	switch (contentEncoding.toLowerCase()) {
+		case "gzip": return gunzipAsync(buffer);
+		case "deflate": return inflateAsync(buffer);
+		default: throw new Error(`Unsupported content-encoding: ${contentEncoding}`);
+	}
+}
 
 //#endregion
 //#region src/worker.ts
@@ -79,22 +132,38 @@ var MessageValidationError = class extends WorkerError {
 * ```
 */
 var TypedAmqpWorker = class TypedAmqpWorker {
+	/**
+	* Internal handler type - always safe handlers (`Future<Result>`).
+	* Unsafe handlers are wrapped into safe handlers by defineUnsafeHandler/defineUnsafeHandlers.
+	*/
 	actualHandlers;
 	consumerOptions;
 	batchTimers = /* @__PURE__ */ new Map();
-	constructor(contract, amqpClient, handlers, logger) {
+	consumerTags = /* @__PURE__ */ new Set();
+	retryConfig;
+	constructor(contract, amqpClient, handlers, logger, retryOptions) {
 		this.contract = contract;
 		this.amqpClient = amqpClient;
 		this.logger = logger;
 		this.actualHandlers = {};
 		this.consumerOptions = {};
-		for (const consumerName of Object.keys(handlers)) {
-			const handlerEntry = handlers[consumerName];
+		const handlersRecord = handlers;
+		for (const consumerName of Object.keys(handlersRecord)) {
+			const handlerEntry = handlersRecord[consumerName];
+			const typedConsumerName = consumerName;
 			if (Array.isArray(handlerEntry)) {
-				this.actualHandlers[consumerName] = handlerEntry[0];
-				this.consumerOptions[consumerName] = handlerEntry[1];
-			} else this.actualHandlers[consumerName] = handlerEntry;
+				this.actualHandlers[typedConsumerName] = handlerEntry[0];
+				this.consumerOptions[typedConsumerName] = handlerEntry[1];
+			} else this.actualHandlers[typedConsumerName] = handlerEntry;
 		}
+		if (retryOptions === void 0) this.retryConfig = null;
+		else this.retryConfig = {
+			maxRetries: retryOptions.maxRetries ?? 3,
+			initialDelayMs: retryOptions.initialDelayMs ?? 1e3,
+			maxDelayMs: retryOptions.maxDelayMs ?? 3e4,
+			backoffMultiplier: retryOptions.backoffMultiplier ?? 2,
+			jitter: retryOptions.jitter ?? true
+		};
 	}
 	/**
 	* Create a type-safe AMQP worker from a contract.
@@ -112,25 +181,21 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 	*
 	* @example
 	* ```typescript
-	* const workerResult = await TypedAmqpWorker.create({
+	* const worker = 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({ contract, handlers, urls, connectionOptions, logger }) {
+	static create({ contract, handlers, urls, connectionOptions, logger, retry }) {
 		const worker = new TypedAmqpWorker(contract, new AmqpClient(contract, {
 			urls,
 			connectionOptions
-		}), handlers, logger);
-		return worker.waitForConnectionReady().flatMapOk(() => worker.consumeAll()).mapOk(() => worker);
+		}), handlers, logger, retry);
+		return worker.waitForConnectionReady().flatMapOk(() => worker.setupWaitQueues()).flatMapOk(() => worker.consumeAll()).mapOk(() => worker);
 	}
 	/**
 	* Close the AMQP channel and connection.
@@ -151,7 +216,51 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 	close() {
 		for (const timer of this.batchTimers.values()) clearTimeout(timer);
 		this.batchTimers.clear();
-		return Future.fromPromise(this.amqpClient.close()).mapError((error) => new TechnicalError("Failed to close AMQP connection", error)).mapOk(() => void 0);
+		return Future.all(Array.from(this.consumerTags).map((consumerTag) => Future.fromPromise(this.amqpClient.channel.cancel(consumerTag)).mapErrorToResult((error) => {
+			this.logger?.warn("Failed to cancel consumer during close", {
+				consumerTag,
+				error
+			});
+			return Result.Ok(void 0);
+		}))).map(Result.all).tapOk(() => {
+			this.consumerTags.clear();
+		}).flatMapOk(() => Future.fromPromise(this.amqpClient.close())).mapError((error) => new TechnicalError("Failed to close AMQP connection", error)).mapOk(() => void 0);
+	}
+	/**
+	* Set up wait queues for retry mechanism.
+	* Creates and binds wait queues for each consumer queue that has DLX configuration.
+	*/
+	setupWaitQueues() {
+		if (this.retryConfig === null) return Future.value(Result.Ok(void 0));
+		if (!this.contract.consumers || !this.contract.queues) return Future.value(Result.Ok(void 0));
+		const setupTasks = [];
+		for (const consumerName of Object.keys(this.contract.consumers)) {
+			const consumer = this.contract.consumers[consumerName];
+			if (!consumer) continue;
+			const queue = consumer.queue;
+			const deadLetter = queue.deadLetter;
+			if (!deadLetter) continue;
+			const queueName = queue.name;
+			const waitQueueName = `${queueName}-wait`;
+			const dlxName = deadLetter.exchange.name;
+			const setupTask = Future.fromPromise(this.amqpClient.channel.addSetup(async (channel) => {
+				await channel.assertQueue(waitQueueName, {
+					durable: queue.durable ?? false,
+					deadLetterExchange: dlxName,
+					deadLetterRoutingKey: queueName
+				});
+				await channel.bindQueue(waitQueueName, dlxName, `${queueName}-wait`);
+				this.logger?.info("Wait queue created and bound", {
+					consumerName: String(consumerName),
+					queueName,
+					waitQueueName,
+					dlxName
+				});
+			})).mapError((error) => new TechnicalError(`Failed to setup wait queue for "${String(consumerName)}"`, error));
+			setupTasks.push(setupTask);
+		}
+		if (setupTasks.length === 0) return Future.value(Result.Ok(void 0));
+		return Future.all(setupTasks).map(Result.all).mapOk(() => void 0);
 	}
 	/**
 	* Start consuming messages for all consumers
@@ -205,33 +314,48 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 	}
 	/**
 	* Parse and validate a message from AMQP
-	* @returns Future<Result<validated message, void>> - Ok with validated message, or Error (already handled with nack)
+	* @returns `Future<Result<validated message, void>>` - Ok with validated message, or Error (already handled with nack)
 	*/
 	parseAndValidateMessage(msg, consumer, consumerName) {
-		const parseResult = Result.fromExecution(() => JSON.parse(msg.content.toString()));
-		if (parseResult.isError()) {
-			this.logger?.error("Error parsing message", {
+		const decompressMessage = Future.fromPromise(decompressBuffer(msg.content, msg.properties.contentEncoding)).tapError((error) => {
+			this.logger?.error("Error decompressing message", {
 				consumerName: String(consumerName),
 				queueName: consumer.queue.name,
-				error: parseResult.error
+				contentEncoding: msg.properties.contentEncoding,
+				error
 			});
 			this.amqpClient.channel.nack(msg, false, false);
-			return Future.value(Result.Error(void 0));
-		}
-		const rawValidation = consumer.message.payload["~standard"].validate(parseResult.value);
-		return Future.fromPromise(rawValidation instanceof Promise ? rawValidation : Promise.resolve(rawValidation)).mapOkToResult((validationResult) => {
-			if (validationResult.issues) {
-				const error = new MessageValidationError(String(consumerName), validationResult.issues);
-				this.logger?.error("Message validation failed", {
+		});
+		const parseMessage = (buffer) => {
+			const parseResult = Result.fromExecution(() => JSON.parse(buffer.toString()));
+			if (parseResult.isError()) {
+				this.logger?.error("Error parsing message", {
 					consumerName: String(consumerName),
 					queueName: consumer.queue.name,
-					error
+					error: parseResult.error
 				});
 				this.amqpClient.channel.nack(msg, false, false);
-				return Result.Error(void 0);
+				return Future.value(Result.Error(void 0));
 			}
-			return Result.Ok(validationResult.value);
-		});
+			return Future.value(Result.Ok(parseResult.value));
+		};
+		const validateMessage = (parsedMessage) => {
+			const rawValidation = consumer.message.payload["~standard"].validate(parsedMessage);
+			return Future.fromPromise(rawValidation instanceof Promise ? rawValidation : Promise.resolve(rawValidation)).mapOkToResult((validationResult) => {
+				if (validationResult.issues) {
+					const error = new MessageValidationError(String(consumerName), validationResult.issues);
+					this.logger?.error("Message validation failed", {
+						consumerName: String(consumerName),
+						queueName: consumer.queue.name,
+						error
+					});
+					this.amqpClient.channel.nack(msg, false, false);
+					return Result.Error(void 0);
+				}
+				return Result.Ok(validationResult.value);
+			});
+		};
+		return decompressMessage.flatMapOk(parseMessage).flatMapOk(validateMessage);
 	}
 	/**
 	* Consume messages one at a time
@@ -245,21 +369,31 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 				});
 				return;
 			}
-			await this.parseAndValidateMessage(msg, consumer, consumerName).flatMapOk((validatedMessage) => Future.fromPromise(handler(validatedMessage)).tapError((error) => {
-				this.logger?.error("Error processing message", {
-					consumerName: String(consumerName),
-					queueName: consumer.queue.name,
-					error
-				});
-				this.amqpClient.channel.nack(msg, false, true);
-			})).tapOk(() => {
+			await this.parseAndValidateMessage(msg, consumer, consumerName).flatMapOk((validatedMessage) => handler(validatedMessage).flatMapOk(() => {
 				this.logger?.info("Message consumed successfully", {
 					consumerName: String(consumerName),
 					queueName: consumer.queue.name
 				});
 				this.amqpClient.channel.ack(msg);
-			}).toPromise();
-		})).mapError((error) => new TechnicalError(`Failed to start consuming for "${String(consumerName)}"`, error)).mapOk(() => void 0);
+				return Future.value(Result.Ok(void 0));
+			}).flatMapError((handlerError) => {
+				this.logger?.error("Error processing message", {
+					consumerName: String(consumerName),
+					queueName: consumer.queue.name,
+					errorType: handlerError.name,
+					error: handlerError.message
+				});
+				return this.handleError(handlerError, msg, String(consumerName), consumer);
+			})).toPromise();
+		})).tapOk((reply) => {
+			this.consumerTags.add(reply.consumerTag);
+		}).mapError((error) => new TechnicalError(`Failed to start consuming for "${String(consumerName)}"`, error)).mapOk(() => void 0);
+	}
+	/**
+	* Handle batch processing error by applying error handling to all messages.
+	*/
+	handleBatchError(error, currentBatch, consumerName, consumer) {
+		return Future.all(currentBatch.map((item) => this.handleError(error, item.amqpMessage, consumerName, consumer))).map(Result.all).mapOk(() => void 0);
 	}
 	/**
 	* Consume messages in batches
@@ -270,8 +404,8 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 		const timerKey = String(consumerName);
 		let batch = [];
 		let isProcessing = false;
-		const processBatch = async () => {
-			if (isProcessing || batch.length === 0) return;
+		const processBatch = () => {
+			if (isProcessing || batch.length === 0) return Future.value(Result.Ok(void 0));
 			isProcessing = true;
 			const currentBatch = batch;
 			batch = [];
@@ -286,37 +420,33 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 				queueName: consumer.queue.name,
 				batchSize: currentBatch.length
 			});
-			try {
-				await handler(messages);
+			return handler(messages).flatMapOk(() => {
 				for (const item of currentBatch) this.amqpClient.channel.ack(item.amqpMessage);
 				this.logger?.info("Batch processed successfully", {
 					consumerName: String(consumerName),
 					queueName: consumer.queue.name,
 					batchSize: currentBatch.length
 				});
-			} catch (error) {
+				return Future.value(Result.Ok(void 0));
+			}).flatMapError((handlerError) => {
 				this.logger?.error("Error processing batch", {
 					consumerName: String(consumerName),
 					queueName: consumer.queue.name,
 					batchSize: currentBatch.length,
-					error
+					errorType: handlerError.name,
+					error: handlerError.message
 				});
-				for (const item of currentBatch) this.amqpClient.channel.nack(item.amqpMessage, false, true);
-			} finally {
+				return this.handleBatchError(handlerError, currentBatch, String(consumerName), consumer);
+			}).tap(() => {
 				isProcessing = false;
-			}
+			});
 		};
 		const scheduleBatchProcessing = () => {
 			if (isProcessing) return;
 			const existingTimer = this.batchTimers.get(timerKey);
 			if (existingTimer) clearTimeout(existingTimer);
 			const timer = setTimeout(() => {
-				processBatch().catch((error) => {
-					this.logger?.error("Unexpected error in batch processing", {
-						consumerName: String(consumerName),
-						error
-					});
-				});
+				processBatch().toPromise();
 			}, batchTimeout);
 			this.batchTimers.set(timerKey, timer);
 		};
@@ -326,7 +456,7 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 					consumerName: String(consumerName),
 					queueName: consumer.queue.name
 				});
-				await processBatch();
+				await processBatch().toPromise();
 				return;
 			}
 			const validationResult = await this.parseAndValidateMessage(msg, consumer, consumerName).toPromise();
@@ -336,89 +466,285 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 				amqpMessage: msg
 			});
 			if (batch.length >= batchSize) {
-				await processBatch();
+				await processBatch().toPromise();
 				if (batch.length > 0 && !this.batchTimers.has(timerKey)) scheduleBatchProcessing();
 			} else if (!this.batchTimers.has(timerKey)) scheduleBatchProcessing();
-		})).mapError((error) => new TechnicalError(`Failed to start consuming for "${String(consumerName)}"`, error)).mapOk(() => void 0);
+		})).tapOk((reply) => {
+			this.consumerTags.add(reply.consumerTag);
+		}).mapError((error) => new TechnicalError(`Failed to start consuming for "${String(consumerName)}"`, error)).mapOk(() => void 0);
+	}
+	/**
+	* Handle error in message processing with retry logic.
+	*
+	* Flow:
+	* 1. If NonRetryableError -> send directly to DLQ (no retry)
+	* 2. If no retry config -> legacy behavior (immediate requeue)
+	* 3. If max retries exceeded -> send to DLQ
+	* 4. Otherwise -> publish to wait queue with TTL for retry
+	*/
+	handleError(error, msg, consumerName, consumer) {
+		if (error instanceof NonRetryableError) {
+			this.logger?.error("Non-retryable error, sending to DLQ immediately", {
+				consumerName,
+				errorType: error.name,
+				error: error.message
+			});
+			this.sendToDLQ(msg, consumer);
+			return Future.value(Result.Ok(void 0));
+		}
+		if (this.retryConfig === null) {
+			this.logger?.warn("Error in handler (legacy mode: immediate requeue)", {
+				consumerName,
+				error: error.message
+			});
+			this.amqpClient.channel.nack(msg, false, true);
+			return Future.value(Result.Ok(void 0));
+		}
+		const retryCount = msg.properties.headers?.["x-retry-count"] ?? 0;
+		const config = this.retryConfig;
+		if (retryCount >= config.maxRetries) {
+			this.logger?.error("Max retries exceeded, sending to DLQ", {
+				consumerName,
+				retryCount,
+				maxRetries: config.maxRetries,
+				error: error.message
+			});
+			this.sendToDLQ(msg, consumer);
+			return Future.value(Result.Ok(void 0));
+		}
+		const delayMs = this.calculateRetryDelay(retryCount);
+		this.logger?.warn("Retrying message", {
+			consumerName,
+			retryCount: retryCount + 1,
+			delayMs,
+			error: error.message
+		});
+		return this.publishForRetry(msg, consumer, retryCount + 1, delayMs, error);
+	}
+	/**
+	* Calculate retry delay with exponential backoff and optional jitter.
+	*/
+	calculateRetryDelay(retryCount) {
+		const { initialDelayMs, maxDelayMs, backoffMultiplier, jitter } = this.retryConfig;
+		let delay = Math.min(initialDelayMs * Math.pow(backoffMultiplier, retryCount), maxDelayMs);
+		if (jitter) delay = delay * (.5 + Math.random() * .5);
+		return Math.floor(delay);
+	}
+	/**
+	* Parse message content for republishing.
+	* Prevents double JSON serialization by converting Buffer to object when possible.
+	*/
+	parseMessageContentForRetry(msg, queueName) {
+		let content = msg.content;
+		if (!msg.properties.contentEncoding) try {
+			content = JSON.parse(msg.content.toString());
+		} catch (err) {
+			this.logger?.warn("Failed to parse message for retry, using original buffer", {
+				queueName,
+				error: err
+			});
+		}
+		return content;
+	}
+	/**
+	* Publish message to wait queue for retry after TTL expires.
+	*
+	* ┌─────────────────────────────────────────────────────────────────┐
+	* │ Retry Flow (Native RabbitMQ TTL + DLX Pattern)                   │
+	* ├─────────────────────────────────────────────────────────────────┤
+	* │                                                                   │
+	* │ 1. Handler throws any Error                                      │
+	* │    ↓                                                              │
+	* │ 2. Worker publishes to DLX with routing key: {queue}-wait        │
+	* │    ↓                                                              │
+	* │ 3. DLX routes to wait queue: {queue}-wait                        │
+	* │    (with expiration: calculated backoff delay)                   │
+	* │    ↓                                                              │
+	* │ 4. Message waits in queue until TTL expires                      │
+	* │    ↓                                                              │
+	* │ 5. Expired message dead-lettered to DLX                          │
+	* │    (with routing key: {queue})                                   │
+	* │    ↓                                                              │
+	* │ 6. DLX routes back to main queue → RETRY                         │
+	* │    ↓                                                              │
+	* │ 7. If retries exhausted: nack without requeue → DLQ              │
+	* │                                                                   │
+	* └─────────────────────────────────────────────────────────────────┘
+	*/
+	publishForRetry(msg, consumer, newRetryCount, delayMs, error) {
+		const queueName = consumer.queue.name;
+		const deadLetter = consumer.queue.deadLetter;
+		if (!deadLetter) {
+			this.logger?.warn("Cannot retry: queue does not have DLX configured, falling back to nack with requeue", { queueName });
+			this.amqpClient.channel.nack(msg, false, true);
+			return Future.value(Result.Ok(void 0));
+		}
+		const dlxName = deadLetter.exchange.name;
+		const waitRoutingKey = `${queueName}-wait`;
+		this.amqpClient.channel.ack(msg);
+		const content = this.parseMessageContentForRetry(msg, queueName);
+		return Future.fromPromise(this.amqpClient.channel.publish(dlxName, waitRoutingKey, content, {
+			...msg.properties,
+			expiration: delayMs.toString(),
+			headers: {
+				...msg.properties.headers,
+				"x-retry-count": newRetryCount,
+				"x-last-error": error.message,
+				"x-first-failure-timestamp": msg.properties.headers?.["x-first-failure-timestamp"] ?? Date.now()
+			}
+		})).mapError((error$1) => new TechnicalError("Failed to publish message for retry", error$1)).mapOkToResult((published) => {
+			if (!published) {
+				this.logger?.error("Failed to publish message for retry (write buffer full)", {
+					queueName,
+					waitRoutingKey,
+					retryCount: newRetryCount
+				});
+				return Result.Error(new TechnicalError("Failed to publish message for retry (write buffer full)"));
+			}
+			this.logger?.info("Message published for retry", {
+				queueName,
+				waitRoutingKey,
+				retryCount: newRetryCount,
+				delayMs
+			});
+			return Result.Ok(void 0);
+		});
+	}
+	/**
+	* Send message to dead letter queue.
+	* Nacks the message without requeue, relying on DLX configuration.
+	*/
+	sendToDLQ(msg, consumer) {
+		const queueName = consumer.queue.name;
+		if (!(consumer.queue.deadLetter !== void 0)) this.logger?.warn("Queue does not have DLX configured - message will be lost on nack", { queueName });
+		this.logger?.info("Sending message to DLQ", {
+			queueName,
+			deliveryTag: msg.fields.deliveryTag
+		});
+		this.amqpClient.channel.nack(msg, false, false);
 	}
 };
 
 //#endregion
 //#region src/handlers.ts
-function defineHandler(contract, consumerName, handler, options) {
+/**
+* Validate that a consumer exists in the contract
+*/
+function validateConsumerExists(contract, consumerName) {
 	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}`);
+		throw new Error(`Consumer "${consumerName}" not found in contract. Available consumers: ${available}`);
 	}
+}
+/**
+* Validate that all handlers reference valid consumers
+*/
+function validateHandlers(contract, handlers) {
+	const consumers = contract.consumers;
+	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}`);
+}
+/**
+* Wrap a Promise-based handler into a Future-based safe handler.
+* This is used internally by defineUnsafeHandler to convert Promise handlers to Future handlers.
+*/
+function wrapUnsafeHandler(handler) {
+	return (input) => {
+		return Future.fromPromise(handler(input)).mapOkToResult(() => Result.Ok(void 0)).flatMapError((error) => {
+			if (error instanceof NonRetryableError || error instanceof RetryableError) return Future.value(Result.Error(error));
+			const retryableError = new RetryableError(error instanceof Error ? error.message : String(error), error);
+			return Future.value(Result.Error(retryableError));
+		});
+	};
+}
+function defineHandler(contract, consumerName, handler, options) {
+	validateConsumerExists(contract, String(consumerName));
 	if (options) return [handler, options];
 	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.
+* **Recommended:** This function creates handlers that return `Future<Result<void, HandlerError>>`,
+* providing explicit error handling and better control over retry behavior.
 *
 * @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
+* @param handlers - An object with 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 { defineHandlers, RetryableError } from '@amqp-contract/worker';
+* import { Future } from '@swan-io/boxed';
 * 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',
+*   processOrder: (message) =>
+*     Future.fromPromise(processPayment(message))
+*       .mapOk(() => undefined)
+*       .mapError((error) => new RetryableError('Payment failed', error)),
+*   notifyOrder: (message) =>
+*     Future.fromPromise(sendNotification(message))
+*       .mapOk(() => undefined)
+*       .mapError((error) => new RetryableError('Notification failed', error)),
 * });
 * ```
+*/
+function defineHandlers(contract, handlers) {
+	validateHandlers(contract, handlers);
+	return handlers;
+}
+function defineUnsafeHandler(contract, consumerName, handler, options) {
+	validateConsumerExists(contract, String(consumerName));
+	const wrappedHandler = wrapUnsafeHandler(handler);
+	if (options) return [wrappedHandler, options];
+	return wrappedHandler;
+}
+/**
+* Define multiple unsafe handlers for consumers in a contract.
+*
+* @deprecated Use `defineHandlers` instead for explicit error handling with `Future<Result>`.
+*
+* **Warning:** Unsafe handlers use exception-based error handling.
+* Consider migrating to safe handlers for better error control.
+*
+* **Note:** Internally, this function wraps all Promise-based handlers into Future-based
+* safe handlers for consistent processing in the worker.
+*
+* @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
-* // 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);
-* }
+* import { defineUnsafeHandlers } from '@amqp-contract/worker';
 *
-* const handlers = defineHandlers(orderContract, {
-*   processOrder: handleProcessOrder,
-*   notifyOrder: handleNotifyOrder,
+* // ⚠️ Consider using defineHandlers for better error handling
+* const handlers = defineUnsafeHandlers(orderContract, {
+*   processOrder: async (message) => {
+*     await processPayment(message);
+*   },
+*   notifyOrder: async (message) => {
+*     await sendNotification(message);
+*   },
 * });
 * ```
 */
-function defineHandlers(contract, handlers) {
-	const consumers = contract.consumers;
-	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;
+function defineUnsafeHandlers(contract, handlers) {
+	validateHandlers(contract, handlers);
+	const result = {};
+	for (const [name, entry] of Object.entries(handlers)) if (Array.isArray(entry)) {
+		const [handler, options] = entry;
+		result[name] = [wrapUnsafeHandler(handler), options];
+	} else result[name] = wrapUnsafeHandler(entry);
+	return result;
 }
 
 //#endregion
-export { MessageValidationError, TechnicalError, TypedAmqpWorker, defineHandler, defineHandlers };
+export { MessageValidationError, NonRetryableError, RetryableError, TechnicalError, TypedAmqpWorker, defineHandler, defineHandlers, defineUnsafeHandler, defineUnsafeHandlers };
 //# sourceMappingURL=index.mjs.map