Skip to content

amqp-contractType-safe contracts for AMQP/RabbitMQ

End-to-end type safety ยท Runtime validation ยท Reliable retry patterns

amqp-contract

Quick Example โ€‹

Define your contract once โ€” get type safety everywhere:

typescript
import {
  defineContract,
  defineExchange,
  defineQueue,
  defineEventPublisher,
  defineEventConsumer,
  defineMessage,
} from "@amqp-contract/contract";
import { z } from "zod";

const ordersExchange = defineExchange("orders");
const ordersDlx = defineExchange("orders-dlx");
const orderProcessingQueue = defineQueue("order-processing", {
  deadLetter: { exchange: ordersDlx },
  retry: { mode: "ttl-backoff" }, // Automatic retry with exponential backoff
});

const orderMessage = defineMessage(
  z.object({
    orderId: z.string(),
    amount: z.number(),
  }),
);

// Event pattern: publisher broadcasts, consumers subscribe
const orderCreatedEvent = defineEventPublisher(ordersExchange, orderMessage, {
  routingKey: "order.created",
});

// Compose contract - exchanges, queues, bindings auto-extracted
export const contract = defineContract({
  publishers: {
    // EventPublisherConfig โ†’ auto-extracted to publisher
    orderCreated: orderCreatedEvent,
  },
  consumers: {
    // EventConsumerResult โ†’ auto-extracted to consumer + binding
    processOrder: defineEventConsumer(orderCreatedEvent, orderProcessingQueue),
  },
});
typescript
import { TypedAmqpClient } from "@amqp-contract/client";
import { contract } from "./contract";

const client = (
  await TypedAmqpClient.create({
    contract,
    urls: ["amqp://localhost"],
  })
)._unsafeUnwrap();

await client.publish("orderCreated", {
  orderId: "ORD-123", // โœ… TypeScript knows!
  amount: 99.99,
});
typescript
import { TypedAmqpWorker } from "@amqp-contract/worker";
import { okAsync, ResultAsync, Result } from "neverthrow";
import { contract } from "./contract";

const worker = (
  await TypedAmqpWorker.create({
    contract,
    handlers: {
      processOrder: ({ payload }) => {
        console.log(payload.orderId); // โœ… Fully typed!
        return okAsync(undefined);
      },
    },
    urls: ["amqp://localhost"],
  })
)._unsafeUnwrap();

Released under the MIT License.