@amqp-contract/worker 1.0.0 → 2.0.0

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import { extractConsumer, extractQueue, isQueueWithTtlBackoffInfrastructure } from "@amqp-contract/contract";
 import { AmqpClient, MessageValidationError, TechnicalError, defaultTelemetryProvider, endSpanError, endSpanSuccess, recordConsumeMetric, safeJsonParse, startConsumeSpan } from "@amqp-contract/core";
-import { TaggedError, allAsync, err, fromPromise, fromSafePromise, ok } from "unthrown";
+import { Err, Ok, TaggedError, allAsync, fromPromise, fromSafePromise } from "unthrown";
 import { gunzip, inflate } from "node:zlib";
 import { promisify } from "node:util";
 //#region src/decompression.ts
@@ -26,9 +26,9 @@ function isSupportedEncoding(encoding) {
 * @internal
 */
 function decompressBuffer(buffer, contentEncoding) {
-	if (!contentEncoding) return ok(buffer).toAsync();
+	if (!contentEncoding) return Ok(buffer).toAsync();
 	const normalizedEncoding = contentEncoding.toLowerCase();
-	if (!isSupportedEncoding(normalizedEncoding)) return err(new TechnicalError(`Unsupported content-encoding: "${contentEncoding}". Supported encodings are: ${SUPPORTED_ENCODINGS.join(", ")}. Please check your publisher configuration.`)).toAsync();
+	if (!isSupportedEncoding(normalizedEncoding)) return Err(new TechnicalError(`Unsupported content-encoding: "${contentEncoding}". Supported encodings are: ${SUPPORTED_ENCODINGS.join(", ")}. Please check your publisher configuration.`)).toAsync();
 	switch (normalizedEncoding) {
 		case "gzip": return fromPromise(gunzipAsync(buffer), (error) => new TechnicalError("Failed to decompress gzip", error));
 		case "deflate": return fromPromise(inflateAsync(buffer), (error) => new TechnicalError("Failed to decompress deflate", error));
@@ -185,17 +185,17 @@ function retryable(message, cause) {
 * @example
 * ```typescript
 * import { nonRetryable } from '@amqp-contract/worker';
-* import { err, ok } from 'unthrown';
+* import { Err, Ok } from 'unthrown';
 *
 * const handler = ({ payload }) => {
 *   if (!isValidPayload(payload)) {
-*     return err(nonRetryable('Invalid payload format')).toAsync();
+*     return Err(nonRetryable('Invalid payload format')).toAsync();
 *   }
-*   return ok(undefined).toAsync();
+*   return Ok(undefined).toAsync();
 * };
 *
 * // Equivalent to:
-* // return err(new NonRetryableError('Invalid payload format')).toAsync();
+* // return Err(new NonRetryableError('Invalid payload format')).toAsync();
 * ```
 */
 function nonRetryable(message, cause) {
@@ -224,7 +224,7 @@ function nonRetryable(message, cause) {
 function handleError(ctx, error, msg, consumerName, consumer) {
 	if (error instanceof NonRetryableError) {
 		sendToDLQ(ctx, msg, consumer);
-		return ok(void 0).toAsync();
+		return Ok(void 0).toAsync();
 	}
 	const config = extractQueue(consumer.queue).retry;
 	if (config.mode === "immediate-requeue") return handleErrorImmediateRequeue(ctx, error, msg, consumerName, consumer, config);
@@ -234,7 +234,7 @@ function handleError(ctx, error, msg, consumerName, consumer) {
 		queueName: extractQueue(consumer.queue).name
 	});
 	sendToDLQ(ctx, msg, consumer);
-	return ok(void 0).toAsync();
+	return Ok(void 0).toAsync();
 }
 /**
 * Handle error by requeuing immediately.
@@ -257,7 +257,7 @@ function handleErrorImmediateRequeue(ctx, error, msg, consumerName, consumer, co
 			maxRetries: config.maxRetries
 		});
 		sendToDLQ(ctx, msg, consumer);
-		return ok(void 0).toAsync();
+		return Ok(void 0).toAsync();
 	}
 	ctx.logger?.info("Retrying message (immediate-requeue mode)", {
 		consumerName,
@@ -267,7 +267,7 @@ function handleErrorImmediateRequeue(ctx, error, msg, consumerName, consumer, co
 	});
 	if (queue.type === "quorum") {
 		ctx.amqpClient.nack(msg, false, true);
-		return ok(void 0).toAsync();
+		return Ok(void 0).toAsync();
 	} else return publishForRetry(ctx, {
 		msg,
 		exchange: msg.fields.exchange,
@@ -308,7 +308,7 @@ function handleErrorTtlBackoff(ctx, error, msg, consumerName, consumer, config)
 			consumerName,
 			queueName: consumer.queue.name
 		});
-		return err(new TechnicalError("Queue does not have TTL-backoff infrastructure")).toAsync();
+		return Err(new TechnicalError("Queue does not have TTL-backoff infrastructure")).toAsync();
 	}
 	const queueEntry = consumer.queue;
 	const queueName = extractQueue(queueEntry).name;
@@ -321,7 +321,7 @@ function handleErrorTtlBackoff(ctx, error, msg, consumerName, consumer, config)
 			maxRetries: config.maxRetries
 		});
 		sendToDLQ(ctx, msg, consumer);
-		return ok(void 0).toAsync();
+		return Ok(void 0).toAsync();
 	}
 	const delayMs = calculateRetryDelay(retryCount, config);
 	ctx.logger?.info("Retrying message (ttl-backoff mode)", {
@@ -401,7 +401,7 @@ function publishForRetry(ctx, { msg, exchange, routingKey, queueName, waitQueueN
 				retryCount: newRetryCount,
 				...delayMs !== void 0 ? { delayMs } : {}
 			});
-			return err(new TechnicalError("Failed to publish message for retry (write buffer full)"));
+			return Err(new TechnicalError("Failed to publish message for retry (write buffer full)"));
 		}
 		ctx.amqpClient.ack(msg);
 		ctx.logger?.info("Message published for retry", {
@@ -409,7 +409,7 @@ function publishForRetry(ctx, { msg, exchange, routingKey, queueName, waitQueueN
 			retryCount: newRetryCount,
 			...delayMs !== void 0 ? { delayMs } : {}
 		});
-		return ok(void 0);
+		return Ok(void 0);
 	}).orElse((publishError) => {
 		ctx.logger?.error("Publish for retry failed; leaving original un-ack'd for redelivery", {
 			queueName,
@@ -417,7 +417,7 @@ function publishForRetry(ctx, { msg, exchange, routingKey, queueName, waitQueueN
 			...delayMs !== void 0 ? { delayMs } : {},
 			error: publishError
 		});
-		return err(publishError);
+		return Err(publishError);
 	});
 }
 /**
@@ -454,7 +454,7 @@ function isHandlerTuple(entry) {
 * ```typescript
 * import { TypedAmqpWorker } from '@amqp-contract/worker';
 * import { defineQueue, defineMessage, defineContract, defineConsumer } from '@amqp-contract/contract';
-* import { ok } from 'unthrown';
+* import { Ok } from 'unthrown';
 * import { z } from 'zod';
 *
 * const orderQueue = defineQueue('order-processing');
@@ -474,7 +474,7 @@ function isHandlerTuple(entry) {
 *   handlers: {
 *     processOrder: ({ payload }) => {
 *       console.log('Processing order', payload.orderId);
-*       return ok(undefined).toAsync();
+*       return Ok(undefined).toAsync();
 *     },
 *   },
 *   urls: ['amqp://localhost'],
@@ -570,7 +570,7 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 	* const result = await TypedAmqpWorker.create({
 	*   contract: myContract,
 	*   handlers: {
-	*     processOrder: ({ payload }) => ok(undefined).toAsync(),
+	*     processOrder: ({ payload }) => Ok(undefined).toAsync(),
 	*   },
 	*   urls: ['amqp://localhost'],
 	* });
@@ -612,7 +612,7 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 				consumerTag,
 				error
 			});
-			return ok(void 0);
+			return Ok(void 0);
 		}))).tap(() => {
 			this.consumerTags.clear();
 		}).flatMap(() => this.amqpClient.close()).map(() => void 0);
@@ -644,8 +644,8 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 	validateSchema(schema, data, context) {
 		const rawValidation = schema["~standard"].validate(data);
 		return fromPromise(rawValidation instanceof Promise ? rawValidation : Promise.resolve(rawValidation), (error) => new TechnicalError(`Error validating ${context.field}`, error)).flatMap((result) => {
-			if (result.issues) return err(new TechnicalError(`${context.field} validation failed`, new MessageValidationError(context.consumerName, result.issues)));
-			return ok(result.value);
+			if (result.issues) return Err(new TechnicalError(`${context.field} validation failed`, new MessageValidationError(context.consumerName, result.issues)));
+			return Ok(result.value);
 		});
 	}
 	/**
@@ -663,7 +663,7 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 		})), consumer.message.headers ? this.validateSchema(consumer.message.headers, msg.properties.headers ?? {}, {
 			...context,
 			field: "headers"
-		}) : ok(void 0).toAsync()]).map(([payload, headers]) => ({
+		}) : Ok(void 0).toAsync()]).map(([payload, headers]) => ({
 			payload,
 			headers
 		}));
@@ -695,7 +695,7 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 				rpcName: String(rpcName),
 				queueName
 			});
-			return err(new NonRetryableError(`RPC "${String(rpcName)}" received a message without replyTo; cannot deliver response`)).toAsync();
+			return Err(new NonRetryableError(`RPC "${String(rpcName)}" received a message without replyTo; cannot deliver response`)).toAsync();
 		}
 		if (typeof correlationId !== "string" || correlationId.length === 0) {
 			this.logger?.error("RPC handler returned a response but the incoming message has no correlationId", {
@@ -703,21 +703,21 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 				queueName,
 				replyTo
 			});
-			return err(new NonRetryableError(`RPC "${String(rpcName)}" received a message without correlationId; cannot deliver response`)).toAsync();
+			return Err(new NonRetryableError(`RPC "${String(rpcName)}" received a message without correlationId; cannot deliver response`)).toAsync();
 		}
 		let rawValidation;
 		try {
 			rawValidation = responseSchema["~standard"].validate(response);
 		} catch (error) {
-			return err(new NonRetryableError("RPC response schema validation threw", error)).toAsync();
+			return Err(new NonRetryableError("RPC response schema validation threw", error)).toAsync();
 		}
 		return fromPromise(rawValidation instanceof Promise ? rawValidation : Promise.resolve(rawValidation), (error) => new NonRetryableError("RPC response schema validation threw", error)).flatMap((validation) => {
-			if (validation.issues) return err(new NonRetryableError(`RPC response for "${String(rpcName)}" failed schema validation`, new MessageValidationError(String(rpcName), validation.issues)));
-			return ok(validation.value);
+			if (validation.issues) return Err(new NonRetryableError(`RPC response for "${String(rpcName)}" failed schema validation`, new MessageValidationError(String(rpcName), validation.issues)));
+			return Ok(validation.value);
 		}).flatMap((validatedResponse) => this.amqpClient.publish("", replyTo, validatedResponse, {
 			correlationId,
 			contentType: "application/json"
-		}).mapErr((error) => new NonRetryableError("Failed to publish RPC response", error)).flatMap((published) => published ? ok(void 0) : err(new NonRetryableError("Failed to publish RPC response: channel buffer full"))));
+		}).mapErr((error) => new NonRetryableError("Failed to publish RPC response", error)).flatMap((published) => published ? Ok(void 0) : Err(new NonRetryableError("Failed to publish RPC response: channel buffer full"))));
 	}
 	/**
 	* Parse and validate the message; on failure, nack(requeue=false) so the
@@ -728,7 +728,7 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 	parseAndValidateOrNack(msg, consumer, name) {
 		return this.parseAndValidateMessage(msg, consumer, name).orElse((parseError) => {
 			this.amqpClient.nack(msg, false, false);
-			return err(parseError).toAsync();
+			return Err(parseError).toAsync();
 		});
 	}
 	/**
@@ -743,10 +743,10 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 	/**
 	* For RPC handlers, validate and publish the reply on the caller's
 	* `replyTo` / `correlationId`. For non-RPC consumers, this is a no-op that
-	* resolves to `ok(undefined).toAsync()`.
+	* resolves to `Ok(undefined).toAsync()`.
 	*/
 	publishReplyIfRpc(msg, view, name, handlerResponse) {
-		if (!view.isRpc || !view.responseSchema) return ok(void 0).toAsync();
+		if (!view.isRpc || !view.responseSchema) return Ok(void 0).toAsync();
 		const queueName = extractQueue(view.consumer.queue).name;
 		return this.publishRpcResponse(msg, queueName, name, view.responseSchema, handlerResponse);
 	}
@@ -759,7 +759,7 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 	* is still needed (see {@link consumeSingle}).
 	*
 	* Success-vs-failure telemetry is data-driven: the chain resolves to
-	* `ok(undefined)` only on handler success (and reply-publish success for
+	* `Ok(undefined)` only on handler success (and reply-publish success for
 	* RPC). Handler failures — even when {@link handleError} routes them
 	* successfully to retry/DLQ — are classified as failures for metrics by
 	* re-failing the chain with a `TechnicalError` whose `cause` is the
@@ -799,7 +799,7 @@ var TypedAmqpWorker = class TypedAmqpWorker {
 				logger: this.logger
 			}, handlerError, msg, String(name), consumer).tap(() => {
 				state.messageHandled = true;
-			}).flatMap(() => err(new TechnicalError(`Handler "${String(name)}" failed: ${handlerError.message}`, handlerError)).toAsync());
+			}).flatMap(() => Err(new TechnicalError(`Handler "${String(name)}" failed: ${handlerError.message}`, handlerError)).toAsync());
 		})).tap(() => {
 			try {
 				endSpanSuccess(span);
@@ -921,7 +921,7 @@ function defineHandler(contract, name, handler, options) {
 * @example
 * ```typescript
 * import { defineHandlers, RetryableError } from '@amqp-contract/worker';
-* import { fromPromise, ok } from 'unthrown';
+* import { fromPromise, Ok } from 'unthrown';
 *
 * const handlers = defineHandlers(orderContract, {
 *   processOrder: ({ payload }) =>
@@ -929,7 +929,7 @@ function defineHandler(contract, name, handler, options) {
 *       processPayment(payload),
 *       (error) => new RetryableError('Payment failed', error),
 *     ).map(() => undefined),
-*   calculate: ({ payload }) => ok({ sum: payload.a + payload.b }).toAsync(),
+*   calculate: ({ payload }) => Ok({ sum: payload.a + payload.b }).toAsync(),
 * });
 * ```
 */