@amqp-contract/worker 0.23.1 → 0.25.0

package/README.md

@@ -1,11 +1,11 @@
 # @amqp-contract/worker
 
-**Type-safe AMQP worker for consuming messages using amqp-contract with Future/Result error handling.**
+**Type-safe AMQP worker for consuming messages using amqp-contract with ResultAsync/Result error handling.**
 
 [![CI](https://github.com/btravers/amqp-contract/actions/workflows/ci.yml/badge.svg)](https://github.com/btravers/amqp-contract/actions/workflows/ci.yml)
 [![npm version](https://img.shields.io/npm/v/@amqp-contract/worker.svg?logo=npm)](https://www.npmjs.com/package/@amqp-contract/worker)
 [![npm downloads](https://img.shields.io/npm/dm/@amqp-contract/worker.svg)](https://www.npmjs.com/package/@amqp-contract/worker)
-[![TypeScript](https://img.shields.io/badge/TypeScript-5.9-blue?logo=typescript)](https://www.typescriptlang.org/)
+[![TypeScript](https://img.shields.io/badge/TypeScript-6.0-blue?logo=typescript)](https://www.typescriptlang.org/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
 📖 **[Full documentation →](https://btravers.github.io/amqp-contract/api/worker)**
@@ -31,7 +31,7 @@ pnpm add @amqp-contract/worker
 ```typescript
 import { TypedAmqpWorker, RetryableError } from "@amqp-contract/worker";
 import type { Logger } from "@amqp-contract/core";
-import { Future } from "@swan-io/boxed";
+import { ResultAsync } from "neverthrow";
 import { contract } from "./contract";
 
 // Optional: Create a logger implementation
@@ -43,21 +43,24 @@ const logger: Logger = {
 };
 
 // Create worker from contract with handlers (automatically connects and starts consuming)
-const worker = await TypedAmqpWorker.create({
-  contract,
-  handlers: {
-    processOrder: ({ payload }) => {
-      console.log("Processing order:", payload.orderId);
-
-      // Your business logic here
-      return Future.fromPromise(Promise.all([processPayment(payload), updateInventory(payload)]))
-        .mapOk(() => undefined)
-        .mapError((error) => new RetryableError("Order processing failed", error));
+const worker = (
+  await TypedAmqpWorker.create({
+    contract,
+    handlers: {
+      processOrder: ({ payload }) => {
+        console.log("Processing order:", payload.orderId);
+
+        // Your business logic here
+        return ResultAsync.fromPromise(
+          Promise.all([processPayment(payload), updateInventory(payload)]),
+          (error) => new RetryableError("Order processing failed", error),
+        ).map(() => undefined);
+      },
     },
-  },
-  urls: ["amqp://localhost"],
-  logger, // Optional: logs message consumption and errors
-});
+    urls: ["amqp://localhost"],
+    logger, // Optional: logs message consumption and errors
+  })
+)._unsafeUnwrap();
 
 // Worker is already consuming messages
 
@@ -96,19 +99,22 @@ Then use `RetryableError` in your handlers:
 
 ```typescript
 import { TypedAmqpWorker, RetryableError } from "@amqp-contract/worker";
-import { Future } from "@swan-io/boxed";
-
-const worker = await TypedAmqpWorker.create({
-  contract,
-  handlers: {
-    processOrder: ({ payload }) =>
-      // If this fails with RetryableError, message is automatically retried
-      Future.fromPromise(processPayment(payload))
-        .mapOk(() => undefined)
-        .mapError((error) => new RetryableError("Payment failed", error)),
-  },
-  urls: ["amqp://localhost"],
-});
+import { ResultAsync } from "neverthrow";
+
+const worker = (
+  await TypedAmqpWorker.create({
+    contract,
+    handlers: {
+      processOrder: ({ payload }) =>
+        // If this fails with RetryableError, message is automatically retried
+        ResultAsync.fromPromise(
+          processPayment(payload),
+          (error) => new RetryableError("Payment failed", error),
+        ).map(() => undefined),
+    },
+    urls: ["amqp://localhost"],
+  })
+)._unsafeUnwrap();
 ```
 
 See the [Error Handling and Retry](https://btravers.github.io/amqp-contract/guide/worker-usage#error-handling-and-retry) section in the guide for complete details.
@@ -119,23 +125,22 @@ You can define handlers outside of the worker creation using `defineHandler` and
 
 ## Error Handling
 
-Worker handlers return `Future<Result<void, HandlerError>>` for explicit error handling:
+Worker handlers return `ResultAsync<void, HandlerError>` for explicit error handling:
 
 ```typescript
 import { RetryableError, NonRetryableError } from "@amqp-contract/worker";
-import { Future, Result } from "@swan-io/boxed";
+import { errAsync, ResultAsync } from "neverthrow";
 
 handlers: {
   processOrder: ({ payload }) => {
     // Validation errors - non-retryable
     if (payload.amount <= 0) {
-      return Future.value(Result.Error(new NonRetryableError("Invalid amount")));
+      return errAsync(new NonRetryableError("Invalid amount"));
     }
 
     // Transient errors - retryable
-    return Future.fromPromise(process(payload))
-      .mapOk(() => undefined)
-      .mapError((error) => new RetryableError("Processing failed", error));
+    return ResultAsync.fromPromise(process(payload), (error) => new RetryableError("Processing failed", error))
+      .map(() => undefined);
   },
 }
 ```