amqp-resilient 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 berkeerdo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,257 @@
+# amqp-resilient
+
+[![npm version](https://img.shields.io/npm/v/amqp-resilient.svg)](https://www.npmjs.com/package/amqp-resilient)
+[![npm downloads](https://img.shields.io/npm/dm/amqp-resilient.svg)](https://www.npmjs.com/package/amqp-resilient)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.0+-blue.svg)](https://www.typescriptlang.org/)
+[![Node.js](https://img.shields.io/badge/Node.js-18+-green.svg)](https://nodejs.org/)
+
+Production-ready AMQP client for Node.js with built-in resilience patterns.
+
+## Features
+
+- **Auto-Reconnection** - Exponential backoff with jitter for stable reconnects
+- **Circuit Breaker** - Prevent cascading failures with configurable thresholds
+- **Retry with DLQ** - Failed messages retry with backoff, then route to Dead Letter Queue
+- **Publisher Confirms** - Guaranteed message delivery with confirmation
+- **Health Monitoring** - Built-in health checks for all connections
+- **TypeScript** - Full type safety with generics support
+- **ESM** - Native ES modules support
+- **Zero Dependencies** - Only amqplib as peer dependency
+
+## Installation
+
+```bash
+npm install amqp-resilient amqplib
+```
+
+## Quick Start
+
+### Connection
+
+```typescript
+import { ConnectionManager } from 'amqp-resilient';
+
+const connection = new ConnectionManager({
+  url: 'amqp://localhost:5672',
+  connectionName: 'my-service',
+  logger: console, // optional
+});
+
+await connection.connect();
+```
+
+### Consumer
+
+```typescript
+import { BaseConsumer, type MessageContext } from 'amqp-resilient';
+
+interface OrderMessage {
+  orderId: string;
+  amount: number;
+}
+
+class OrderConsumer extends BaseConsumer<OrderMessage> {
+  constructor(connection: ConnectionManager) {
+    super(connection, {
+      queue: 'orders',
+      exchange: 'orders.exchange',
+      routingKeys: ['order.created', 'order.updated'],
+      prefetch: 10,
+      maxRetries: 3,
+    });
+  }
+
+  protected async handle(message: OrderMessage, context: MessageContext): Promise<void> {
+    console.log(`Processing order ${message.orderId}`);
+    // Throw an error to trigger retry
+  }
+}
+
+const consumer = new OrderConsumer(connection);
+await consumer.start();
+```
+
+### Publisher
+
+```typescript
+import { BasePublisher } from 'amqp-resilient';
+
+const publisher = new BasePublisher(connection, {
+  exchange: 'orders.exchange',
+  confirm: true,
+});
+
+const result = await publisher.publish('order.created', {
+  orderId: '123',
+  amount: 99.99,
+});
+
+if (result.success) {
+  console.log(`Published message ${result.messageId}`);
+}
+
+// Or throw on failure
+await publisher.publishOrThrow('order.created', { orderId: '456' });
+```
+
+## Configuration
+
+### ConnectionManager
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `url` | string | - | Full AMQP URL (amqp://host:port) |
+| `host` | string | - | RabbitMQ host (alternative to url) |
+| `port` | number | 5672 | RabbitMQ port |
+| `username` | string | guest | Username |
+| `password` | string | guest | Password |
+| `vhost` | string | / | Virtual host |
+| `connectionName` | string | **required** | Name for logging and health checks |
+| `prefetch` | number | 10 | Default channel prefetch count |
+| `heartbeat` | number | 60 | Heartbeat interval in seconds |
+| `maxReconnectAttempts` | number | 0 | Max reconnect attempts (0 = unlimited) |
+| `initialReconnectDelay` | number | 1000 | Initial reconnect delay (ms) |
+| `maxReconnectDelay` | number | 30000 | Max reconnect delay (ms) |
+| `logger` | AmqpLogger | noop | Logger instance |
+
+### BaseConsumer
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `queue` | string | **required** | Queue name |
+| `exchange` | string | **required** | Exchange to bind |
+| `routingKeys` | string[] | **required** | Routing keys to bind |
+| `prefetch` | number | 10 | Consumer prefetch count |
+| `maxRetries` | number | 3 | Max retries before DLQ |
+| `initialRetryDelay` | number | 1000 | Initial retry delay (ms) |
+| `maxRetryDelay` | number | 30000 | Max retry delay (ms) |
+| `useCircuitBreaker` | boolean | true | Enable circuit breaker |
+| `exchangeType` | ExchangeType | topic | Exchange type |
+
+### BasePublisher
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `exchange` | string | **required** | Exchange name |
+| `exchangeType` | ExchangeType | topic | Exchange type |
+| `confirm` | boolean | true | Use publisher confirms |
+| `maxRetries` | number | 3 | Max publish retries |
+| `initialRetryDelay` | number | 100 | Initial retry delay (ms) |
+| `maxRetryDelay` | number | 5000 | Max retry delay (ms) |
+| `useCircuitBreaker` | boolean | true | Enable circuit breaker |
+
+## Health & Metrics
+
+```typescript
+import { HealthService, ConnectionStatus } from 'amqp-resilient';
+
+// Get overall health status
+const status = HealthService.getOverallStatus();
+// 'healthy' | 'degraded' | 'dead' | 'not_configured'
+
+// Get specific connection status
+const connStatus = HealthService.getStatus('my-connection');
+// ConnectionStatus.CONNECTED | CONNECTING | DISCONNECTED | RECONNECTING | CLOSED
+
+// Get all connection statuses
+const allStatuses = HealthService.getAllStatuses();
+// { 'my-connection': 'connected', 'other-connection': 'reconnecting' }
+
+// Get connection stats
+const stats = connection.getStats();
+// {
+//   connected: true,
+//   reconnectAttempts: 0,
+//   channelCount: 2,
+//   lastConnectedAt: Date,
+// }
+```
+
+## Events
+
+```typescript
+connection.on('connected', () => {
+  console.log('AMQP connected');
+});
+
+connection.on('disconnected', () => {
+  console.log('AMQP disconnected');
+});
+
+connection.on('reconnecting', (attempt) => {
+  console.log(`Reconnecting attempt ${attempt}`);
+});
+
+connection.on('error', (error) => {
+  console.error('Connection error:', error);
+});
+```
+
+## Circuit Breaker
+
+Standalone circuit breaker that can be used independently:
+
+```typescript
+import { CircuitBreaker, CircuitBreakerOpenError } from 'amqp-resilient';
+
+const breaker = new CircuitBreaker({
+  name: 'external-api',
+  failureThreshold: 5,    // Open after 5 failures
+  resetTimeout: 30000,    // Try half-open after 30s
+  successThreshold: 3,    // Close after 3 successes in half-open
+});
+
+try {
+  const result = await breaker.execute(async () => {
+    return await externalApiCall();
+  });
+} catch (error) {
+  if (error instanceof CircuitBreakerOpenError) {
+    console.log(`Circuit open, retry in ${error.remainingResetTime}ms`);
+  }
+}
+
+// Get circuit state
+const state = breaker.getState();
+// 'CLOSED' | 'OPEN' | 'HALF_OPEN'
+```
+
+## Logger Interface
+
+Any logger that implements this interface works:
+
+```typescript
+interface AmqpLogger {
+  info(obj: object, msg?: string): void;
+  warn(obj: object, msg?: string): void;
+  error(obj: object, msg?: string): void;
+  debug(obj: object, msg?: string): void;
+}
+
+// Examples: pino, winston, bunyan, console
+```
+
+## Dead Letter Queue (DLQ)
+
+Messages that fail after max retries are automatically sent to a DLQ:
+
+```typescript
+// Queue: orders
+// DLQ: orders.dlq (auto-created)
+
+// Message headers in DLQ:
+// x-death-reason: 'max-retries-exceeded'
+// x-death-count: 3
+// x-original-routing-key: 'order.created'
+// x-first-death-queue: 'orders'
+```
+
+## Requirements
+
+- Node.js >= 18.0.0
+- amqplib >= 0.10.0
+
+## License
+
+MIT © [berkeerdo](https://github.com/berkeerdo)

package/dist/connection/ConnectionManager.d.ts

@@ -0,0 +1,84 @@
+import type { Channel, ConfirmChannel } from 'amqplib';
+import { type AmqpLogger, type ConnectionOptions } from '../types.js';
+/**
+ * ConnectionManager - Manages AMQP connection with auto-reconnect
+ * Use one instance per logical connection purpose
+ */
+export declare class ConnectionManager {
+    private connection;
+    private sharedChannel;
+    private confirmChannel;
+    private reconnectAttempts;
+    private isShuttingDown;
+    private reconnectTimer;
+    private readonly createdChannels;
+    private readonly logger;
+    private readonly connectionUrl;
+    private readonly connectionName;
+    private readonly prefetch;
+    private readonly heartbeat;
+    private readonly maxReconnectAttempts;
+    private readonly initialReconnectDelay;
+    private readonly maxReconnectDelay;
+    constructor(options: ConnectionOptions);
+    /**
+     * Setup connection event handlers
+     */
+    private setupConnectionHandlers;
+    /**
+     * Reset connection state on disconnect
+     */
+    private resetConnectionState;
+    /**
+     * Connect to AMQP server
+     */
+    connect(): Promise<void>;
+    /**
+     * Create a managed channel with error handlers
+     */
+    private createManagedChannel;
+    /**
+     * Schedule reconnection with exponential backoff and jitter
+     */
+    private scheduleReconnect;
+    /**
+     * Get the shared channel (for simple operations)
+     * Note: For consumers, use createChannel() instead
+     */
+    getChannel(): Promise<Channel>;
+    /**
+     * Create a dedicated channel for a consumer
+     * Best Practice: Each consumer should have its own channel
+     */
+    createChannel(): Promise<Channel>;
+    /**
+     * Get confirm channel for guaranteed delivery
+     */
+    getConfirmChannel(): Promise<ConfirmChannel>;
+    /**
+     * Close connection gracefully
+     */
+    close(): Promise<void>;
+    /**
+     * Check if connected
+     */
+    isConnected(): boolean;
+    /**
+     * Get connection name
+     */
+    getConnectionName(): string;
+    /**
+     * Get logger instance (for consumers/publishers to inherit)
+     */
+    getLogger(): AmqpLogger;
+    /**
+     * Get connection stats
+     */
+    getStats(): {
+        connected: boolean;
+        reconnectAttempts: number;
+        channelCount: number;
+        hasConfirmChannel: boolean;
+    };
+}
+//# sourceMappingURL=ConnectionManager.d.ts.map

package/dist/connection/ConnectionManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConnectionManager.d.ts","sourceRoot":"","sources":["../../src/connection/ConnectionManager.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AACvD,OAAO,EAAgC,KAAK,UAAU,EAAE,KAAK,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAepG;;;GAGG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,UAAU,CAA+B;IACjD,OAAO,CAAC,aAAa,CAAwB;IAC7C,OAAO,CAAC,cAAc,CAA+B;IACrD,OAAO,CAAC,iBAAiB,CAAK;IAC9B,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,cAAc,CAA8C;IACpE,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAsB;IACtD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAa;IAEpC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IACvC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;IACxC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAS;IAC9C,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAS;IAC/C,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAS;gBAE/B,OAAO,EAAE,iBAAiB;IAwBtC;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAkC/B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAO5B;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IA0B9B;;OAEG;YACW,oBAAoB;IAwBlC;;OAEG;IACH,OAAO,CAAC,iBAAiB;IA2CzB;;;OAGG;IACG,UAAU,IAAI,OAAO,CAAC,OAAO,CAAC;IAUpC;;;OAGG;IACG,aAAa,IAAI,OAAO,CAAC,OAAO,CAAC;IAiBvC;;OAEG;IACG,iBAAiB,IAAI,OAAO,CAAC,cAAc,CAAC;IA8BlD;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IA0D5B;;OAEG;IACH,WAAW,IAAI,OAAO;IAItB;;OAEG;IACH,iBAAiB,IAAI,MAAM;IAI3B;;OAEG;IACH,SAAS,IAAI,UAAU;IAIvB;;OAEG;IACH,QAAQ,IAAI;QACV,SAAS,EAAE,OAAO,CAAC;QACnB,iBAAiB,EAAE,MAAM,CAAC;QAC1B,YAAY,EAAE,MAAM,CAAC;QACrB,iBAAiB,EAAE,OAAO,CAAC;KAC5B;CAQF"}

package/dist/connection/ConnectionManager.js

@@ -0,0 +1,312 @@
+/**
+ * AMQP Connection Manager
+ * Production-ready implementation with:
+ * - Automatic reconnection with exponential backoff and jitter
+ * - Connection heartbeat for health monitoring
+ * - Dedicated channels for consumers (one channel per consumer)
+ * - Confirm channels for publishers (guaranteed delivery)
+ * - Graceful shutdown handling
+ *
+ * Best Practices:
+ * 1. Use separate channels for publishing and consuming
+ * 2. Never share channels between consumers
+ * 3. Use confirm channels for critical messages
+ * 4. Implement proper error handling and reconnection
+ * 5. Use heartbeats to detect dead connections
+ */
+import amqplib from 'amqplib';
+import { ConnectionStatus, noopLogger } from '../types.js';
+import { HealthService } from '../health/HealthService.js';
+/** Default configuration values */
+const DEFAULTS = {
+    INITIAL_RECONNECT_DELAY: 1000,
+    MAX_RECONNECT_DELAY: 60000,
+    MAX_RECONNECT_ATTEMPTS: 0, // unlimited
+    HEARTBEAT_SECONDS: 60,
+    PREFETCH: 10,
+};
+/**
+ * ConnectionManager - Manages AMQP connection with auto-reconnect
+ * Use one instance per logical connection purpose
+ */
+export class ConnectionManager {
+    connection = null;
+    sharedChannel = null;
+    confirmChannel = null;
+    reconnectAttempts = 0;
+    isShuttingDown = false;
+    reconnectTimer = null;
+    createdChannels = new Set();
+    logger;
+    connectionUrl;
+    connectionName;
+    prefetch;
+    heartbeat;
+    maxReconnectAttempts;
+    initialReconnectDelay;
+    maxReconnectDelay;
+    constructor(options) {
+        this.connectionName = options.connectionName ?? 'default';
+        this.prefetch = options.prefetch ?? DEFAULTS.PREFETCH;
+        this.heartbeat = options.heartbeat ?? DEFAULTS.HEARTBEAT_SECONDS;
+        this.maxReconnectAttempts = options.maxReconnectAttempts ?? DEFAULTS.MAX_RECONNECT_ATTEMPTS;
+        this.initialReconnectDelay = options.initialReconnectDelay ?? DEFAULTS.INITIAL_RECONNECT_DELAY;
+        this.maxReconnectDelay = options.maxReconnectDelay ?? DEFAULTS.MAX_RECONNECT_DELAY;
+        this.logger = options.logger ?? noopLogger;
+        // Build connection URL from individual params or use provided URL
+        if (options.url) {
+            this.connectionUrl = options.url;
+        }
+        else if (options.host) {
+            const username = encodeURIComponent(options.username ?? 'guest');
+            const password = encodeURIComponent(options.password ?? 'guest');
+            const host = options.host;
+            const port = options.port ?? 5672;
+            const vhost = encodeURIComponent(options.vhost ?? '/');
+            this.connectionUrl = `amqp://${username}:${password}@${host}:${port}/${vhost}`;
+        }
+        else {
+            throw new Error('ConnectionManager requires either url or host parameter');
+        }
+    }
+    /**
+     * Setup connection event handlers
+     */
+    setupConnectionHandlers() {
+        if (!this.connection) {
+            return;
+        }
+        this.connection.on('error', (err) => {
+            this.logger.error({ err, connectionName: this.connectionName }, 'AMQP connection error');
+        });
+        this.connection.on('close', () => {
+            if (this.isShuttingDown) {
+                return;
+            }
+            this.logger.warn({ connectionName: this.connectionName }, 'AMQP connection closed unexpectedly, scheduling reconnect...');
+            this.resetConnectionState();
+            HealthService.registerStatus(this.connectionName, ConnectionStatus.RECONNECTING);
+            this.scheduleReconnect();
+        });
+        this.connection.on('blocked', (reason) => {
+            this.logger.warn({ connectionName: this.connectionName, reason }, 'AMQP connection blocked by broker');
+        });
+        this.connection.on('unblocked', () => {
+            this.logger.info({ connectionName: this.connectionName }, 'AMQP connection unblocked');
+        });
+    }
+    /**
+     * Reset connection state on disconnect
+     */
+    resetConnectionState() {
+        this.connection = null;
+        this.sharedChannel = null;
+        this.confirmChannel = null;
+        this.createdChannels.clear();
+    }
+    /**
+     * Connect to AMQP server
+     */
+    async connect() {
+        if (this.connection) {
+            return;
+        }
+        HealthService.registerStatus(this.connectionName, ConnectionStatus.CONNECTING);
+        try {
+            this.logger.info({ connectionName: this.connectionName }, 'Connecting to AMQP server...');
+            this.connection = await amqplib.connect(this.connectionUrl, { heartbeat: this.heartbeat });
+            this.reconnectAttempts = 0;
+            this.setupConnectionHandlers();
+            this.sharedChannel = await this.createManagedChannel();
+            HealthService.registerStatus(this.connectionName, ConnectionStatus.CONNECTED);
+            this.logger.info({ connectionName: this.connectionName }, 'AMQP connected successfully');
+        }
+        catch (error) {
+            this.logger.error({ err: error, connectionName: this.connectionName }, 'Failed to connect to AMQP server');
+            HealthService.registerStatus(this.connectionName, ConnectionStatus.DISCONNECTED);
+            this.scheduleReconnect();
+            throw error;
+        }
+    }
+    /**
+     * Create a managed channel with error handlers
+     */
+    async createManagedChannel() {
+        if (!this.connection) {
+            throw new Error('Not connected to AMQP server');
+        }
+        const channel = await this.connection.createChannel();
+        await channel.prefetch(this.prefetch);
+        channel.on('error', (err) => {
+            this.logger.error({ err, connectionName: this.connectionName }, 'AMQP channel error');
+            this.createdChannels.delete(channel);
+        });
+        channel.on('close', () => {
+            if (!this.isShuttingDown) {
+                this.logger.warn({ connectionName: this.connectionName }, 'AMQP channel closed');
+            }
+            this.createdChannels.delete(channel);
+        });
+        this.createdChannels.add(channel);
+        return channel;
+    }
+    /**
+     * Schedule reconnection with exponential backoff and jitter
+     */
+    scheduleReconnect() {
+        if (this.isShuttingDown || this.reconnectTimer) {
+            return;
+        }
+        this.reconnectAttempts++;
+        // Check max attempts (0 = unlimited)
+        if (this.maxReconnectAttempts > 0 && this.reconnectAttempts > this.maxReconnectAttempts) {
+            this.logger.error({ connectionName: this.connectionName, attempts: this.reconnectAttempts }, 'Max reconnection attempts reached, marking connection as dead');
+            HealthService.registerStatus(this.connectionName, ConnectionStatus.DEAD);
+            return;
+        }
+        // Calculate delay with exponential backoff and jitter
+        const exponentialDelay = Math.min(this.initialReconnectDelay * Math.pow(2, this.reconnectAttempts - 1), this.maxReconnectDelay);
+        // Add jitter (0-25% of delay) to prevent thundering herd
+        const jitter = Math.random() * exponentialDelay * 0.25;
+        const delay = Math.floor(exponentialDelay + jitter);
+        this.logger.info({
+            connectionName: this.connectionName,
+            attempt: this.reconnectAttempts,
+            delayMs: delay,
+        }, 'Scheduling AMQP reconnection...');
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            this.connect().catch(() => {
+                // Error already logged in connect()
+            });
+        }, delay);
+    }
+    /**
+     * Get the shared channel (for simple operations)
+     * Note: For consumers, use createChannel() instead
+     */
+    async getChannel() {
+        if (!this.sharedChannel) {
+            await this.connect();
+        }
+        if (!this.sharedChannel) {
+            throw new Error('Failed to get AMQP channel');
+        }
+        return this.sharedChannel;
+    }
+    /**
+     * Create a dedicated channel for a consumer
+     * Best Practice: Each consumer should have its own channel
+     */
+    async createChannel() {
+        if (!this.connection) {
+            await this.connect();
+        }
+        if (!this.connection) {
+            throw new Error('Failed to get AMQP connection');
+        }
+        const channel = await this.createManagedChannel();
+        this.logger.debug({ connectionName: this.connectionName, channelCount: this.createdChannels.size }, 'Created dedicated channel');
+        return channel;
+    }
+    /**
+     * Get confirm channel for guaranteed delivery
+     */
+    async getConfirmChannel() {
+        if (!this.confirmChannel) {
+            if (!this.connection) {
+                await this.connect();
+            }
+            if (!this.connection) {
+                throw new Error('Failed to get AMQP connection');
+            }
+            this.confirmChannel = await this.connection.createConfirmChannel();
+            await this.confirmChannel.prefetch(this.prefetch);
+            this.confirmChannel.on('error', (err) => {
+                this.logger.error({ err, connectionName: this.connectionName }, 'AMQP confirm channel error');
+                this.confirmChannel = null;
+            });
+            this.confirmChannel.on('close', () => {
+                if (!this.isShuttingDown) {
+                    this.logger.warn({ connectionName: this.connectionName }, 'AMQP confirm channel closed');
+                }
+                this.confirmChannel = null;
+            });
+            this.logger.debug({ connectionName: this.connectionName }, 'Created confirm channel');
+        }
+        return this.confirmChannel;
+    }
+    /**
+     * Close connection gracefully
+     */
+    async close() {
+        this.isShuttingDown = true;
+        // Cancel reconnection timer
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        try {
+            // Close all created channels
+            const closePromises = [];
+            for (const channel of this.createdChannels) {
+                closePromises.push(channel.close().catch((err) => {
+                    this.logger.debug({ err }, 'Error closing channel');
+                }));
+            }
+            if (this.sharedChannel && !this.createdChannels.has(this.sharedChannel)) {
+                closePromises.push(this.sharedChannel.close().catch((err) => {
+                    this.logger.debug({ err }, 'Error closing shared channel');
+                }));
+            }
+            if (this.confirmChannel) {
+                closePromises.push(this.confirmChannel.close().catch((err) => {
+                    this.logger.debug({ err }, 'Error closing confirm channel');
+                }));
+            }
+            await Promise.all(closePromises);
+            if (this.connection) {
+                await this.connection.close();
+            }
+            this.connection = null;
+            this.sharedChannel = null;
+            this.confirmChannel = null;
+            this.createdChannels.clear();
+            HealthService.unregisterConnection(this.connectionName);
+            this.logger.info({ connectionName: this.connectionName }, 'AMQP connection closed gracefully');
+        }
+        catch (error) {
+            this.logger.error({ err: error, connectionName: this.connectionName }, 'Error closing AMQP connection');
+        }
+    }
+    /**
+     * Check if connected
+     */
+    isConnected() {
+        return this.connection !== null;
+    }
+    /**
+     * Get connection name
+     */
+    getConnectionName() {
+        return this.connectionName;
+    }
+    /**
+     * Get logger instance (for consumers/publishers to inherit)
+     */
+    getLogger() {
+        return this.logger;
+    }
+    /**
+     * Get connection stats
+     */
+    getStats() {
+        return {
+            connected: this.isConnected(),
+            reconnectAttempts: this.reconnectAttempts,
+            channelCount: this.createdChannels.size,
+            hasConfirmChannel: this.confirmChannel !== null,
+        };
+    }
+}
+//# sourceMappingURL=ConnectionManager.js.map