fastify-rabbitmq 3.2.0 → 3.4.0

package/CHANGELOG.md

@@ -0,0 +1,71 @@
+# Fastify RabbitMQ
+
+## v3.4.0 - 2026-06-09
+
+### What Changed 👀
+
+#### 🚀 Features
+
+- feat: re-export the rabbitmq-client types from fastify-rabbitmq @Bugs5382 (#135)
+- build: migrate to tsdown and the shared eslint-config @Bugs5382 (#119)
+
+#### 🐛 Bug Fixes
+
+- fix: validate connection shape and reject invalid registration options @Bugs5382 (#125)
+
+#### 📄 Documentation
+
+- docs: point consumers at the re-exported client types @Bugs5382 (#137)
+- docs: show how to encapsulate messaging in a Fastify plugin @Bugs5382 (#131)
+- docs: rewrite README to standard, add AGENTS.md, fix typedoc parent-export @Bugs5382 (#124)
+
+#### 🧩 Dependency Updates
+
+- build(deps): bump the production-dependencies group across 1 directory with 3 updates @[dependabot[bot]](https://github.com/apps/dependabot) (#121)
+- build: migrate to tsdown and the shared eslint-config @Bugs5382 (#119)
+
+### Extra
+
+**Full Changelog**: https://github.com/Bugs5382/fastify-rabbitmq/compare/v3.3.0...v3.4.0
+
+## v3.3.0 - 2025-05-31
+
+#### What Changed 👀
+
+#### 🚀 Features
+
+- feat: remove old build method @Bugs5382 (#108)
+
+#### 🧩 Dependency Updates
+
+- feat: remove old build method @Bugs5382 (#108)
+
+### Extra
+
+**Full Changelog**: https://github.com/Bugs5382/fastify-rabbitmq/compare/v3.2.0...v3.3.0
+
+## v3.2.0 - 2025-03-25
+
+#### What Changed 👀
+
+#### 🧩 Dependency Updates
+
+- feat: updated dependencies @Bugs5382 (#106)
+
+### Extra
+
+**Full Changelog**: https://github.com/Bugs5382/fastify-rabbitmq/compare/v3.1.0...v3.2.0
+
+## v3.1.0 - 2024-11-17
+
+#### What Changed 👀
+
+- ci: update workflows @Bugs5382 (#103)
+
+#### 🧩 Dependency Updates
+
+- feat: updated packages @Bugs5382 (#105)
+
+### Extra
+
+**Full Changelog**: https://github.com/Bugs5382/fastify-rabbitmq/compare/v3.0.0...v3.1.0

package/README.md

@@ -1,104 +1,291 @@
-# Fastify RabbitMQ
+# 🐰 Fastify RabbitMQ
 
-A Fastify RabbitMQ Plugin Developed in Pure TypeScript.
-It uses the [node-rabbitmq-client](https://github.com/cody-greene/node-rabbitmq-client/) plugin as a wrapper.
+A Fastify RabbitMQ plugin developed in pure TypeScript.
+It wraps the [`rabbitmq-client`](https://www.npmjs.com/package/rabbitmq-client) package so a Fastify
+app can publish, consume, and RPC over RabbitMQ (AMQP 0-9-1).
 
-The build exports this to valid ESM and CJS for ease of cross-compatibility.
+The build exports valid ESM and CJS for cross-compatibility.
 
-If you are using this NPM package, please consider giving it a :star: star.
-This will increase its visibility and solicit more contribution from the outside.
+If you use this package, please consider giving it a ⭐ — it raises visibility and brings in more
+contribution from the outside.
+
+> This documentation covers **how to use the plugin**. The decorator `app.rabbitmq` is a live
+> `rabbitmq-client` `Connection`, so its full API is available — for publisher/consumer/RPC option
+> details, see [External Libraries](#-external-libraries).
+
+> 🟢 **Requires Node.js ≥ 20.15.**
 
 ## Table of Contents
 
-1. [Install](#install)
-2. [Basic Usage](#basic-usage)
-3. [Full Documentation](#full-documentation)
-   1. [Options](#options)
-4. [Acknowledgements](#acknowledgements)
-5. [License](#license)
+1. [Install](#-install)
+2. [Basic Usage](#-basic-usage)
+3. [Recipes](#-recipes)
+   1. [Publish a message](#1-publish-a-message)
+   2. [Consume a queue](#2-consume-a-queue)
+   3. [RPC (request/response)](#3-rpc-requestresponse)
+   4. [Declare exchanges, queues, and bindings](#4-declare-exchanges-queues-and-bindings)
+   5. [Multiple connections with namespaces](#5-multiple-connections-with-namespaces)
+   6. [Encapsulate messaging in your own plugin](#6-encapsulate-messaging-in-your-own-plugin)
+4. [API Reference](#-api-reference-fastifyrabbitmq)
+5. [Plugin Options](#-plugin-options)
+6. [External Libraries](#-external-libraries)
+7. [Acknowledgements](#-acknowledgements)
+8. [License](#-license)
 
-## Install
+## 📦 Install
 
-```
+```shell
 npm install fastify-rabbitmq
 ```
 
-## Basic Usage
+Requires Node.js ≥ 20.15.
+
+## 🚀 Basic Usage
+
+Register the plugin (before any routes that use it):
+
+```ts
+import fastify from "fastify";
+import fastifyRabbitMQ from "fastify-rabbitmq";
+
+const app = fastify();
+
+await app.register(fastifyRabbitMQ, {
+  connection: "amqp://guest:guest@localhost",
+});
+```
+
+Registering decorates the Fastify instance with `app.rabbitmq` — a live `rabbitmq-client`
+`Connection`. Use it to create publishers, consumers, and RPC clients, or to declare topology.
+
+## 🧩 Recipes
+
+### 1. Publish a message
+
+```ts
+const publisher = app.rabbitmq.createPublisher({
+  confirm: true,
+  maxAttempts: 1,
+});
+
+await publisher.send("foo", "bar"); // routing key "foo", body "bar"
+```
+
+In a route, reach the instance via `request.server`:
+
+```ts
+app.get("/publish", async (request, reply) => {
+  const publisher = request.server.rabbitmq.createPublisher({ confirm: true });
+  await publisher.send("foo", "bar");
+  return { sent: true };
+});
+```
+
+### 2. Consume a queue
+
+```ts
+const consumer = app.rabbitmq.createConsumer(
+  {
+    queue: "foo",
+    queueOptions: { durable: true },
+  },
+  async (msg) => {
+    app.log.info({ body: msg.body }, "received");
+    // ...handle the message...
+  },
+);
+```
+
+### 3. RPC (request/response)
+
+```ts
+const rpc = app.rabbitmq.createRPCClient({ confirm: true });
+const response = await rpc.send("my-rpc-queue", "ping");
+app.log.info({ response: response.body }, "rpc reply");
+```
+
+### 4. Declare exchanges, queues, and bindings
 
-Register this as a plugin.
-Make sure it is loaded before any **_routes_** are loaded.
+```ts
+await app.rabbitmq.queueDeclare({ queue: "foo", durable: true });
+await app.rabbitmq.exchangeDeclare({ exchange: "my-exchange", type: "topic" });
+await app.rabbitmq.queueBind({
+  queue: "foo",
+  exchange: "my-exchange",
+  routingKey: "foo.#",
+});
+```
+
+### 5. Multiple connections with namespaces
+
+To talk to more than one broker (or keep separate connections), register the plugin once per
+`namespace`; each is reachable at `app.rabbitmq.<namespace>`:
+
+```ts
+await app.register(fastifyRabbitMQ, {
+  connection: "amqp://guest:guest@broker-a",
+  namespace: "a",
+});
+await app.register(fastifyRabbitMQ, {
+  connection: "amqp://guest:guest@broker-b",
+  namespace: "b",
+});
+
+const pubA = app.rabbitmq.a.createPublisher();
+const pubB = app.rabbitmq.b.createPublisher();
+```
+
+Registering the same namespace twice throws `FASTIFY_RABBIT_MQ_ERR_SETUP_ERRORS`.
+
+### 6. Encapsulate messaging in your own plugin
+
+This is the pattern the plugin is built for, and the reason it is a plugin at all.
+Fastify's encapsulation lets you keep every messaging concern — the connection, the
+topology, the publishers, the consumers, and their shutdown — in **one plugin**, and
+expose just a small, intent-named surface (a decorator like `app.events`) to the rest
+of the app. Your routes publish business events; they never see exchanges, routing
+keys, or the AMQP client.
+
+Wrap it with [`fastify-plugin`](https://github.com/fastify/fastify-plugin) so the
+decorator is visible to sibling plugins and routes (without `fp`, the decorator would
+be trapped inside this plugin's encapsulation context):
+
+```ts
+// plugins/messaging.ts
+import fp from "fastify-plugin";
+import fastifyRabbitMQ, { type Publisher } from "fastify-rabbitmq";
 
-### Quick Setup on the Server Side
+declare module "fastify" {
+  interface FastifyInstance {
+    events: Publisher;
+  }
+}
+
+export default fp(
+  async (app) => {
+    // 1. Open the connection.
+    await app.register(fastifyRabbitMQ, {
+      connection: process.env.RABBITMQ_URL ?? "amqp://guest:guest@localhost",
+    });
 
-```typescript
-export default fp<FastifyRabbitMQOptions>((fastify, options, done) => {
-  void fastify.register(fastifyRabbit, {
-    connection: `amqp://guest:guest@localhost`,
-  });
+    // 2. Declare the topology and a publisher once, at startup. The publisher
+    //    re-declares these on every reconnect, so the exchange always exists
+    //    before the first send.
+    const publisher = app.rabbitmq.createPublisher({
+      confirm: true,
+      maxAttempts: 2,
+      exchanges: [{ exchange: "events", type: "topic" }],
+    });
 
-  void fastify.ready().then(async () => {
-    const consumer = fastify.rabbitmq.createConsumer(
+    // 3. Expose one intent-named sender. Routes call app.events.send(...) and
+    //    stay ignorant of AMQP.
+    app.decorate("events", publisher);
+
+    // 4. Run consumers as part of the app lifecycle. The consumer manages its
+    //    own channel and re-subscribes across reconnects.
+    const consumer = app.rabbitmq.createConsumer(
       {
-        queue: "foo",
+        queue: "user-events",
         queueOptions: { durable: true },
+        queueBindings: [{ exchange: "events", routingKey: "user.#" }],
       },
-      async (msg: any) => {
-        console.log(msg); // ==> bar
+      async (msg) => {
+        app.log.info({ body: msg.body }, "user event");
+        // ...handle the message; throw to nack/retry...
       },
     );
-  });
-});
+
+    // 5. Tear everything down with the app, so a restart or test closes
+    //    cleanly instead of leaking connections.
+    app.addHook("onClose", async () => {
+      await consumer.close();
+      await publisher.close();
+    });
+  },
+  { name: "messaging" },
+);
 ```
 
-### Quick Setup on the Client Side
+Register it once, then publish from anywhere:
 
-Within any "endpoint" function, or if you have access to `fastify.rabbitmq` you can then call:
+```ts
+import messaging from "./plugins/messaging";
 
-```js
-fastify.get("/rabbitmq", async (request, reply) => {
-  let pub = request.rabbitmq.createPublisher({
-    confirm: true,
-    maxAttempts: 1,
-  });
+await app.register(messaging);
 
-  await pub.send("foo", "bar"); // ==> sent to foo queue
+app.post("/signup", async (request, reply) => {
+  await app.events.send(
+    { exchange: "events", routingKey: "user.created" },
+    request.body,
+  );
+  return { accepted: true };
 });
 ```
 
-Sending the string `bar` to the queue called `foo`.
+Why this shape works well:
 
-## Full Documentation
+- **One place owns messaging.** Connection, topology, publishers, consumers, and
+  shutdown live together; the rest of the app depends only on `app.events`.
+- **Startup declares, routes send.** Topology is declared once at boot, so the first
+  request never races a missing exchange.
+- **Lifecycle is handled.** The `onClose` hook closes the consumer and publisher with
+  the app — important for graceful shutdown and for tests that start and stop Fastify
+  repeatedly.
+- **Swappable.** Because routes only know `app.events`, you can change brokers, add a
+  [namespace](#5-multiple-connections-with-namespaces), or stub the decorator in a test
+  without touching route code.
 
-### Options
+> The types you need — `Publisher`, `Consumer`, `RPCClient`, `Connection`, `ConnectionOptions`,
+> `Envelope`, the message types, and the AMQP error classes — are re-exported from
+> `fastify-rabbitmq`. Import them from here, not from `rabbitmq-client`.
 
-```typescript
-export interface FastifyRabbitMQOptions {
-  /** Connection String or object pointing to the RabbitMQ Broker Services */
-  connection: string | ConnectionOptions;
-  /** To set the custom nNamespace within this plugin instance. Used to register this plugin more than one time. */
-  namespace?: string;
-}
-```
+## 📖 API Reference (`fastify.rabbitmq`)
+
+`app.rabbitmq` is a `rabbitmq-client` `Connection` (and, with namespaces, an index of them). The
+methods you will use most:
+
+| Method | Description |
+|---|---|
+| `createPublisher(options?)` | Create a `Publisher` (`.send(routingKey, body)`). |
+| `createConsumer(options, handler)` | Create a `Consumer` bound to a queue; `handler(msg)` runs per message. |
+| `createRPCClient(options?)` | Create an RPC client (`.send(queue, body)` returns the reply). |
+| `exchangeDeclare(params)` | Declare an exchange. |
+| `queueDeclare(params)` | Declare a queue. |
+| `queueBind(params)` | Bind a queue to an exchange. |
+| `acquire()` | Acquire a raw channel. |
+| `ready()` | Resolve once the connection is established. |
+| `close()` | Close the connection. |
+
+The full option shapes for each come from `rabbitmq-client` — see [External Libraries](#-external-libraries).
+
+## ⚙️ Plugin Options
+
+Pass these to `app.register(fastifyRabbitMQ, options)`:
+
+### `connection`
+
+A connection string (e.g. `"amqp://guest:guest@localhost"`) or a `ConnectionOptions` object from
+`rabbitmq-client` pointing at the broker. **Required.**
 
-#### FastifyRabbitMQOptions
+### `namespace`
 
-##### `connection`
+`string` — register the plugin more than once by giving each instance a unique namespace; the
+connection is then exposed at `app.rabbitmq.<namespace>`. Re-using a namespace fails to load.
 
-Connection String or object pointing to the RabbitMQ Broker Services.
-This can be an object of `ConnectionOptions` from the `node-rabbitmq-client` plugin options.
+## 🔌 External Libraries
 
-##### `namespace`
+This plugin documents only its own surface. For publisher/consumer/RPC options, connection options
+(`ConnectionOptions`), TLS, and reconnect behavior, see the package it wraps:
 
-If you need more than one "connection" to a different set and/or array of RabbitMQ servers,
-either on network or cloud, each registration of the plugin needs it to be in its own namespace.
-If the name space is duplicated, it will fail to load.
+- [`rabbitmq-client`](https://www.npmjs.com/package/rabbitmq-client) — the underlying AMQP client
+  (repo: [cody-greene/node-rabbitmq-client](https://github.com/cody-greene/node-rabbitmq-client)).
 
-## Acknowledgements
+## 🙏 Acknowledgements
 
-- [node-rabbitmq-client](https://www.npmjs.com/package/rabbitmq-client)
-- [fastify](https://fastify.dev/)
-- ... and my Wife and Baby Girl.
+- [`rabbitmq-client`](https://www.npmjs.com/package/rabbitmq-client)
+- [Fastify](https://fastify.dev/)
+- ...and my Wife and Baby Girl.
 
-## License
+## 📄 License
 
 Licensed under [MIT](./LICENSE).

package/{lib/esm → dist}/decorate.d.ts

@@ -4,10 +4,11 @@ export interface FastifyRabbitMQOptions {
      * @since 1.0.0
      * @remarks Connection String or object pointing to the RabbitMQ Broker Services
      */
-    connection: string | ConnectionOptions;
+    connection: ConnectionOptions | string;
     /**
      * @since 1.0.0
      * @remarks To set the custom nNamespace within this plugin instance. Used to register this plugin more than one time.
      */
     namespace?: string;
 }
+//# sourceMappingURL=decorate.d.ts.map

package/dist/decorate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decorate.d.ts","sourceRoot":"","sources":["../src/decorate.ts"],"names":[],"mappings":"AAsBA,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEpD,MAAM,WAAW,sBAAsB;IACrC;;;OAGG;IACH,UAAU,EAAE,iBAAiB,GAAG,MAAM,CAAC;IACvC;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB"}

package/{lib/types → dist}/errors.d.ts

@@ -12,3 +12,4 @@ export declare const errors: {
         code: "FASTIFY_RABBIT_MQ_ERR_USAGE";
     }, [any?, any?, any?]>;
 };
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAwBA,eAAO,MAAM,MAAM;IACjB,oEAAoE;;;;IAKpE,6DAA6D;;;;IAK7D,mEAAmE;;;;CAKpE,CAAC"}

package/dist/index.cjs

@@ -0,0 +1,139 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let fastify_plugin = require("fastify-plugin");
+fastify_plugin = __toESM(fastify_plugin);
+let rabbitmq_client = require("rabbitmq-client");
+let _fastify_error = require("@fastify/error");
+_fastify_error = __toESM(_fastify_error);
+//#region src/errors.ts
+const errors = {
+	/** Error if there is an invalid option used during registration. */
+	FASTIFY_RABBIT_MQ_ERR_INVALID_OPTS: (0, _fastify_error.default)("FASTIFY_RABBIT_MQ_ERR_INVALID_OPTS", "Invalid options: %s"),
+	/** Error if there is an setup error of the plugin itself. */
+	FASTIFY_RABBIT_MQ_ERR_SETUP_ERRORS: (0, _fastify_error.default)("FASTIFY_RABBIT_MQ_ERR_SETUP_ERRORS", "Setup error: %s"),
+	/** If an invalid usage error was done, this error would pop up. */
+	FASTIFY_RABBIT_MQ_ERR_USAGE: (0, _fastify_error.default)("FASTIFY_RABBIT_MQ_ERR_USAGE", "Usage error: %s")
+};
+//#endregion
+//#region src/validation.ts
+/**
+* Validate Options
+*
+* The plugin validates only the *shape* of `connection` -- that it is a
+* non-empty connection string or a `ConnectionOptions` object. Parsing the URL
+* and validating the broker options (hosts, TLS, reconnect, etc.) is delegated
+* to `rabbitmq-client`. The shape guard exists because `new Connection(...)`
+* accepts garbage (a number, an array, `null`, `{}`) without throwing and then
+* silently fails to connect at runtime; rejecting it here surfaces a clear
+* registration-time error instead.
+* @since 1.0.0
+* @param options
+*/
+const validateOpts = async (options) => {
+	const { connection } = options;
+	if (connection === void 0) throw new errors.FASTIFY_RABBIT_MQ_ERR_INVALID_OPTS("connection must be defined.");
+	if (typeof connection === "string") {
+		if (connection.length === 0) throw new errors.FASTIFY_RABBIT_MQ_ERR_INVALID_OPTS("connection string must not be empty.");
+		return;
+	}
+	if (!(typeof connection === "object" && connection !== null && !Array.isArray(connection))) throw new errors.FASTIFY_RABBIT_MQ_ERR_INVALID_OPTS("connection must be a connection string or a ConnectionOptions object.");
+};
+//#endregion
+//#region src/index.ts
+/**
+* How we talk with Fastify
+* @since 1.0.0
+* @param fastify
+* @param options
+* @param connection
+*/
+const decorateFastifyInstance = (fastify, options, connection) => {
+	const { namespace = "" } = options;
+	if (namespace !== void 0 && namespace !== "") fastify.log.debug("[fastify-rabbitmq] Namespace Attempt: %s", namespace);
+	if (namespace !== void 0 && namespace !== "") {
+		if (fastify.rabbitmq === void 0) fastify.decorate("rabbitmq", Object.create(null));
+		if (fastify.rabbitmq[namespace] !== void 0) throw new errors.FASTIFY_RABBIT_MQ_ERR_SETUP_ERRORS(`Already registered with namespace: ${namespace}`);
+		fastify.log.trace(`[fastify-rabbitmq] Decorate Fastify with Namespace: ${namespace}`);
+		fastify.rabbitmq[namespace] = connection;
+	} else if (fastify.rabbitmq !== void 0) throw new errors.FASTIFY_RABBIT_MQ_ERR_SETUP_ERRORS("Already registered.");
+	if (fastify.rabbitmq === void 0) {
+		fastify.log.trace("[fastify-rabbitmq] Decorate Fastify");
+		fastify.decorate("rabbitmq", connection);
+	}
+};
+/**
+* Main Function
+* @since 1.0.0
+* @example
+* This is the basics on how to use this plugin:
+* ```js
+* app.register(fastifyRabbit, {
+*  connection: 'amqp://guest:guest@localhost'
+* })
+* ```
+* This will allow you to read from your Fastify "object" and
+* use this plugin at the "rabbitmq" level. From there you can execute and maintain
+* the RabbitMQ Connection using the 'rabbitmq-client' package, which is wrapping around
+* this plugin to execute functions it provides.
+*
+* @see [https://cody-greene.github.io/node-rabbitmq-client/latest/index.html](https://cody-greene.github.io/node-rabbitmq-client/latest/index.html)
+*
+*/
+const fastifyRabbit = (0, fastify_plugin.default)(async (fastify, opts) => {
+	await validateOpts(opts);
+	const { connection } = opts;
+	decorateFastifyInstance(fastify, opts, new rabbitmq_client.Connection(connection));
+});
+//#endregion
+Object.defineProperty(exports, "AMQPChannelError", {
+	enumerable: true,
+	get: function() {
+		return rabbitmq_client.AMQPChannelError;
+	}
+});
+Object.defineProperty(exports, "AMQPConnectionError", {
+	enumerable: true,
+	get: function() {
+		return rabbitmq_client.AMQPConnectionError;
+	}
+});
+Object.defineProperty(exports, "AMQPError", {
+	enumerable: true,
+	get: function() {
+		return rabbitmq_client.AMQPError;
+	}
+});
+Object.defineProperty(exports, "ConsumerStatus", {
+	enumerable: true,
+	get: function() {
+		return rabbitmq_client.ConsumerStatus;
+	}
+});
+exports.decorateFastifyInstance = decorateFastifyInstance;
+exports.default = fastifyRabbit;
+
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["RabbitMQConnection"],"sources":["../src/errors.ts","../src/validation.ts","../src/index.ts"],"sourcesContent":["/*\nMIT License\n\nCopyright (c) 2026 Shane Froebel\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.\n*/\nimport createError from \"@fastify/error\";\n\nexport const errors = {\n  /** Error if there is an invalid option used during registration. */\n  FASTIFY_RABBIT_MQ_ERR_INVALID_OPTS: createError(\n    \"FASTIFY_RABBIT_MQ_ERR_INVALID_OPTS\",\n    \"Invalid options: %s\",\n  ),\n  /** Error if there is an setup error of the plugin itself. */\n  FASTIFY_RABBIT_MQ_ERR_SETUP_ERRORS: createError(\n    \"FASTIFY_RABBIT_MQ_ERR_SETUP_ERRORS\",\n    \"Setup error: %s\",\n  ),\n  /** If an invalid usage error was done, this error would pop up. */\n  FASTIFY_RABBIT_MQ_ERR_USAGE: createError(\n    \"FASTIFY_RABBIT_MQ_ERR_USAGE\",\n    \"Usage error: %s\",\n  ),\n};\n","/*\nMIT License\n\nCopyright (c) 2026 Shane Froebel\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.\n*/\nimport { FastifyRabbitMQOptions } from \"./decorate\";\nimport { errors } from \"./errors\";\n\n/**\n * Validate Options\n *\n * The plugin validates only the *shape* of `connection` -- that it is a\n * non-empty connection string or a `ConnectionOptions` object. Parsing the URL\n * and validating the broker options (hosts, TLS, reconnect, etc.) is delegated\n * to `rabbitmq-client`. The shape guard exists because `new Connection(...)`\n * accepts garbage (a number, an array, `null`, `{}`) without throwing and then\n * silently fails to connect at runtime; rejecting it here surfaces a clear\n * registration-time error instead.\n * @since 1.0.0\n * @param options\n */\nexport const validateOpts = async (\n  options: FastifyRabbitMQOptions,\n): Promise<void> => {\n  const { connection } = options;\n\n  // Mandatory\n  if (connection === undefined) {\n    throw new errors.FASTIFY_RABBIT_MQ_ERR_INVALID_OPTS(\n      \"connection must be defined.\",\n    );\n  }\n\n  if (typeof connection === \"string\") {\n    if (connection.length === 0) {\n      throw new errors.FASTIFY_RABBIT_MQ_ERR_INVALID_OPTS(\n        \"connection string must not be empty.\",\n      );\n    }\n    return;\n  }\n\n  const isConnectionOptions =\n    typeof connection === \"object\" &&\n    connection !== null &&\n    !Array.isArray(connection);\n\n  if (!isConnectionOptions) {\n    throw new errors.FASTIFY_RABBIT_MQ_ERR_INVALID_OPTS(\n      \"connection must be a connection string or a ConnectionOptions object.\",\n    );\n  }\n};\n","/*\nMIT License\n\nCopyright (c) 2026 Shane Froebel\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.\n*/\nimport { FastifyInstance } from \"fastify\";\nimport fp from \"fastify-plugin\";\nimport { Connection as RabbitMQConnection } from \"rabbitmq-client\";\n\nimport { FastifyRabbitMQOptions } from \"./decorate\";\nimport { errors } from \"./errors\";\nimport { validateOpts } from \"./validation\";\nexport { type FastifyRabbitMQOptions } from \"./decorate\";\n\n/**\n * How we talk with Fastify\n * @since 1.0.0\n * @param fastify\n * @param options\n * @param connection\n */\nconst decorateFastifyInstance = (\n  fastify: FastifyInstance,\n  options: FastifyRabbitMQOptions,\n  connection: any,\n): void => {\n  const { namespace = \"\" } = options;\n\n  if (namespace !== undefined && namespace !== \"\") {\n    fastify.log.debug(\"[fastify-rabbitmq] Namespace Attempt: %s\", namespace);\n  }\n  if (namespace !== undefined && namespace !== \"\") {\n    if (fastify.rabbitmq === undefined) {\n      fastify.decorate(\"rabbitmq\", Object.create(null));\n    }\n\n    if (fastify.rabbitmq[namespace] !== undefined) {\n      throw new errors.FASTIFY_RABBIT_MQ_ERR_SETUP_ERRORS(\n        `Already registered with namespace: ${namespace}`,\n      );\n    }\n\n    fastify.log.trace(\n      `[fastify-rabbitmq] Decorate Fastify with Namespace: ${namespace}`,\n    );\n    fastify.rabbitmq[namespace] = connection;\n  } else {\n    if (fastify.rabbitmq !== undefined) {\n      throw new errors.FASTIFY_RABBIT_MQ_ERR_SETUP_ERRORS(\n        \"Already registered.\",\n      );\n    }\n  }\n\n  if (fastify.rabbitmq === undefined) {\n    fastify.log.trace(\"[fastify-rabbitmq] Decorate Fastify\");\n    fastify.decorate(\"rabbitmq\", connection);\n  }\n};\n\n/**\n * Main Function\n * @since 1.0.0\n * @example\n * This is the basics on how to use this plugin:\n * ```js\n * app.register(fastifyRabbit, {\n *  connection: 'amqp://guest:guest@localhost'\n * })\n * ```\n * This will allow you to read from your Fastify \"object\" and\n * use this plugin at the \"rabbitmq\" level. From there you can execute and maintain\n * the RabbitMQ Connection using the 'rabbitmq-client' package, which is wrapping around\n * this plugin to execute functions it provides.\n *\n * @see [https://cody-greene.github.io/node-rabbitmq-client/latest/index.html](https://cody-greene.github.io/node-rabbitmq-client/latest/index.html)\n *\n */\nconst fastifyRabbit = fp<FastifyRabbitMQOptions>(async (fastify, opts) => {\n  await validateOpts(opts);\n\n  const { connection } = opts;\n\n  const c = new RabbitMQConnection(connection);\n\n  decorateFastifyInstance(fastify, opts, c);\n});\n\nexport default fastifyRabbit;\n\nexport { decorateFastifyInstance };\n\nexport * from \"./types\";\n\n// Re-export the rabbitmq-client surface so consumers import from this package\n// instead of reaching for the wrapped client. These are the exact types the\n// app.rabbitmq decorator hands back, so they stay correct without owning a\n// parallel definition.\nexport type {\n  AsyncMessage,\n  Channel,\n  Connection,\n  ConnectionOptions,\n  Consumer,\n  ConsumerHandler,\n  ConsumerProps,\n  Envelope,\n  HeaderFields,\n  MessageBody,\n  Publisher,\n  PublisherProps,\n  ReturnedMessage,\n  RPCClient,\n  RPCProps,\n  SyncMessage,\n} from \"rabbitmq-client\";\nexport {\n  AMQPChannelError,\n  AMQPConnectionError,\n  AMQPError,\n  ConsumerStatus,\n} from \"rabbitmq-client\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,MAAa,SAAS;;CAEpB,qCAAA,GAAA,eAAA,QAAA,CACE,sCACA,qBACF;;CAEA,qCAAA,GAAA,eAAA,QAAA,CACE,sCACA,iBACF;;CAEA,8BAAA,GAAA,eAAA,QAAA,CACE,+BACA,iBACF;AACF;;;;;;;;;;;;;;;;ACFA,MAAa,eAAe,OAC1B,YACkB;CAClB,MAAM,EAAE,eAAe;CAGvB,IAAI,eAAe,KAAA,GACjB,MAAM,IAAI,OAAO,mCACf,6BACF;CAGF,IAAI,OAAO,eAAe,UAAU;EAClC,IAAI,WAAW,WAAW,GACxB,MAAM,IAAI,OAAO,mCACf,sCACF;EAEF;CACF;CAOA,IAAI,EAJF,OAAO,eAAe,YACtB,eAAe,QACf,CAAC,MAAM,QAAQ,UAAU,IAGzB,MAAM,IAAI,OAAO,mCACf,uEACF;AAEJ;;;;;;;;;;AC/BA,MAAM,2BACJ,SACA,SACA,eACS;CACT,MAAM,EAAE,YAAY,OAAO;CAE3B,IAAI,cAAc,KAAA,KAAa,cAAc,IAC3C,QAAQ,IAAI,MAAM,4CAA4C,SAAS;CAEzE,IAAI,cAAc,KAAA,KAAa,cAAc,IAAI;EAC/C,IAAI,QAAQ,aAAa,KAAA,GACvB,QAAQ,SAAS,YAAY,OAAO,OAAO,IAAI,CAAC;EAGlD,IAAI,QAAQ,SAAS,eAAe,KAAA,GAClC,MAAM,IAAI,OAAO,mCACf,sCAAsC,WACxC;EAGF,QAAQ,IAAI,MACV,uDAAuD,WACzD;EACA,QAAQ,SAAS,aAAa;CAChC,OACE,IAAI,QAAQ,aAAa,KAAA,GACvB,MAAM,IAAI,OAAO,mCACf,qBACF;CAIJ,IAAI,QAAQ,aAAa,KAAA,GAAW;EAClC,QAAQ,IAAI,MAAM,qCAAqC;EACvD,QAAQ,SAAS,YAAY,UAAU;CACzC;AACF;;;;;;;;;;;;;;;;;;;AAoBA,MAAM,iBAAA,GAAA,eAAA,QAAA,CAA2C,OAAO,SAAS,SAAS;CACxE,MAAM,aAAa,IAAI;CAEvB,MAAM,EAAE,eAAe;CAIvB,wBAAwB,SAAS,MAAM,IAFzBA,gBAAAA,WAAmB,UAEM,CAAC;AAC1C,CAAC"}

package/{lib/esm → dist}/index.d.ts

@@ -1,7 +1,13 @@
 import { FastifyInstance } from "fastify";
-import { ConnectionOptions } from "rabbitmq-client";
-import { FastifyRabbitMQOptions } from "./decorate.js";
-export * from "./types.js";
+import { FastifyRabbitMQOptions } from "./decorate";
+export { type FastifyRabbitMQOptions } from "./decorate";
+/**
+ * How we talk with Fastify
+ * @since 1.0.0
+ * @param fastify
+ * @param options
+ * @param connection
+ */
 declare const decorateFastifyInstance: (fastify: FastifyInstance, options: FastifyRabbitMQOptions, connection: any) => void;
 /**
  * Main Function
@@ -23,4 +29,8 @@ declare const decorateFastifyInstance: (fastify: FastifyInstance, options: Fasti
  */
 declare const fastifyRabbit: import("fastify").FastifyPluginCallback<FastifyRabbitMQOptions, import("fastify").RawServerDefault, import("fastify").FastifyTypeProviderDefault, import("fastify").FastifyBaseLogger>;
 export default fastifyRabbit;
-export { decorateFastifyInstance, FastifyRabbitMQOptions, ConnectionOptions };
+export { decorateFastifyInstance };
+export * from "./types";
+export type { AsyncMessage, Channel, Connection, ConnectionOptions, Consumer, ConsumerHandler, ConsumerProps, Envelope, HeaderFields, MessageBody, Publisher, PublisherProps, ReturnedMessage, RPCClient, RPCProps, SyncMessage, } from "rabbitmq-client";
+export { AMQPChannelError, AMQPConnectionError, AMQPError, ConsumerStatus, } from "rabbitmq-client";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAsBA,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAI1C,OAAO,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAGpD,OAAO,EAAE,KAAK,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAEzD;;;;;;GAMG;AACH,QAAA,MAAM,uBAAuB,GAC3B,SAAS,eAAe,EACxB,SAAS,sBAAsB,EAC/B,YAAY,GAAG,KACd,IAiCF,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,QAAA,MAAM,aAAa,wLAQjB,CAAC;AAEH,eAAe,aAAa,CAAC;AAE7B,OAAO,EAAE,uBAAuB,EAAE,CAAC;AAEnC,cAAc,SAAS,CAAC;AAMxB,YAAY,EACV,YAAY,EACZ,OAAO,EACP,UAAU,EACV,iBAAiB,EACjB,QAAQ,EACR,eAAe,EACf,aAAa,EACb,QAAQ,EACR,YAAY,EACZ,WAAW,EACX,SAAS,EACT,cAAc,EACd,eAAe,EACf,SAAS,EACT,QAAQ,EACR,WAAW,GACZ,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,gBAAgB,EAChB,mBAAmB,EACnB,SAAS,EACT,cAAc,GACf,MAAM,iBAAiB,CAAC"}