@amqp-contract/worker 0.4.0 → 0.6.0

package/dist/index.d.mts

@@ -50,13 +50,38 @@ type InferConsumer<TContract extends ContractDefinition, TName extends InferCons
  */
 type WorkerInferConsumerInput<TContract extends ContractDefinition, TName extends InferConsumerNames<TContract>> = ConsumerInferInput<InferConsumer<TContract, TName>>;
 /**
- * Infer consumer handler type for a specific consumer
+ * Infer consumer handler type for a specific consumer.
+ * Handlers always receive a single message by default.
+ * For batch processing, use consumerOptions to configure batch behavior.
  */
 type WorkerInferConsumerHandler<TContract extends ContractDefinition, TName extends InferConsumerNames<TContract>> = (message: WorkerInferConsumerInput<TContract, TName>) => Promise<void>;
 /**
- * Infer all consumer handlers for a contract
+ * Infer consumer handler type for batch processing.
+ * Batch handlers receive an array of messages.
  */
-type WorkerInferConsumerHandlers<TContract extends ContractDefinition> = { [K in InferConsumerNames<TContract>]: WorkerInferConsumerHandler<TContract, K> };
+type WorkerInferConsumerBatchHandler<TContract extends ContractDefinition, TName extends InferConsumerNames<TContract>> = (messages: Array<WorkerInferConsumerInput<TContract, TName>>) => Promise<void>;
+/**
+ * Infer handler entry for a consumer - either a function or a tuple of [handler, options].
+ *
+ * Three patterns are supported:
+ * 1. Simple handler: `async (message) => { ... }`
+ * 2. Handler with prefetch: `[async (message) => { ... }, { prefetch: 10 }]`
+ * 3. Batch handler: `[async (messages) => { ... }, { batchSize: 5, batchTimeout: 1000 }]`
+ */
+type WorkerInferConsumerHandlerEntry<TContract extends ContractDefinition, TName extends InferConsumerNames<TContract>> = WorkerInferConsumerHandler<TContract, TName> | readonly [WorkerInferConsumerHandler<TContract, TName>, {
+  prefetch?: number;
+  batchSize?: never;
+  batchTimeout?: never;
+}] | readonly [WorkerInferConsumerBatchHandler<TContract, TName>, {
+  prefetch?: number;
+  batchSize: number;
+  batchTimeout?: number;
+}];
+/**
+ * Infer all consumer handlers for a contract.
+ * Handlers can be either single-message handlers, batch handlers, or a tuple of [handler, options].
+ */
+type WorkerInferConsumerHandlers<TContract extends ContractDefinition> = { [K in InferConsumerNames<TContract>]: WorkerInferConsumerHandlerEntry<TContract, K> };
 //#endregion
 //#region src/worker.d.ts
 /**
@@ -69,9 +94,24 @@ type WorkerInferConsumerHandlers<TContract extends ContractDefinition> = { [K in
  * const options: CreateWorkerOptions<typeof contract> = {
  *   contract: myContract,
  *   handlers: {
+ *     // Simple handler
  *     processOrder: async (message) => {
  *       console.log('Processing order:', message.orderId);
- *     }
+ *     },
+ *     // Handler with options (prefetch)
+ *     processPayment: [
+ *       async (message) => {
+ *         console.log('Processing payment:', message.paymentId);
+ *       },
+ *       { prefetch: 10 }
+ *     ],
+ *     // Handler with batch processing
+ *     processNotifications: [
+ *       async (messages) => {
+ *         console.log('Processing batch:', messages.length);
+ *       },
+ *       { batchSize: 5, batchTimeout: 1000 }
+ *     ]
  *   },
  *   urls: ['amqp://localhost'],
  *   connectionOptions: {
@@ -84,7 +124,7 @@ type WorkerInferConsumerHandlers<TContract extends ContractDefinition> = { [K in
 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 for each consumer defined in the contract. Can be a function or a tuple of [handler, options] */
   handlers: WorkerInferConsumerHandlers<TContract>;
   /** AMQP broker URL(s). Multiple URLs provide failover support */
   urls: ConnectionUrl[];
