@amqp-contract/worker 0.1.4 → 0.2.1

package/dist/index.mjs

@@ -1,5 +1,5 @@
-import { connect } from "amqplib";
-import { Result } from "@swan-io/boxed";
+import { AmqpClient } from "@amqp-contract/core";
+import { Future, Result } from "@swan-io/boxed";
 
 //#region src/errors.ts
 /**
@@ -39,127 +39,293 @@ var MessageValidationError = class extends WorkerError {
 //#endregion
 //#region src/worker.ts
 /**
-* Type-safe AMQP worker for consuming messages
+* Type-safe AMQP worker for consuming messages from RabbitMQ.
+*
+* This class provides automatic message validation, connection management,
+* and error handling for consuming messages based on a contract definition.
+*
+* @typeParam TContract - The contract definition type
+*
+* @example
+* ```typescript
+* import { TypedAmqpWorker } from '@amqp-contract/worker';
+* import { z } from 'zod';
+*
+* const contract = defineContract({
+*   queues: {
+*     orderProcessing: defineQueue('order-processing', { durable: true })
+*   },
+*   consumers: {
+*     processOrder: defineConsumer('order-processing', z.object({
+*       orderId: z.string(),
+*       amount: z.number()
+*     }))
+*   }
+* });
+*
+* const worker = await TypedAmqpWorker.create({
+*   contract,
+*   handlers: {
+*     processOrder: async (message) => {
+*       console.log('Processing order', message.orderId);
+*       // Process the order...
+*     }
+*   },
+*   urls: ['amqp://localhost']
+* }).resultToPromise();
+*
+* // Close when done
+* await worker.close().resultToPromise();
+* ```
 */
 var TypedAmqpWorker = class TypedAmqpWorker {
-	channel = null;
-	connection = null;
-	consumerTags = [];
-	constructor(contract, handlers, connectionOptions) {
+	constructor(contract, amqpClient, handlers) {
 		this.contract = contract;
+		this.amqpClient = amqpClient;
 		this.handlers = handlers;
-		this.connectionOptions = connectionOptions;
 	}
 	/**
-	* Create a type-safe AMQP worker from a contract
-	* The worker will automatically connect and start consuming all messages
+	* Create a type-safe AMQP worker from a contract.
+	*
+	* Connection management (including automatic reconnection) is handled internally
+	* by amqp-connection-manager via the {@link AmqpClient}. The worker will set up
+	* consumers for all contract-defined handlers asynchronously in the background
+	* once the underlying connection and channels are ready.
+	*
+	* @param options - Configuration options for the worker
+	* @returns A Future that resolves to a Result containing the worker or an error
+	*
+	* @example
+	* ```typescript
+	* const workerResult = await TypedAmqpWorker.create({
+	*   contract: myContract,
+	*   handlers: {
+	*     processOrder: async (msg) => console.log('Order:', msg.orderId)
+	*   },
+	*   urls: ['amqp://localhost']
+	* }).resultToPromise();
+	*
+	* if (workerResult.isError()) {
+	*   console.error('Failed to create worker:', workerResult.error);
+	* }
+	* ```
 	*/
-	static async create(options) {
-		const worker = new TypedAmqpWorker(options.contract, options.handlers, options.connection);
-		await worker.init();
-		await worker.consumeAll();
-		return worker;
+	static create({ contract, handlers, urls, connectionOptions }) {
+		const worker = new TypedAmqpWorker(contract, new AmqpClient(contract, {
+			urls,
+			connectionOptions
+		}), handlers);
+		return worker.consumeAll().mapOk(() => worker);
 	}
 	/**
-	* Close the connection
+	* Close the AMQP channel and connection.
+	*
+	* This gracefully closes the connection to the AMQP broker,
+	* stopping all message consumption and cleaning up resources.
+	*
+	* @returns A Future that resolves to a Result indicating success or failure
+	*
+	* @example
+	* ```typescript
+	* const closeResult = await worker.close().resultToPromise();
+	* if (closeResult.isOk()) {
+	*   console.log('Worker closed successfully');
+	* }
+	* ```
 	*/
-	async close() {
-		await this.stopConsuming();
-		if (this.channel) {
-			await this.channel.close();
-			this.channel = null;
-		}
-		if (this.connection) {
-			await this.connection.close();
-			this.connection = null;
-		}
-	}
-	/**
-	* Connect to AMQP broker
-	*/
-	async init() {
-		this.connection = await connect(this.connectionOptions);
-		this.channel = await this.connection.createChannel();
-		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);
-		}
+	close() {
+		return Future.fromPromise(this.amqpClient.close()).mapError((error) => new TechnicalError("Failed to close AMQP connection", error)).mapOk(() => void 0);
 	}
 	/**
 	* Start consuming messages for all consumers
 	*/
-	async consumeAll() {
-		if (!this.contract.consumers) throw new Error("No consumers defined in contract");
+	consumeAll() {
+		if (!this.contract.consumers) return Future.value(Result.Error(new TechnicalError("No consumers defined in contract")));
 		const consumerNames = Object.keys(this.contract.consumers);
-		for (const consumerName of consumerNames) await this.consume(consumerName);
+		return Future.all(consumerNames.map((consumerName) => this.consume(consumerName))).map(Result.all).mapOk(() => void 0);
 	}
 	/**
 	* Start consuming messages for a specific consumer
 	*/
-	async consume(consumerName) {
-		if (!this.channel) throw new Error("Worker not initialized. Use TypedAmqpWorker.create() to obtain an initialized worker instance.");
+	consume(consumerName) {
 		const consumers = this.contract.consumers;
-		if (!consumers) throw new Error("No consumers defined in contract");
+		if (!consumers) return Future.value(Result.Error(new TechnicalError("No consumers defined in contract")));
 		const consumer = consumers[consumerName];
-		if (!consumer || typeof consumer !== "object") {
+		if (!consumer) {
 			const availableConsumers = Object.keys(consumers);
 			const available = availableConsumers.length > 0 ? availableConsumers.join(", ") : "none";
-			throw new Error(`Consumer not found: "${String(consumerName)}". Available consumers: ${available}`);
+			return Future.value(Result.Error(new TechnicalError(`Consumer not found: "${String(consumerName)}". Available consumers: ${available}`)));
 		}
-		const consumerDef = consumer;
 		const handler = this.handlers[consumerName];
-		if (!handler) throw new Error(`Handler for "${String(consumerName)}" not provided`);
-		if (consumerDef.prefetch !== void 0) await this.channel.prefetch(consumerDef.prefetch);
-		const result = await this.channel.consume(consumerDef.queue, async (msg) => {
-			if (!msg) return;
+		if (!handler) return Future.value(Result.Error(new TechnicalError(`Handler for "${String(consumerName)}" not provided`)));
+		return Future.fromPromise(this.amqpClient.channel.consume(consumer.queue.name, async (msg) => {
 			const parseResult = Result.fromExecution(() => JSON.parse(msg.content.toString()));
 			if (parseResult.isError()) {
 				console.error(new TechnicalError(`Error parsing message for consumer "${String(consumerName)}"`, parseResult.error));
-				this.channel?.nack(msg, false, false);
-				return;
-			}
-			const content = parseResult.value;
-			const rawValidation = consumerDef.message["~standard"].validate(content);
-			const resolvedValidation = rawValidation instanceof Promise ? await rawValidation : rawValidation;
-			const validationResult = typeof resolvedValidation === "object" && resolvedValidation !== null && "issues" in resolvedValidation && resolvedValidation.issues ? Result.Error(new MessageValidationError(String(consumerName), resolvedValidation.issues)) : Result.Ok(typeof resolvedValidation === "object" && resolvedValidation !== null && "value" in resolvedValidation ? resolvedValidation.value : content);
-			if (validationResult.isError()) {
-				console.error(validationResult.error);
-				this.channel?.nack(msg, false, false);
+				this.amqpClient.channel.nack(msg, false, false);
 				return;
 			}
-			const validatedMessage = validationResult.value;
-			try {
-				await handler(validatedMessage);
-				if (!consumerDef.noAck) this.channel?.ack(msg);
-			} catch (error) {
+			const rawValidation = consumer.message.payload["~standard"].validate(parseResult.value);
+			await Future.fromPromise(rawValidation instanceof Promise ? rawValidation : Promise.resolve(rawValidation)).mapOkToResult((validationResult) => {
+				if (validationResult.issues) return Result.Error(new MessageValidationError(String(consumerName), validationResult.issues));
+				return Result.Ok(validationResult.value);
+			}).tapError((error) => {
+				console.error(error);
+				this.amqpClient.channel.nack(msg, false, false);
+			}).flatMapOk((validatedMessage) => Future.fromPromise(handler(validatedMessage)).tapError((error) => {
 				console.error(new TechnicalError(`Error processing message for consumer "${String(consumerName)}"`, error));
-				this.channel?.nack(msg, false, true);
-			}
-		}, { noAck: consumerDef.noAck ?? false });
-		this.consumerTags.push(result.consumerTag);
-	}
-	/**
-	* Stop consuming messages
-	*/
-	async stopConsuming() {
-		if (!this.channel) return;
-		for (const tag of this.consumerTags) await this.channel.cancel(tag);
-		this.consumerTags = [];
+				this.amqpClient.channel.nack(msg, false, true);
+			})).tapOk(() => {
+				this.amqpClient.channel.ack(msg);
+			}).toPromise();
+		})).mapError((error) => new TechnicalError(`Failed to start consuming for "${String(consumerName)}"`, error)).mapOk(() => void 0);
 	}
 };
 
 //#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 = 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;
+}
+
+//#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","amqpClient: AmqpClient","handlers: WorkerInferConsumerHandlers<TContract>"],"sources":["../src/errors.ts","../src/worker.ts","../src/handlers.ts"],"sourcesContent":["/**\n * Base error class for worker errors\n */\nabstract class WorkerError extends Error {\n  protected constructor(message: string) {\n    super(message);\n    this.name = \"WorkerError\";\n    // Node.js specific stack trace capture\n    const ErrorConstructor = Error as unknown as {\n      captureStackTrace?: (target: object, constructor: Function) => void;\n    };\n    if (typeof ErrorConstructor.captureStackTrace === \"function\") {\n      ErrorConstructor.captureStackTrace(this, this.constructor);\n    }\n  }\n}\n\n/**\n * Error for technical/runtime failures in worker operations\n * This includes validation failures, parsing failures, and processing failures\n */\nexport class TechnicalError extends WorkerError {\n  constructor(\n    message: string,\n    public override readonly cause?: unknown,\n  ) {\n    super(message);\n    this.name = \"TechnicalError\";\n  }\n}\n\n/**\n * Error thrown when message validation fails\n */\nexport class MessageValidationError extends WorkerError {\n  constructor(\n    public readonly consumerName: string,\n    public readonly issues: unknown,\n  ) {\n    super(`Message validation failed for consumer \"${consumerName}\"`);\n    this.name = \"MessageValidationError\";\n  }\n}\n","import type { ContractDefinition, InferConsumerNames } from \"@amqp-contract/contract\";\nimport { AmqpClient } from \"@amqp-contract/core\";\nimport { Future, Result } from \"@swan-io/boxed\";\nimport { MessageValidationError, TechnicalError } from \"./errors.js\";\nimport type { WorkerInferConsumerHandlers, WorkerInferConsumerInput } from \"./types.js\";\nimport type { AmqpConnectionManagerOptions, ConnectionUrl } from \"amqp-connection-manager\";\n\n/**\n * Options for creating a type-safe AMQP worker.\n *\n * @typeParam TContract - The contract definition type\n *\n * @example\n * ```typescript\n * const options: CreateWorkerOptions<typeof contract> = {\n *   contract: myContract,\n *   handlers: {\n *     processOrder: async (message) => {\n *       console.log('Processing order:', message.orderId);\n *     }\n *   },\n *   urls: ['amqp://localhost'],\n *   connectionOptions: {\n *     heartbeatIntervalInSeconds: 30\n *   }\n * };\n * ```\n */\nexport type CreateWorkerOptions<TContract extends ContractDefinition> = {\n  /** The AMQP contract definition specifying consumers and their message schemas */\n  contract: TContract;\n  /** Handlers for each consumer defined in the contract */\n  handlers: WorkerInferConsumerHandlers<TContract>;\n  /** AMQP broker URL(s). Multiple URLs provide failover support */\n  urls: ConnectionUrl[];\n  /** Optional connection configuration (heartbeat, reconnect settings, etc.) */\n  connectionOptions?: AmqpConnectionManagerOptions | undefined;\n};\n\n/**\n * Type-safe AMQP worker for consuming messages from RabbitMQ.\n *\n * This class provides automatic message validation, connection management,\n * and error handling for consuming messages based on a contract definition.\n *\n * @typeParam TContract - The contract definition type\n *\n * @example\n * ```typescript\n * import { TypedAmqpWorker } from '@amqp-contract/worker';\n * import { z } from 'zod';\n *\n * const contract = defineContract({\n *   queues: {\n *     orderProcessing: defineQueue('order-processing', { durable: true })\n *   },\n *   consumers: {\n *     processOrder: defineConsumer('order-processing', z.object({\n *       orderId: z.string(),\n *       amount: z.number()\n *     }))\n *   }\n * });\n *\n * const worker = await TypedAmqpWorker.create({\n *   contract,\n *   handlers: {\n *     processOrder: async (message) => {\n *       console.log('Processing order', message.orderId);\n *       // Process the order...\n *     }\n *   },\n *   urls: ['amqp://localhost']\n * }).resultToPromise();\n *\n * // Close when done\n * await worker.close().resultToPromise();\n * ```\n */\nexport class TypedAmqpWorker<TContract extends ContractDefinition> {\n  private constructor(\n    private readonly contract: TContract,\n    private readonly amqpClient: AmqpClient,\n    private readonly handlers: WorkerInferConsumerHandlers<TContract>,\n  ) {}\n\n  /**\n   * Create a type-safe AMQP worker from a contract.\n   *\n   * Connection management (including automatic reconnection) is handled internally\n   * by amqp-connection-manager via the {@link AmqpClient}. The worker will set up\n   * consumers for all contract-defined handlers asynchronously in the background\n   * once the underlying connection and channels are ready.\n   *\n   * @param options - Configuration options for the worker\n   * @returns A Future that resolves to a Result containing the worker or an error\n   *\n   * @example\n   * ```typescript\n   * const workerResult = await TypedAmqpWorker.create({\n   *   contract: myContract,\n   *   handlers: {\n   *     processOrder: async (msg) => console.log('Order:', msg.orderId)\n   *   },\n   *   urls: ['amqp://localhost']\n   * }).resultToPromise();\n   *\n   * if (workerResult.isError()) {\n   *   console.error('Failed to create worker:', workerResult.error);\n   * }\n   * ```\n   */\n  static create<TContract extends ContractDefinition>({\n    contract,\n    handlers,\n    urls,\n    connectionOptions,\n  }: CreateWorkerOptions<TContract>): Future<Result<TypedAmqpWorker<TContract>, TechnicalError>> {\n    const worker = new TypedAmqpWorker(\n      contract,\n      new AmqpClient(contract, {\n        urls,\n        connectionOptions,\n      }),\n      handlers,\n    );\n    return worker.consumeAll().mapOk(() => worker);\n  }\n\n  /**\n   * Close the AMQP channel and connection.\n   *\n   * This gracefully closes the connection to the AMQP broker,\n   * stopping all message consumption and cleaning up resources.\n   *\n   * @returns A Future that resolves to a Result indicating success or failure\n   *\n   * @example\n   * ```typescript\n   * const closeResult = await worker.close().resultToPromise();\n   * if (closeResult.isOk()) {\n   *   console.log('Worker closed successfully');\n   * }\n   * ```\n   */\n  close(): Future<Result<void, TechnicalError>> {\n    return Future.fromPromise(this.amqpClient.close())\n      .mapError((error) => new TechnicalError(\"Failed to close AMQP connection\", error))\n      .mapOk(() => undefined);\n  }\n\n  /**\n   * Start consuming messages for all consumers\n   */\n  private consumeAll(): Future<Result<void, TechnicalError>> {\n    if (!this.contract.consumers) {\n      return Future.value(Result.Error(new TechnicalError(\"No consumers defined in contract\")));\n    }\n\n    const consumerNames = Object.keys(this.contract.consumers) as InferConsumerNames<TContract>[];\n\n    return Future.all(consumerNames.map((consumerName) => this.consume(consumerName)))\n      .map(Result.all)\n      .mapOk(() => undefined);\n  }\n\n  /**\n   * Start consuming messages for a specific consumer\n   */\n  private consume<TName extends InferConsumerNames<TContract>>(\n    consumerName: TName,\n  ): Future<Result<void, TechnicalError>> {\n    const consumers = this.contract.consumers;\n    if (!consumers) {\n      return Future.value(Result.Error(new TechnicalError(\"No consumers defined in contract\")));\n    }\n\n    const consumer = consumers[consumerName as string];\n    if (!consumer) {\n      const availableConsumers = Object.keys(consumers);\n      const available = availableConsumers.length > 0 ? availableConsumers.join(\", \") : \"none\";\n      return Future.value(\n        Result.Error(\n          new TechnicalError(\n            `Consumer not found: \"${String(consumerName)}\". Available consumers: ${available}`,\n          ),\n        ),\n      );\n    }\n\n    const handler = this.handlers[consumerName];\n    if (!handler) {\n      return Future.value(\n        Result.Error(new TechnicalError(`Handler for \"${String(consumerName)}\" not provided`)),\n      );\n    }\n\n    // Start consuming\n    return Future.fromPromise(\n      this.amqpClient.channel.consume(consumer.queue.name, async (msg) => {\n        // Parse message\n        const parseResult = Result.fromExecution(() => JSON.parse(msg.content.toString()));\n        if (parseResult.isError()) {\n          // fixme: define a proper logging mechanism\n          // fixme: do not log just an error, use a proper logging mechanism\n          console.error(\n            new TechnicalError(\n              `Error parsing message for consumer \"${String(consumerName)}\"`,\n              parseResult.error,\n            ),\n          );\n\n          // fixme proper error handling strategy\n          // Reject message with no requeue (malformed JSON)\n          this.amqpClient.channel.nack(msg, false, false);\n          return;\n        }\n\n        const rawValidation = consumer.message.payload[\"~standard\"].validate(parseResult.value);\n        await Future.fromPromise(\n          rawValidation instanceof Promise ? rawValidation : Promise.resolve(rawValidation),\n        )\n          .mapOkToResult((validationResult) => {\n            if (validationResult.issues) {\n              return Result.Error(\n                new MessageValidationError(String(consumerName), validationResult.issues),\n              );\n            }\n\n            return Result.Ok(validationResult.value as WorkerInferConsumerInput<TContract, TName>);\n          })\n          .tapError((error) => {\n            // fixme: define a proper logging mechanism\n            // fixme: do not log just an error, use a proper logging mechanism\n            console.error(error);\n\n            // fixme proper error handling strategy\n            // Reject message with no requeue (validation failed)\n            this.amqpClient.channel.nack(msg, false, false);\n          })\n          .flatMapOk((validatedMessage) =>\n            Future.fromPromise(handler(validatedMessage)).tapError((error) => {\n              // fixme: define a proper logging mechanism\n              // fixme: do not log just an error, use a proper logging mechanism\n              console.error(\n                new TechnicalError(\n                  `Error processing message for consumer \"${String(consumerName)}\"`,\n                  error,\n                ),\n              );\n\n              // fixme proper error handling strategy\n              // Reject message and requeue (handler failed)\n              this.amqpClient.channel.nack(msg, false, true);\n            }),\n          )\n          .tapOk(() => {\n            // Acknowledge message\n            this.amqpClient.channel.ack(msg);\n          })\n          .toPromise();\n      }),\n    )\n      .mapError(\n        (error) =>\n          new TechnicalError(`Failed to start consuming for \"${String(consumerName)}\"`, error),\n      )\n      .mapOk(() => undefined);\n  }\n}\n","import type { ContractDefinition, InferConsumerNames } from \"@amqp-contract/contract\";\nimport type { WorkerInferConsumerHandler, WorkerInferConsumerHandlers } from \"./types.js\";\n\n/**\n * Define a type-safe handler for a specific consumer in a contract.\n *\n * This utility allows you to define handlers outside of the worker creation,\n * providing better code organization and reusability.\n *\n * @template TContract - The contract definition type\n * @template TName - The consumer name from the contract\n * @param contract - The contract definition containing the consumer\n * @param consumerName - The name of the consumer from the contract\n * @param handler - The async handler function that processes messages\n * @returns A type-safe handler that can be used with TypedAmqpWorker\n *\n * @example\n * ```typescript\n * import { defineHandler } from '@amqp-contract/worker';\n * import { orderContract } from './contract';\n *\n * // Define handler outside of worker creation\n * const processOrderHandler = defineHandler(\n *   orderContract,\n *   'processOrder',\n *   async (message) => {\n *     // message is fully typed based on the contract\n *     console.log('Processing order:', message.orderId);\n *     await processPayment(message);\n *   }\n * );\n *\n * // Use the handler in worker\n * const worker = await TypedAmqpWorker.create({\n *   contract: orderContract,\n *   handlers: {\n *     processOrder: processOrderHandler,\n *   },\n *   connection: 'amqp://localhost',\n * });\n * ```\n *\n * @example\n * ```typescript\n * // Define multiple handlers\n * const processOrderHandler = defineHandler(\n *   orderContract,\n *   'processOrder',\n *   async (message) => {\n *     await processOrder(message);\n *   }\n * );\n *\n * const notifyOrderHandler = defineHandler(\n *   orderContract,\n *   'notifyOrder',\n *   async (message) => {\n *     await sendNotification(message);\n *   }\n * );\n *\n * // Compose handlers\n * const worker = await TypedAmqpWorker.create({\n *   contract: orderContract,\n *   handlers: {\n *     processOrder: processOrderHandler,\n *     notifyOrder: notifyOrderHandler,\n *   },\n *   connection: 'amqp://localhost',\n * });\n * ```\n */\nexport function defineHandler<\n  TContract extends ContractDefinition,\n  TName extends InferConsumerNames<TContract>,\n>(\n  contract: TContract,\n  consumerName: TName,\n  handler: WorkerInferConsumerHandler<TContract, TName>,\n): WorkerInferConsumerHandler<TContract, TName> {\n  // Validate that the consumer exists in the contract\n  const consumers = contract.consumers;\n\n  if (!consumers || !(consumerName in consumers)) {\n    const availableConsumers = consumers ? Object.keys(consumers) : [];\n    const available = availableConsumers.length > 0 ? availableConsumers.join(\", \") : \"none\";\n    throw new Error(\n      `Consumer \"${String(consumerName)}\" not found in contract. Available consumers: ${available}`,\n    );\n  }\n\n  // Return the handler as-is, with type checking enforced\n  return handler;\n}\n\n/**\n * Define multiple type-safe handlers for consumers in a contract.\n *\n * This utility allows you to define all handlers at once outside of the worker creation,\n * ensuring type safety and providing better code organization.\n *\n * @template TContract - The contract definition type\n * @param contract - The contract definition containing the consumers\n * @param handlers - An object with async handler functions for each consumer\n * @returns A type-safe handlers object that can be used with TypedAmqpWorker\n *\n * @example\n * ```typescript\n * import { defineHandlers } from '@amqp-contract/worker';\n * import { orderContract } from './contract';\n *\n * // Define all handlers at once\n * const handlers = defineHandlers(orderContract, {\n *   processOrder: async (message) => {\n *     // message is fully typed based on the contract\n *     console.log('Processing order:', message.orderId);\n *     await processPayment(message);\n *   },\n *   notifyOrder: async (message) => {\n *     await sendNotification(message);\n *   },\n *   shipOrder: async (message) => {\n *     await prepareShipment(message);\n *   },\n * });\n *\n * // Use the handlers in worker\n * const worker = await TypedAmqpWorker.create({\n *   contract: orderContract,\n *   handlers,\n *   connection: 'amqp://localhost',\n * });\n * ```\n *\n * @example\n * ```typescript\n * // Separate handler definitions for better organization\n * async function handleProcessOrder(message: WorkerInferConsumerInput<typeof orderContract, 'processOrder'>) {\n *   await processOrder(message);\n * }\n *\n * async function handleNotifyOrder(message: WorkerInferConsumerInput<typeof orderContract, 'notifyOrder'>) {\n *   await sendNotification(message);\n * }\n *\n * const handlers = defineHandlers(orderContract, {\n *   processOrder: handleProcessOrder,\n *   notifyOrder: handleNotifyOrder,\n * });\n * ```\n */\nexport function defineHandlers<TContract extends ContractDefinition>(\n  contract: TContract,\n  handlers: WorkerInferConsumerHandlers<TContract>,\n): WorkerInferConsumerHandlers<TContract> {\n  // Validate that all consumers in handlers exist in the contract\n  const consumers = contract.consumers;\n  const availableConsumers = Object.keys(consumers ?? {});\n  const availableConsumerNames =\n    availableConsumers.length > 0 ? availableConsumers.join(\", \") : \"none\";\n\n  for (const handlerName of Object.keys(handlers)) {\n    if (!consumers || !(handlerName in consumers)) {\n      throw new Error(\n        `Consumer \"${handlerName}\" not found in contract. Available consumers: ${availableConsumerNames}`,\n      );\n    }\n  }\n\n  // Return the handlers as-is, with type checking enforced\n  return handlers;\n}\n"],"mappings":"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"}