fastify-rabbitmq 3.3.0 → 3.4.1

package/CHANGELOG.md

@@ -0,0 +1,91 @@
+# Fastify RabbitMQ
+
+## v3.4.1 - 2026-09-26
+
+### What Changed 👀
+
+#### 🐛 Bug Fixes
+
+- fix: close the RabbitMQ connection when the Fastify app closes @Bugs5382 (#166)
+- fix(test): stop declaring transient non-exclusive queues so tests pass on RabbitMQ 4 @Bugs5382 (#165)
+- fix(build): keep source maps out of the npm package @Bugs5382 (#163)
+
+#### 📄 Documentation
+
+- docs(readme): apply the lite emoji treatment @Bugs5382 (#158)
+
+#### 🧩 Dependency Updates
+
+- build(deps): bump the github-actions group with 9 updates @[dependabot[bot]](https://github.com/apps/dependabot) (#143)
+
+### Extra
+
+**Full Changelog**: https://github.com/Bugs5382/fastify-rabbitmq/compare/v3.4.0...v3.4.1
+
+## 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 👀
+
+#### 🧩 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,304 @@
-# 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.
 
-The build exports this to valid ESM and CJS for ease of cross-compatibility.
+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).
 
-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.
+The build exports valid ESM and CJS for cross-compatibility.
 
-## Table of Contents
+If you use this package, please consider giving it a ⭐ — it raises visibility and brings in more
+contribution from the outside.
 
-1. [Install](#install)
-2. [Basic Usage](#basic-usage)
-3. [Full Documentation](#full-documentation)
-   1. [Options](#options)
-4. [Acknowledgements](#acknowledgements)
-5. [License](#license)
+> 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).
 
-## Install
+> 🟢 **Requires Node.js ≥ 20.15.**
 
-```
+## 📑 Table of Contents
+
+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
+
+```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.
+
+The plugin owns the connection's lifecycle:
+
+- **`app.close()` closes the connection** (each one, with namespaces), so the process can exit.
+  Close your own consumers and publishers in an `onClose` hook, as in
+  [recipe 6](#6-encapsulate-messaging-in-your-own-plugin).
+- **Connection errors are logged, not thrown.** If the broker is down or drops the connection,
+  the error goes to `app.log.error` and `rabbitmq-client` keeps reconnecting in the background.
+  The app does not crash. Add your own `app.rabbitmq.on("error", ...)` listener if you need to
+  react to it.
+
+## 🧩 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`:
 
-Register this as a plugin.
-Make sure it is loaded before any **_routes_** are loaded.
+```ts
+app.get("/publish", async (request, reply) => {
+  const publisher = request.server.rabbitmq.createPublisher({ confirm: true });
+  await publisher.send("foo", "bar");
+  return { sent: true };
+});
+```
 
-### Quick Setup on the Server Side
+### 2. Consume a queue
 
-```typescript
-export default fp<FastifyRabbitMQOptions>((fastify, options, done) => {
-  void fastify.register(fastifyRabbit, {
-    connection: `amqp://guest:guest@localhost`,
-  });
+```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");
+```
 
-  void fastify.ready().then(async () => {
-    const consumer = fastify.rabbitmq.createConsumer(
+### 4. Declare exchanges, queues, and bindings
+
+```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";
+
+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",
+    });
+
+    // 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" }],
+    });
+
+    // 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. Close the consumer and publisher with the app. The plugin then
+    //    closes the connection itself, after this hook has released the
+    //    channels, so app.close() resolves and the process can exit.
+    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, and
+  the plugin closes the connection, all with `app.close()` — 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. |
+| `onConnect(timeout?)` | Resolve once the connection is established. |
+| `ready` | `true` while the connection is established and unblocked. |
+| `close()` | Close the connection. `app.close()` already does this for you. |
+
+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/dist/decorate.d.ts

@@ -0,0 +1,13 @@
+import { ConnectionOptions } from "rabbitmq-client";
+export interface FastifyRabbitMQOptions {
+    /**
+     * @since 1.0.0
+     * @remarks Connection String or object pointing to the RabbitMQ Broker Services
+     */
+    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;
+}

package/dist/errors.d.ts

@@ -0,0 +1,14 @@
+export declare const errors: {
+    /** Error if there is an invalid option used during registration. */
+    FASTIFY_RABBIT_MQ_ERR_INVALID_OPTS: import("@fastify/error").FastifyErrorConstructor<{
+        code: "FASTIFY_RABBIT_MQ_ERR_INVALID_OPTS";
+    }, [any?, any?, any?]>;
+    /** Error if there is an setup error of the plugin itself. */
+    FASTIFY_RABBIT_MQ_ERR_SETUP_ERRORS: import("@fastify/error").FastifyErrorConstructor<{
+        code: "FASTIFY_RABBIT_MQ_ERR_SETUP_ERRORS";
+    }, [any?, any?, any?]>;
+    /** If an invalid usage error was done, this error would pop up. */
+    FASTIFY_RABBIT_MQ_ERR_USAGE: import("@fastify/error").FastifyErrorConstructor<{
+        code: "FASTIFY_RABBIT_MQ_ERR_USAGE";
+    }, [any?, any?, any?]>;
+};

package/dist/index.cjs

@@ -0,0 +1,175 @@
+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 || !__hasOwnProp.call(mod, "default") ? __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, namespace = "" } = opts;
+	const label = namespace === "" ? "(default)" : namespace;
+	fastify.log.debug("[fastify-rabbitmq] Creating connection for namespace %s", label);
+	const c = new rabbitmq_client.Connection(connection);
+	watchConnection(fastify, c, label);
+	decorateFastifyInstance(fastify, opts, c);
+	fastify.addHook("onClose", async () => {
+		const started = Date.now();
+		fastify.log.debug("[fastify-rabbitmq] Closing connection for namespace %s", label);
+		try {
+			await c.close();
+			fastify.log.info("[fastify-rabbitmq] Connection for namespace %s closed in %dms", label, Date.now() - started);
+		} catch (error) {
+			fastify.log.error({ err: error }, "[fastify-rabbitmq] Failed to close connection for namespace %s", label);
+		}
+	});
+});
+/**
+* Log the connection's lifecycle events. The 'error' listener also keeps a
+* refused or dropped connection from becoming an unhandled 'error' event,
+* which would crash the process (#164). rabbitmq-client keeps retrying in the
+* background, so an error here is reported, not fatal.
+* @since 3.4.1
+* @param fastify
+* @param c
+* @param label
+*/
+const watchConnection = (fastify, c, label) => {
+	c.on("error", (err) => {
+		fastify.log.error({ err }, "[fastify-rabbitmq] RabbitMQ connection error for namespace %s", label);
+	});
+	c.on("connection", () => {
+		fastify.log.info("[fastify-rabbitmq] RabbitMQ connection established for namespace %s", label);
+	});
+	c.on("connection.blocked", (reason) => {
+		fastify.log.warn("[fastify-rabbitmq] RabbitMQ connection blocked for namespace %s: %s", label, reason);
+	});
+	c.on("connection.unblocked", () => {
+		fastify.log.info("[fastify-rabbitmq] RabbitMQ connection unblocked for namespace %s", label);
+	});
+};
+//#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;

package/dist/index.d.ts

@@ -0,0 +1,35 @@
+import { FastifyInstance } from "fastify";
+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
+ * @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)
+ *
+ */
+declare const fastifyRabbit: import("fastify").FastifyPluginCallback<FastifyRabbitMQOptions, import("fastify").RawServerDefault, import("fastify").FastifyTypeProviderDefault, import("fastify").FastifyBaseLogger>;
+export default fastifyRabbit;
+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";

package/dist/index.mjs

@@ -0,0 +1,122 @@
+import fp from "fastify-plugin";
+import { AMQPChannelError, AMQPConnectionError, AMQPError, Connection, ConsumerStatus } from "rabbitmq-client";
+import createError from "@fastify/error";
+//#region src/errors.ts
+const errors = {
+	/** Error if there is an invalid option used during registration. */
+	FASTIFY_RABBIT_MQ_ERR_INVALID_OPTS: createError("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: createError("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: createError("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 = fp(async (fastify, opts) => {
+	await validateOpts(opts);
+	const { connection, namespace = "" } = opts;
+	const label = namespace === "" ? "(default)" : namespace;
+	fastify.log.debug("[fastify-rabbitmq] Creating connection for namespace %s", label);
+	const c = new Connection(connection);
+	watchConnection(fastify, c, label);
+	decorateFastifyInstance(fastify, opts, c);
+	fastify.addHook("onClose", async () => {
+		const started = Date.now();
+		fastify.log.debug("[fastify-rabbitmq] Closing connection for namespace %s", label);
+		try {
+			await c.close();
+			fastify.log.info("[fastify-rabbitmq] Connection for namespace %s closed in %dms", label, Date.now() - started);
+		} catch (error) {
+			fastify.log.error({ err: error }, "[fastify-rabbitmq] Failed to close connection for namespace %s", label);
+		}
+	});
+});
+/**
+* Log the connection's lifecycle events. The 'error' listener also keeps a
+* refused or dropped connection from becoming an unhandled 'error' event,
+* which would crash the process (#164). rabbitmq-client keeps retrying in the
+* background, so an error here is reported, not fatal.
+* @since 3.4.1
+* @param fastify
+* @param c
+* @param label
+*/
+const watchConnection = (fastify, c, label) => {
+	c.on("error", (err) => {
+		fastify.log.error({ err }, "[fastify-rabbitmq] RabbitMQ connection error for namespace %s", label);
+	});
+	c.on("connection", () => {
+		fastify.log.info("[fastify-rabbitmq] RabbitMQ connection established for namespace %s", label);
+	});
+	c.on("connection.blocked", (reason) => {
+		fastify.log.warn("[fastify-rabbitmq] RabbitMQ connection blocked for namespace %s: %s", label, reason);
+	});
+	c.on("connection.unblocked", () => {
+		fastify.log.info("[fastify-rabbitmq] RabbitMQ connection unblocked for namespace %s", label);
+	});
+};
+//#endregion
+export { AMQPChannelError, AMQPConnectionError, AMQPError, ConsumerStatus, decorateFastifyInstance, fastifyRabbit as default };

package/dist/types.d.ts

@@ -0,0 +1,12 @@
+import { Connection as RabbitMQConnection } from "rabbitmq-client";
+declare module "fastify" {
+    interface FastifyInstance {
+        /** Main Decorator for Fastify **/
+        rabbitmq: fastifyRabbitMQ.FastifyRabbitMQNO & RabbitMQConnection;
+    }
+}
+export declare namespace fastifyRabbitMQ {
+    interface FastifyRabbitMQNO {
+        [namespace: string]: RabbitMQConnection;
+    }
+}

package/dist/validation.d.ts

@@ -0,0 +1,15 @@
+import { FastifyRabbitMQOptions } from "./decorate";
+/**
+ * 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
+ */
+export declare const validateOpts: (options: FastifyRabbitMQOptions) => Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify-rabbitmq",
-  "version": "3.3.0",
+  "version": "3.4.1",
   "description": "A Fastify RabbitMQ Plugin Developed in Pure TypeScript.",
   "keywords": [
     "rabbitmq-client",
@@ -21,32 +21,35 @@
   "author": "Shane Froebel",
   "exports": {
     ".": {
-      "types": "./lib/types/index.d.ts",
-      "import": "./lib/esm/index.mjs",
-      "require": "./lib/cjs/index.js",
-      "default": "./lib/cjs/index.js"
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.cjs"
+      }
     }
   },
-  "main": "./lib/cjs/index.js",
-  "module": "./lib/esm/index.mjs",
-  "types": "./lib/types/index.d.ts",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
   "files": [
-    "lib/",
+    "dist",
     "README.md",
-    "LICENSE"
+    "LICENSE",
+    "CHANGELOG.md"
   ],
   "scripts": {
-    "build": "tsup",
-    "build:dev": "NODE_ENV=development tsup",
-    "clean": "rm -rf coverage docs lib temp",
-    "format:check": "prettier --check '**/*.{md,ts,json,mts}'",
-    "format:write": "prettier --write '**/*.{md,ts,json,mts}'",
-    "lint": "npm run lint:npm && eslint | snazzy && npm run format:check",
-    "lint:fix": "npm run lint:npm && eslint --fix | snazzy && npm run format:write",
+    "build": "tsdown && tsc --emitDeclarationOnly",
+    "check:pack": "node scripts/checkPack.mjs",
+    "clean": "rm -rf coverage docs dist temp",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
     "lint:npm": "npmPkgJsonLint .",
     "lint:package": "npx sort-package-json",
     "pack": "npm pack",
-    "prepublishOnly": "npm run clean && npm run build && npm run pack",
+    "prepublishOnly": "npm run clean && npm run build",
     "test": "vitest run",
     "test:coverage": "vitest --coverage",
     "test:verbose": "vitest run --reporter verbose",
@@ -54,16 +57,17 @@
     "typedoc": "typedoc",
     "typedoc:watch": "typedoc -watch",
     "update": "npx npm-check-updates -u --enginesNode && npm run update:post-update",
-    "update:post-update": "npm install && npm run test"
+    "update:post-update": "npm install && npm run test",
+    "build:watch": "tsdown --watch",
+    "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@fastify/error": "^4.1.0",
-    "fastify-plugin": "^5.0.1",
-    "rabbitmq-client": "^5.0.4"
+    "@fastify/error": "^4.2.0",
+    "fastify-plugin": "^5.1.0",
+    "rabbitmq-client": "^5.0.8"
   },
   "devDependencies": {
     "@eslint/js": "^9.28.0",
-    "@ianvs/prettier-plugin-sort-imports": "^4.4.2",
     "@shipgirl/typedoc-plugin-versions": "^0.3.1",
     "@types/node": "^22.15.29",
     "@typescript-eslint/eslint-plugin": "^8.33.0",
@@ -71,27 +75,25 @@
     "@vitest/coverage-v8": "^3.1.4",
     "@vitest/ui": "^3.1.4",
     "eslint": "^9.28.0",
-    "eslint-config-prettier": "^10.1.5",
-    "eslint-plugin-prettier": "^5.4.1",
     "eslint-plugin-sort-class-members": "^1.21.0",
     "fastify": "^5.3.3",
     "npm-check-updates": "^18.0.1",
     "npm-package-json-lint": "^8.0.0",
     "npm-package-json-lint-config-default": "^7.0.1",
     "pre-commit": "^1.2.2",
-    "prettier-plugin-organize-imports": "^4.1.0",
     "snazzy": "^9.0.0",
     "sort-package-json": "^3.2.1",
     "ts-node": "^10.9.2",
     "tsd": "^0.32.0",
-    "tsup": "^8.5.0",
     "typedoc": "^0.28.5",
     "typescript": "^5.8.3",
     "typescript-eslint": "^8.33.0",
-    "vitest": "^3.1.4"
+    "vitest": "^3.1.4",
+    "@the-rabbit-hole/eslint-config": "^0.4.0",
+    "tsdown": "^0.22.2"
   },
   "engines": {
-    "node": ">=20.11.0"
+    "node": ">=20.15.0"
   },
   "precommit": [
     "test",

package/lib/cjs/index.js

@@ -1,115 +0,0 @@
-"use strict";
-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 __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  decorateFastifyInstance: () => decorateFastifyInstance,
-  default: () => index_default
-});
-module.exports = __toCommonJS(index_exports);
-var import_fastify_plugin = __toESM(require("fastify-plugin"));
-var import_rabbitmq_client = require("rabbitmq-client");
-
-// src/errors.ts
-var import_error = __toESM(require("@fastify/error"));
-var errors = {
-  /** Error if there is an invalid option used during registration. */
-  FASTIFY_RABBIT_MQ_ERR_INVALID_OPTS: (0, import_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, import_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, import_error.default)(
-    "FASTIFY_RABBIT_MQ_ERR_USAGE",
-    "Usage error: %s"
-  )
-};
-
-// src/validation.ts
-var validateOpts = async (options) => {
-  if (typeof options.connection === "undefined") {
-    throw new errors.FASTIFY_RABBIT_MQ_ERR_INVALID_OPTS(
-      "connection or findServers must be defined."
-    );
-  }
-  if (typeof options.connection !== "undefined") {
-    if (typeof options.connection !== "object") {
-    }
-  }
-};
-
-// src/index.ts
-var decorateFastifyInstance = (fastify, options, connection) => {
-  const { namespace = "" } = options;
-  if (typeof namespace !== "undefined" && namespace !== "") {
-    fastify.log.debug("[fastify-rabbitmq] Namespace Attempt: %s", namespace);
-  }
-  if (typeof namespace !== "undefined" && namespace !== "") {
-    if (typeof fastify.rabbitmq === "undefined") {
-      fastify.decorate("rabbitmq", /* @__PURE__ */ Object.create(null));
-    }
-    if (typeof fastify.rabbitmq[namespace] !== "undefined") {
-      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 (typeof fastify.rabbitmq !== "undefined") {
-      throw new errors.FASTIFY_RABBIT_MQ_ERR_SETUP_ERRORS(
-        "Already registered."
-      );
-    }
-  }
-  if (typeof fastify.rabbitmq === "undefined") {
-    fastify.log.trace("[fastify-rabbitmq] Decorate Fastify");
-    fastify.decorate("rabbitmq", connection);
-  }
-};
-var fastifyRabbit = (0, import_fastify_plugin.default)(async (fastify, opts) => {
-  await validateOpts(opts);
-  const { connection } = opts;
-  const c = new import_rabbitmq_client.Connection(connection);
-  decorateFastifyInstance(fastify, opts, c);
-});
-var index_default = fastifyRabbit;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  decorateFastifyInstance
-});

package/lib/esm/index.mjs

@@ -1,82 +0,0 @@
-// src/index.ts
-import fp from "fastify-plugin";
-import {
-  Connection as RabbitMQConnection
-} from "rabbitmq-client";
-
-// src/errors.ts
-import createError from "@fastify/error";
-var errors = {
-  /** Error if there is an invalid option used during registration. */
-  FASTIFY_RABBIT_MQ_ERR_INVALID_OPTS: createError(
-    "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: createError(
-    "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: createError(
-    "FASTIFY_RABBIT_MQ_ERR_USAGE",
-    "Usage error: %s"
-  )
-};
-
-// src/validation.ts
-var validateOpts = async (options) => {
-  if (typeof options.connection === "undefined") {
-    throw new errors.FASTIFY_RABBIT_MQ_ERR_INVALID_OPTS(
-      "connection or findServers must be defined."
-    );
-  }
-  if (typeof options.connection !== "undefined") {
-    if (typeof options.connection !== "object") {
-    }
-  }
-};
-
-// src/index.ts
-var decorateFastifyInstance = (fastify, options, connection) => {
-  const { namespace = "" } = options;
-  if (typeof namespace !== "undefined" && namespace !== "") {
-    fastify.log.debug("[fastify-rabbitmq] Namespace Attempt: %s", namespace);
-  }
-  if (typeof namespace !== "undefined" && namespace !== "") {
-    if (typeof fastify.rabbitmq === "undefined") {
-      fastify.decorate("rabbitmq", /* @__PURE__ */ Object.create(null));
-    }
-    if (typeof fastify.rabbitmq[namespace] !== "undefined") {
-      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 (typeof fastify.rabbitmq !== "undefined") {
-      throw new errors.FASTIFY_RABBIT_MQ_ERR_SETUP_ERRORS(
-        "Already registered."
-      );
-    }
-  }
-  if (typeof fastify.rabbitmq === "undefined") {
-    fastify.log.trace("[fastify-rabbitmq] Decorate Fastify");
-    fastify.decorate("rabbitmq", connection);
-  }
-};
-var fastifyRabbit = fp(async (fastify, opts) => {
-  await validateOpts(opts);
-  const { connection } = opts;
-  const c = new RabbitMQConnection(connection);
-  decorateFastifyInstance(fastify, opts, c);
-});
-var index_default = fastifyRabbit;
-export {
-  decorateFastifyInstance,
-  index_default as default
-};

package/lib/types/index.d.ts

@@ -1,59 +0,0 @@
-import * as fastify from 'fastify';
-import { FastifyInstance } from 'fastify';
-import { ConnectionOptions, Connection } from 'rabbitmq-client';
-export { ConnectionOptions } from 'rabbitmq-client';
-
-interface FastifyRabbitMQOptions {
-    /**
-     * @since 1.0.0
-     * @remarks Connection String or object pointing to the RabbitMQ Broker Services
-     */
-    connection: string | ConnectionOptions;
-    /**
-     * @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;
-}
-
-declare module "fastify" {
-    interface FastifyInstance {
-        /** Main Decorator for Fastify **/
-        rabbitmq: Connection & fastifyRabbitMQ.FastifyRabbitMQNO;
-    }
-}
-declare namespace fastifyRabbitMQ {
-    interface FastifyRabbitMQNO {
-        [namespace: string]: Connection;
-    }
-}
-
-/**
- * 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
- * @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)
- *
- */
-declare const fastifyRabbit: fastify.FastifyPluginCallback<FastifyRabbitMQOptions, fastify.RawServerDefault, fastify.FastifyTypeProviderDefault, fastify.FastifyBaseLogger>;
-
-export { type FastifyRabbitMQOptions, decorateFastifyInstance, fastifyRabbit as default, fastifyRabbitMQ };