@@ -136,8 +176,10 @@ type CreateWorkerOptions<TContract extends ContractDefinition> = {
 declare class TypedAmqpWorker<TContract extends ContractDefinition> {
   private readonly contract;
   private readonly amqpClient;
-  private readonly handlers;
   private readonly logger?;
+  private readonly actualHandlers;
+  private readonly consumerOptions;
+  private readonly batchTimers;
   private constructor();
   /**
    * Create a type-safe AMQP worker from a contract.
@@ -201,6 +243,19 @@ declare class TypedAmqpWorker<TContract extends ContractDefinition> {
    * Start consuming messages for a specific consumer
    */
   private consume;
+  /**
+   * Parse and validate a message from AMQP
+   * @returns Future<Result<validated message, void>> - Ok with validated message, or Error (already handled with nack)
+   */
+  private parseAndValidateMessage;
+  /**
+   * Consume messages one at a time
+   */
+  private consumeSingle;
+  /**
+   * Consume messages in batches
+   */
+  private consumeBatch;
 }
 //#endregion
 //#region src/handlers.d.ts
@@ -210,11 +265,22 @@ declare class TypedAmqpWorker<TContract extends ContractDefinition> {
  * This utility allows you to define handlers outside of the worker creation,
  * providing better code organization and reusability.
  *
+ * Supports three patterns:
+ * 1. Simple handler: just the function (single message handler)
+ * 2. Handler with prefetch: [handler, { prefetch: 10 }] (single message handler with config)
+ * 3. Batch handler: [batchHandler, { batchSize: 5, batchTimeout: 1000 }] (REQUIRES batchSize config)
+ *
+ * **Important**: Batch handlers (handlers that accept an array of messages) MUST include
+ * batchSize configuration. You cannot create a batch handler without specifying batchSize.
+ *
  * @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
+ * @param handler - The async handler function that processes messages (single or batch)
+ * @param options - Optional consumer options (prefetch, batchSize, batchTimeout)
+ *   - For single-message handlers: { prefetch?: number } is optional
+ *   - For batch handlers: { batchSize: number, batchTimeout?: number } is REQUIRED
  * @returns A type-safe handler that can be used with TypedAmqpWorker
  *
  * @example
@@ -222,58 +288,49 @@ declare class TypedAmqpWorker<TContract extends ContractDefinition> {
  * import { defineHandler } from '@amqp-contract/worker';
  * import { orderContract } from './contract';
  *
- * // Define handler outside of worker creation
+ * // Simple single-message handler without options
  * 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(
+ * // Single-message handler with prefetch
+ * const processOrderWithPrefetch = defineHandler(
  *   orderContract,
  *   'processOrder',
  *   async (message) => {
  *     await processOrder(message);
- *   }
+ *   },
+ *   { prefetch: 10 }
  * );
  *
- * const notifyOrderHandler = defineHandler(
+ * // Batch handler - MUST include batchSize
+ * const processBatchOrders = defineHandler(
  *   orderContract,
- *   'notifyOrder',
- *   async (message) => {
- *     await sendNotification(message);
- *   }
- * );
- *
- * // Compose handlers
- * const worker = await TypedAmqpWorker.create({
- *   contract: orderContract,
- *   handlers: {
- *     processOrder: processOrderHandler,
- *     notifyOrder: notifyOrderHandler,
+ *   'processOrders',
+ *   async (messages) => {
+ *     // messages is an array - batchSize configuration is REQUIRED
+ *     await db.insertMany(messages);
  *   },
- *   connection: 'amqp://localhost',
- * });
+ *   { batchSize: 5, batchTimeout: 1000 }
+ * );
  * ```
  */
-declare function defineHandler<TContract extends ContractDefinition, TName extends InferConsumerNames<TContract>>(contract: TContract, consumerName: TName, handler: WorkerInferConsumerHandler<TContract, TName>): WorkerInferConsumerHandler<TContract, TName>;
+declare function defineHandler<TContract extends ContractDefinition, TName extends InferConsumerNames<TContract>>(contract: TContract, consumerName: TName, handler: WorkerInferConsumerHandler<TContract, TName>): WorkerInferConsumerHandlerEntry<TContract, TName>;
+declare function defineHandler<TContract extends ContractDefinition, TName extends InferConsumerNames<TContract>>(contract: TContract, consumerName: TName, handler: WorkerInferConsumerHandler<TContract, TName>, options: {
+  prefetch?: number;
+  batchSize?: never;
+  batchTimeout?: never;
+}): WorkerInferConsumerHandlerEntry<TContract, TName>;
+declare function defineHandler<TContract extends ContractDefinition, TName extends InferConsumerNames<TContract>>(contract: TContract, consumerName: TName, handler: WorkerInferConsumerBatchHandler<TContract, TName>, options: {
+  prefetch?: number;
+  batchSize: number;
+  batchTimeout?: number;
+}): WorkerInferConsumerHandlerEntry<TContract, TName>;
 /**
  * Define multiple type-safe handlers for consumers in a contract.
  *
@@ -332,5 +389,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, type WorkerInferConsumerHandler, type WorkerInferConsumerHandlers, type WorkerInferConsumerInput, defineHandler, defineHandlers };
+export { type CreateWorkerOptions, MessageValidationError, TechnicalError, TypedAmqpWorker, type WorkerInferConsumerBatchHandler, type WorkerInferConsumerHandler, type WorkerInferConsumerHandlerEntry, 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/errors.ts","../src/types.ts","../src/worker.ts","../src/handlers.ts"],"sourcesContent":[],"mappings":"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"}
+{"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

@@ -79,11 +79,22 @@ var MessageValidationError = class extends WorkerError {
 * ```
 */
 var TypedAmqpWorker = class TypedAmqpWorker {
+	actualHandlers;
+	consumerOptions;
+	batchTimers = /* @__PURE__ */ new Map();
 	constructor(contract, amqpClient, handlers, logger) {
 		this.contract = contract;
 		this.amqpClient = amqpClient;
-		this.handlers = handlers;
 		this.logger = logger;
+		this.actualHandlers = {};
+		this.consumerOptions = {};
+		for (const consumerName of Object.keys(handlers)) {
+			const handlerEntry = handlers[consumerName];
+			if (Array.isArray(handlerEntry)) {
+				this.actualHandlers[consumerName] = handlerEntry[0];
+				this.consumerOptions[consumerName] = handlerEntry[1];
+			} else this.actualHandlers[consumerName] = handlerEntry;
+		}
 	}
 	/**
 	* Create a type-safe AMQP worker from a contract.
@@ -138,6 +149,8 @@ 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);
 	}
 	/**
@@ -146,6 +159,21 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 	consumeAll() {
 		if (!this.contract.consumers) return Future.value(Result.Error(new TechnicalError("No consumers defined in contract")));
 		const consumerNames = Object.keys(this.contract.consumers);
+		let maxPrefetch = 0;
+		for (const consumerName of consumerNames) {
+			const options = this.consumerOptions[consumerName];
+			if (options?.prefetch !== void 0) {
+				if (options.prefetch <= 0 || !Number.isInteger(options.prefetch)) return Future.value(Result.Error(new TechnicalError(`Invalid prefetch value for "${String(consumerName)}": must be a positive integer`)));
+				maxPrefetch = Math.max(maxPrefetch, options.prefetch);
+			}
+			if (options?.batchSize !== void 0) {
+				const effectivePrefetch = options.prefetch ?? options.batchSize;
+				maxPrefetch = Math.max(maxPrefetch, effectivePrefetch);
+			}
+		}
+		if (maxPrefetch > 0) this.amqpClient.channel.addSetup(async (channel) => {
+			await channel.prefetch(maxPrefetch);
+		});
 		return Future.all(consumerNames.map((consumerName) => this.consume(consumerName))).map(Result.all).mapOk(() => void 0);
 	}
 	waitForConnectionReady() {
@@ -163,31 +191,61 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 			const available = availableConsumers.length > 0 ? availableConsumers.join(", ") : "none";
 			return Future.value(Result.Error(new TechnicalError(`Consumer not found: "${String(consumerName)}". Available consumers: ${available}`)));
 		}
-		const handler = this.handlers[consumerName];
+		const handler = this.actualHandlers[consumerName];
 		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()) {
-				this.logger?.error("Error parsing message", {
+		const options = this.consumerOptions[consumerName] ?? {};
+		if (options.batchSize !== void 0) {
+			if (options.batchSize <= 0 || !Number.isInteger(options.batchSize)) return Future.value(Result.Error(new TechnicalError(`Invalid batchSize for "${String(consumerName)}": must be a positive integer`)));
+		}
+		if (options.batchTimeout !== void 0) {
+			if (typeof options.batchTimeout !== "number" || !Number.isFinite(options.batchTimeout) || options.batchTimeout <= 0) return Future.value(Result.Error(new TechnicalError(`Invalid batchTimeout for "${String(consumerName)}": must be a positive number`)));
+		}
+		if (options.batchSize !== void 0 && options.batchSize > 0) return this.consumeBatch(consumerName, consumer, options, handler);
+		else return this.consumeSingle(consumerName, consumer, handler);
+	}
+	/**
+	* Parse and validate a message from AMQP
+	* @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", {
+				consumerName: String(consumerName),
+				queueName: consumer.queue.name,
+				error: parseResult.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", {
 					consumerName: String(consumerName),
 					queueName: consumer.queue.name,
-					error: parseResult.error
+					error
 				});
 				this.amqpClient.channel.nack(msg, false, false);
-				return;
+				return Result.Error(void 0);
 			}
-			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) => {
-				this.logger?.error("Message validation failed", {
+			return Result.Ok(validationResult.value);
+		});
+	}
+	/**
+	* Consume messages one at a time
+	*/
+	consumeSingle(consumerName, consumer, handler) {
+		return Future.fromPromise(this.amqpClient.channel.consume(consumer.queue.name, async (msg) => {
+			if (msg === null) {
+				this.logger?.warn("Consumer cancelled by server", {
 					consumerName: String(consumerName),
-					queueName: consumer.queue.name,
-					error
+					queueName: consumer.queue.name
 				});
-				this.amqpClient.channel.nack(msg, false, false);
-			}).flatMapOk((validatedMessage) => Future.fromPromise(handler(validatedMessage)).tapError((error) => {
+				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,
@@ -203,86 +261,98 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 			}).toPromise();
 		})).mapError((error) => new TechnicalError(`Failed to start consuming for "${String(consumerName)}"`, error)).mapOk(() => void 0);
 	}
+	/**
+	* Consume messages in batches
+	*/
+	consumeBatch(consumerName, consumer, options, handler) {
+		const batchSize = options.batchSize;
+		const batchTimeout = options.batchTimeout ?? 1e3;
+		const timerKey = String(consumerName);
+		let batch = [];
+		let isProcessing = false;
+		const processBatch = async () => {
+			if (isProcessing || batch.length === 0) return;
+			isProcessing = true;
+			const currentBatch = batch;
+			batch = [];
+			const timer = this.batchTimers.get(timerKey);
+			if (timer) {
+				clearTimeout(timer);
+				this.batchTimers.delete(timerKey);
+			}
+			const messages = currentBatch.map((item) => item.message);
+			this.logger?.info("Processing batch", {
+				consumerName: String(consumerName),
+				queueName: consumer.queue.name,
+				batchSize: currentBatch.length
+			});
+			try {
+				await handler(messages);
+				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) {
+				this.logger?.error("Error processing batch", {
+					consumerName: String(consumerName),
+					queueName: consumer.queue.name,
+					batchSize: currentBatch.length,
+					error
+				});
+				for (const item of currentBatch) this.amqpClient.channel.nack(item.amqpMessage, false, true);
+			} finally {
+				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
+					});
+				});
+			}, batchTimeout);
+			this.batchTimers.set(timerKey, timer);
+		};
+		return Future.fromPromise(this.amqpClient.channel.consume(consumer.queue.name, async (msg) => {
+			if (msg === null) {
+				this.logger?.warn("Consumer cancelled by server", {
+					consumerName: String(consumerName),
+					queueName: consumer.queue.name
+				});
+				await processBatch();
+				return;
+			}
+			const validationResult = await this.parseAndValidateMessage(msg, consumer, consumerName).toPromise();
+			if (validationResult.isError()) return;
+			batch.push({
+				message: validationResult.value,
+				amqpMessage: msg
+			});
+			if (batch.length >= batchSize) {
+				await processBatch();
+				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);
+	}
 };
 
 //#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) {
+function defineHandler(contract, consumerName, handler, options) {
 	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}`);
 	}
+	if (options) return [handler, options];
 	return handler;
 }
 /**