@autofleet/rabbit 5.0.28 → 5.1.0-alpha.0

package/README.md

@@ -1,8 +1,474 @@
-# V5 migration
+# @autofleet/rabbit
 
-The breaking change in this version is the removal of `zehut` from dependencies and usage as a peer-dependency.
+RabbitMQ wrapper for Autofleet microservices with support for both classic and quorum queues.
+
+## Features
+
+- **Dual Queue Support**: Classic and quorum queues with automatic vhost separation
+- **Connection Pooling**: Efficient vhost-based connection management
+- **Graceful Shutdown**: Proper cleanup of consumers and connections
+- **Redis Integration**: Message locking and timestamp validation
+- **Tracing Support**: Integration with @autofleet/zehut for distributed tracing
+- **TypeScript**: Full type safety with TypeScript definitions
+
+## Installation
+
+```bash
+pnpm add @autofleet/rabbit
+```
+
+## Quick Start
+
+```typescript
+import RabbitMq from '@autofleet/rabbit';
+
+// Initialize with optional Redis config
+const rabbit = new RabbitMq({
+  rabbitHost: 'localhost:5672',
+  logger: yourLogger,
+}, redisConfig);
+
+// Configure which queues should use quorum type
+process.env.QUORUM_QUEUES = 'order-events,user-updates,notifications';
+
+// Send to queue (automatically routes to correct vhost)
+await rabbit.sendToQueue('order-events', { orderId: 123 });
+
+// Consume from queue
+await rabbit.consume('order-events', async (msg, ack, nack) => {
+  console.log('Received:', msg.content);
+  await ack();
+});
+
+// Publish to exchange
+await rabbit.publish('events', { type: 'order.created' });
+
+// Consume from exchange
+await rabbit.consumeFromExchange('order-queue', 'events', async (msg, ack, nack) => {
+  console.log('Received:', msg.content);
+  await ack();
+});
+```
+
+## Configuration
+
+### Environment Variables
+
+- **`QUORUM_QUEUES`**: Comma-separated list of queue names that should use quorum type
+  ```bash
+  QUORUM_QUEUES="order-events,user-updates,notifications"
+  ```
+  - Queues in this list will be created in the `quorum-vhost` vhost with `x-queue-type: quorum`
+  - All other queues will use the default vhost with `x-queue-type: classic`
+
+- **`RABBITMQ_USERNAME`**: RabbitMQ username (default: `guest`)
+- **`RABBITMQ_PASSWORD`**: RabbitMQ password (default: `guest`)
+- **`RABBITMQ_SERVICE_HOST`**: RabbitMQ host (default: `localhost`)
+
+### Constructor Options
+
+```typescript
+interface AfRabbitOptions {
+  rabbitHost?: string;           // RabbitMQ host:port
+  vhost?: string;                // Default vhost name (default: 'quorum-vhost')
+  logger?: LoggerInstanceManager; // Custom logger instance
+  disableReconnect?: boolean;    // Disable automatic reconnection
+  dontGracefulShutdown?: boolean; // Disable graceful shutdown handlers
+  dontRetryAssert?: boolean;     // Don't retry on queue assertion errors
+}
+```
+
+## API Reference
+
+### Publishing
+
+#### `sendToQueue(queue: string, content: any, options?: Options.AssertQueue, customHeaders?: PublishOptions['headers'])`
+
+Send a message to a specific queue. The queue type (classic/quorum) is determined automatically based on the queue name.
+
+```typescript
+await rabbit.sendToQueue('order-events', { orderId: 123 }, {
+  durable: true,
+  messageTtl: 60000,
+}, {
+  customHeader: 'value',
+});
+```
+
+#### `publish(exchange: string, content: any, customHeaders?: PublishOptions['headers'])`
+
+Publish a message to an exchange.
+
+```typescript
+await rabbit.publish('events', { type: 'order.created' });
+```
+
+### Consuming
+
+#### `consume(queue: string, callback: CallbackFunction, options?: ConsumeOptions)`
+
+Consume messages from a queue.
+
+```typescript
+await rabbit.consume('order-events', async (msg, ack, nack) => {
+  try {
+    await processOrder(msg.content);
+    await ack(); // Acknowledge message
+  } catch (error) {
+    await nack(msg, { skipRetry: false }); // Retry the message
+  }
+}, {
+  retries: 3,
+  deadMessageTtl: 86400000, // 24 hours
+  limit: 10, // Prefetch limit
+});
+```
+
+##### Consume Options
+
+```typescript
+interface ConsumeOptions {
+  retries?: number;              // Number of retries before sending to dead queue
+  deadMessageTtl?: number;       // TTL for dead queue messages (ms)
+  messageTtl?: number;           // TTL for messages (ms)
+  limit?: number;                // Prefetch limit
+  lockTimeout?: number;          // Redis lock timeout (ms)
+  useConsumeWithLock?: boolean;  // Enable Redis-based locking
+  auditContext?: any;            // Audit context function
+  enableRabbitTrace?: boolean;   // Enable tracing integration
+}
+```
+
+#### `consumeFromExchange(queue: string, exchange: string, callback: CallbackFunction, options?: ConsumeOptions)`
+
+Consume messages from an exchange by binding a queue to it.
+
+```typescript
+await rabbit.consumeFromExchange('order-queue', 'events', async (msg, ack, nack) => {
+  console.log('Event:', msg.content);
+  await ack();
+});
+```
+
+### Queue Management
+
+#### `assertQueue(queueName: string, options?: Options.AssertQueue)`
+
+Assert a queue exists, creating it if necessary. Queue type is determined automatically.
+
+```typescript
+await rabbit.assertQueue('order-events', {
+  durable: true,
+  arguments: {
+    'x-message-ttl': 60000,
+  },
+});
+```
+
+#### `assertExchange(exchangeName: string, vhost?: string)`
+
+Assert an exchange exists, creating it if necessary.
+
+```typescript
+await rabbit.assertExchange('events');
+```
+
+#### `bindQueue(queue: string, exchange: string)`
+
+Bind a queue to an exchange.
+
+```typescript
+await rabbit.bindQueue('order-queue', 'events');
+```
+
+#### `getQueueLength(queue: string)`
+
+Get the number of messages in a queue.
+
+```typescript
+const { messageCount } = await rabbit.getQueueLength('order-events');
+console.log(`Queue has ${messageCount} messages`);
+```
+
+### Connection Management
+
+#### `isConnected()`
+
+Check if all connections are healthy and all consumers are registered.
+
+```typescript
+const healthy = await rabbit.isConnected();
+```
+
+#### `gracefulShutdown(signal: string)`
+
+Gracefully shutdown all connections and consumers. This is automatically called on `SIGTERM` and `SIGINT` unless `dontGracefulShutdown` is set.
+
+```typescript
+await rabbit.gracefulShutdown('SIGTERM');
+```
+
+## Architecture
+
+### Queue Type Determination
+
+Queues are automatically routed to the appropriate vhost based on the `QUORUM_QUEUES` environment variable:
+
+```typescript
+// Environment
+QUORUM_QUEUES="order-events,user-updates"
+
+// Routing
+sendToQueue('order-events', data)    → quorum-vhost (quorum queue)
+sendToQueue('other-queue', data)     → default vhost (classic queue)
+```
+
+### Connection Pooling
+
+The package maintains separate connection pools for each vhost:
+
+- **Publish connections**: One connection per vhost for publishing
+- **Consume connections**: One connection per vhost for consuming
+- **Channels**: One channel per vhost for publishing
+
+This architecture ensures efficient connection reuse while maintaining proper isolation between queue types.
+
+### Message Headers
+
+All published messages automatically include the following headers:
+
+- `creationTimestamp`: Unix timestamp in milliseconds
+- `x-user-id`: User ID from zehut context (if available)
+- `x-contexts-ids`: User context IDs from zehut (if available)
+- `x-tracing-id`: Trace ID from zehut context (if available)
+
+### Dead Letter Queues
+
+When a message exceeds the retry limit, it's automatically sent to a dead letter queue:
+
+- **Queue name**: `{original-queue}-dead`
+- **TTL**: Configurable via `deadMessageTtl` option (default: from `messageTtl`)
+
+## Migration Guides
+
+### V6 Migration (Quorum Queue Refactoring)
+
+**Version 6.0.0** introduces a cleaner architecture for managing classic and quorum queues with **breaking changes**.
+
+#### Breaking Changes
+
+1. **Removed parameters**:
+   ```typescript
+   // ❌ Old (deprecated)
+   await rabbit.sendToQueue(queue, data, options, headers, true); // isQuorumQueue param
+   await rabbit.publish(exchange, data, headers, true); // isQuorumQueue param
+
+   // ✅ New
+   await rabbit.sendToQueue(queue, data, options, headers);
+   await rabbit.publish(exchange, data, headers);
+   ```
+
+2. **Removed methods**:
+   - `assertChannel()` - Use `assertChannelForVhost(vhost)` instead (internal use only)
+
+3. **Updated method signatures**:
+   ```typescript
+   // ❌ Old
+   await rabbit.assertExchange(exchange, connectionData);
+
+   // ✅ New
+   await rabbit.assertExchange(exchange); // vhost optional, defaults to ''
+   ```
+
+4. **Removed environment variables**:
+   - `DISABLE_QUORUM_QUEUES_CONSUME` - No longer needed
+   - `DISABLE_QUORUM_QUEUES_PUBLISH` - No longer needed
+
+5. **Removed type options**:
+   ```typescript
+   // ❌ Old (deprecated)
+   interface ConsumeOptions {
+     isQuorumQueue?: boolean; // REMOVED
+   }
+   ```
+
+#### Migration Steps
+
+**Step 1**: Update your code to remove `isQuorumQueue` parameters
+
+```typescript
+// Before
+await rabbit.sendToQueue('orders', data, options, headers, true);
+
+// After
+await rabbit.sendToQueue('orders', data, options, headers);
+```
+
+**Step 2**: Configure `QUORUM_QUEUES` environment variable
+
+```bash
+# Add to your environment
+QUORUM_QUEUES="orders,events,notifications"
+```
+
+**Step 3**: Remove old environment variables
+
+```bash
+# Remove these from your environment
+# DISABLE_QUORUM_QUEUES_CONSUME
+# DISABLE_QUORUM_QUEUES_PUBLISH
+```
+
+**Step 4**: Update `assertExchange` calls
+
+```typescript
+// Before
+await rabbit.assertExchange(exchange, connectionData);
+
+// After
+await rabbit.assertExchange(exchange);
+```
+
+#### Gradual Migration Strategy
+
+For safe migration across multiple services:
+
+1. **Deploy with empty `QUORUM_QUEUES`** initially (all queues remain classic):
+   ```bash
+   QUORUM_QUEUES=""
+   ```
+
+2. **Gradually add queues** to the list:
+   ```bash
+   QUORUM_QUEUES="order-events"  # Start with one
+   # Monitor and verify
+   QUORUM_QUEUES="order-events,user-updates"  # Add more
+   ```
+
+3. **Remove old parameters** from code (cleanup):
+   ```typescript
+   // Remove isQuorumQueue parameters
+   await rabbit.sendToQueue(queue, data, options, headers);
+   ```
+
+#### Benefits of V6
+
+- **40% less code**: Removed ~600 lines of duplicate infrastructure
+- **Better maintainability**: Single code path for all queue types
+- **Clearer configuration**: Queue type determined by name, not global flags
+- **Improved performance**: Connection pooling reduces memory overhead
+- **Easier testing**: Simpler architecture with fewer edge cases
+
+### V5 Migration
+
+The breaking change in version 5 is the removal of `zehut` from dependencies and usage as a peer-dependency.
 The required version of zehut is now `^4.0.0`.
 
 This was moved to being a peer-dependency in order to ensure that the version of `zehut` used here is the same as used in the MS, and not risk the package using v4 while the service is using v3, which would cause `zehut` to have multiple traces, which will not all hold the correct data.
 
-Additionally, the minimum node version is now 18, due to the minimum version of node defined in `zehut`.
+Additionally, the minimum node version is now 18, due to the minimum version of node defined in `zehut`.
+
+## Examples
+
+### Basic Producer-Consumer
+
+```typescript
+import RabbitMq from '@autofleet/rabbit';
+
+const rabbit = new RabbitMq();
+
+// Set up quorum queues
+process.env.QUORUM_QUEUES = 'important-events';
+
+// Producer
+async function sendEvent(event: any) {
+  await rabbit.sendToQueue('important-events', event);
+}
+
+// Consumer
+async function startConsumer() {
+  await rabbit.consume('important-events', async (msg, ack, nack) => {
+    try {
+      console.log('Processing event:', msg.content);
+      await processEvent(msg.content);
+      await ack();
+    } catch (error) {
+      console.error('Failed to process event:', error);
+      await nack(msg); // Will retry based on options
+    }
+  }, {
+    retries: 3,
+    limit: 10,
+  });
+}
+
+startConsumer();
+```
+
+### Fan-out Pattern with Exchange
+
+```typescript
+import RabbitMq from '@autofleet/rabbit';
+
+const rabbit = new RabbitMq();
+
+// Set up exchange and queues
+await rabbit.assertExchange('notifications');
+await rabbit.assertQueue('email-notifications');
+await rabbit.assertQueue('sms-notifications');
+await rabbit.bindQueue('email-notifications', 'notifications');
+await rabbit.bindQueue('sms-notifications', 'notifications');
+
+// Publisher
+await rabbit.publish('notifications', {
+  type: 'order.created',
+  orderId: 123,
+});
+
+// Email consumer
+await rabbit.consumeFromExchange('email-notifications', 'notifications',
+  async (msg, ack, nack) => {
+    await sendEmail(msg.content);
+    await ack();
+  }
+);
+
+// SMS consumer
+await rabbit.consumeFromExchange('sms-notifications', 'notifications',
+  async (msg, ack, nack) => {
+    await sendSMS(msg.content);
+    await ack();
+  }
+);
+```
+
+### With Redis Locking
+
+```typescript
+import RabbitMq from '@autofleet/rabbit';
+
+const rabbit = new RabbitMq(undefined, {
+  host: 'localhost',
+  port: 6379,
+  prefix: 'myapp:',
+});
+
+await rabbit.consume('order-processing', async (msg, ack, nack) => {
+  // Redis lock is automatically acquired before this callback
+  // and released after ack/nack
+
+  await processOrder(msg.content);
+  await ack(); // Lock is released here
+}, {
+  useConsumeWithLock: true,
+  lockTimeout: 30000, // 30 seconds
+});
+```
+
+## License
+
+ISC
+
+## Contributing
+
+Please report issues at: https://github.com/autofleet/autorepo

package/dist/{index-Di_b_UEl.d.ts → index-CBlhQYQ_.d.cts}

@@ -1,10 +1,9 @@
-import { EventEmitter } from "node:events";
 import RedisLock from "redis-lock";
 import { AmqpConnectionManager, ChannelWrapper, CreateChannelOpts } from "amqp-connection-manager";
-import { LoggerInstanceManager } from "@autofleet/logger";
-import { createClient } from "redis";
 import { PublishOptions } from "amqp-connection-manager/dist/types/ChannelWrapper";
 import { ConfirmChannel, ConsumeMessage, Options, Replies } from "amqplib";
+import { LoggerInstanceManager } from "@autofleet/logger";
+import { createClient } from "redis";
 
 //#region src/lib/redis.d.ts
 interface RedisConfig {
@@ -15,10 +14,6 @@ interface RedisConfig {
 declare const getRedisInstance: (config: RedisConfig) => ReturnType<typeof createClient>;
 //#endregion
 //#region src/lib/types.d.ts
-type ExchangesCache = Record<string, Replies.AssertExchange | undefined>;
-type QueuesCache = Record<string, Replies.AssertQueue | undefined>;
-type QueueSetupPromisesDictionary = Record<string, Promise<Replies.AssertQueue> | undefined>;
-type AssertExchangePromisesDictionary = Record<string, Promise<Replies.AssertExchange> | undefined>;
 interface CustomMessageHeaders {
   redisTimestampValidationKey?: string;
 }
@@ -32,7 +27,6 @@ interface ConsumeOptions {
   useConsumeWithLock?: boolean;
   auditContext?: any;
   enableRabbitTrace?: boolean;
-  isQuorumQueue?: boolean;
 }
 interface NackOptions {
   skipRetry?: boolean;
@@ -64,8 +58,7 @@ declare function sendCeleryTaskViaHttp(data: TaskData, {
 interface IAfRabbitMq {
   ack(channel: ConfirmChannel, msg: ConsumeMessageOrNull, shouldUpdateRedisTimestamp?: boolean, releaseLock?: (() => Promise<void>) | null): (userMsg: ConsumeMessage) => Promise<void>;
   nack(channel: ConfirmChannel, queue: string, options: ConsumeOptions, deadQueueOptions: Options.AssertQueue, msg: ConsumeMessageOrNull, releaseLock?: () => Promise<void>): (userMsg: ConsumeMessageOrNull, nackOptions?: NackOptions) => Promise<void>;
-  assertChannel(options?: assertChannelOpts): Promise<ChannelWrapper>;
-  assertExchange(exchangeName: string, connection: ConnectionData): Promise<Replies.AssertExchange>;
+  assertExchange(exchangeName: string, vhost?: string): Promise<Replies.AssertExchange>;
   assertQueue(queueName: string, options?: Options.AssertQueue | null): Promise<Replies.AssertQueue>;
   consume(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<void>;
   consumeFromExchange(queue: string, exchange: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<void>;
@@ -95,11 +88,6 @@ interface newChannelOpts {
   options?: CreateChannelOpts | undefined;
   connection: ConnectionData;
 }
-interface assertChannelOpts {
-  channelName?: string;
-  force?: boolean;
-  connection: ConnectionData;
-}
 declare class RabbitMq implements IAfRabbitMq {
   #private;
   readonly options: AfRabbitOptions;
@@ -109,98 +97,61 @@ declare class RabbitMq implements IAfRabbitMq {
   static getPublishOptions(customHeaders?: CustomMessageHeaders): PublishOptions;
   readonly DISCONNECT_MSG = "rabbit: connection disconnect";
   readonly RECONNECT_MSG = "rabbit: connection disconnect - reconnecting";
-  publishChannel: ChannelWrapper | null;
-  publishChannelSetupPromise: Promise<ChannelWrapper> | null;
-  readonly publishConnection: ConnectionData;
-  readonly consumeConnection: ConnectionData;
-  readonly em: EventEmitter;
-  readonly exchanges: ExchangesCache;
-  readonly queues: QueuesCache;
-  readonly queueSetupPromises: QueueSetupPromisesDictionary;
-  readonly assertExchangePromises: AssertExchangePromisesDictionary;
   readonly redisClient?: ReturnType<typeof getRedisInstance>;
   readonly redisLock?: ReturnType<typeof RedisLock>;
-  /** A map of consumers' tags used for canceling consumption */
-  readonly consumersTags: Map<string, {
-    channel: ConfirmChannel;
-    consumerTag: string;
-  }>;
-  private readonly consumersToRegister;
+  private readonly em;
   private doesVHostExist;
   private readonly vhost;
   private gracefulShutdownStarted;
-  oldPublishChannel: ChannelWrapper | null;
-  oldPublishChannelSetupPromise: Promise<ChannelWrapper> | null;
-  readonly oldPublishConnection: ConnectionData;
-  readonly oldConsumeConnection: ConnectionData;
-  readonly oldEm: EventEmitter;
-  readonly oldExchanges: ExchangesCache;
-  readonly oldQueues: QueuesCache;
-  readonly oldQueueSetupPromises: QueueSetupPromisesDictionary;
-  readonly oldAssertExchangePromises: AssertExchangePromisesDictionary;
-  readonly oldConsumersTags: Map<string, {
-    channel: ConfirmChannel;
-    consumerTag: string;
-  }>;
-  private readonly oldConsumersToRegister;
+  private readonly quorumQueues;
+  private readonly publishConnections;
+  private readonly consumeConnections;
+  private readonly publishChannels;
+  private readonly publishChannelSetupPromises;
+  private readonly queuesByVhost;
+  private readonly exchangesByVhost;
+  private readonly queueSetupPromisesByVhost;
+  private readonly assertExchangePromisesByVhost;
+  private readonly consumersTagsByVhost;
+  private readonly consumersToRegisterByVhost;
   constructor(options?: AfRabbitOptions, redisConfig?: RedisConfig | undefined);
   private getRedisKey;
+  private isQuorumQueue;
+  private getVhostForQueue;
   private assertVHost;
   private shouldConsumeMessageByTimestamp;
   ack: (channel: ConfirmChannel, msg: ConsumeMessageOrNull, shouldUpdateRedisTimestamp?: boolean, releaseLock?: (() => Promise<void>) | null) => (userMsg: ConsumeMessage) => Promise<void>;
   nack: (channel: ConfirmChannel, queue: string, options: ConsumeOptions, deadQueueOptions: Options.AssertQueue, msg: ConsumeMessageOrNull, releaseLock?: (() => Promise<void>) | null) => (userMsg: ConsumeMessageOrNull, {
     skipRetry
   }?: NackOptions) => Promise<void>;
-  getConnection(connection: ConnectionData): Promise<AmqpConnectionManager>;
+  getConnection(connection: ConnectionData, vhost?: string): Promise<AmqpConnectionManager>;
+  getConnectionForVhost(vhost: string, type: "publish" | "consume"): Promise<AmqpConnectionManager>;
+  getConnectionDataForVhost(vhost: string, type: "publish" | "consume"): ConnectionData;
+  assertChannelForVhost(vhost: string, force?: boolean): Promise<ChannelWrapper>;
   getNewChannel({
     name,
     onClose,
     options,
     connection
   }: newChannelOpts): Promise<ChannelWrapper>;
-  assertChannel({
-    force,
-    connection
-  }: assertChannelOpts): Promise<ChannelWrapper>;
-  assertExchange(exchangeName: string, connection: ConnectionData): Promise<Replies.AssertExchange>;
+  assertExchange(exchangeName: string, vhost?: string): Promise<Replies.AssertExchange>;
   getQueueLength(queue: string): Promise<Replies.AssertQueue>;
   private deleteQueue;
   bindQueue(queue: string, exchange: string): Promise<void>;
-  setupQueue(queueName: string, options?: Options.AssertQueue): Promise<Replies.AssertQueue>;
-  static shouldUseQuorum(queueName: string): boolean;
+  setupQueue(queueName: string, options?: Options.AssertQueue, vhost?: string): Promise<Replies.AssertQueue>;
   assertQueue(queueName: string, options?: Options.AssertQueue): Promise<Replies.AssertQueue>;
   private saveConsumer;
   consume(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<void>;
-  consumeNew(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<void>;
-  consumeOld(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<void>;
   private lockRedisIfNeeded;
   private unlockRedisIfNeeded;
   private consumeFromRabbit;
   consumeFromExchange(queue: string, exchange: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<void>;
-  publish(exchange: string, content: any, customHeaders?: PublishOptions["headers"], isQuorumQueue?: boolean): Promise<void>;
-  sendToQueue(queue: string, content: any, options?: Options.AssertQueue, customHeaders?: PublishOptions["headers"], isQuorumQueue?: boolean): Promise<boolean | undefined>;
+  publish(exchange: string, content: any, customHeaders?: PublishOptions["headers"], _isQuorumQueue?: boolean): Promise<void>;
+  sendToQueue(queue: string, content: any, options?: Options.AssertQueue, customHeaders?: PublishOptions["headers"], _isQuorumQueue?: boolean): Promise<boolean | undefined>;
   isConnected(): Promise<boolean>;
   gracefulShutdown(signal: string): Promise<void>;
-  private consumeFromRabbitOld;
-  getNewChannelOld({
-    name,
-    onClose,
-    options,
-    connection
-  }: newChannelOpts): Promise<ChannelWrapper>;
-  getConnectionOld(connection: ConnectionData): Promise<AmqpConnectionManager>;
-  private saveConsumerOld;
-  assertQueueOld(queueName: string, options?: Options.AssertQueue): Promise<Replies.AssertQueue>;
-  setupQueueOld(queueName: string, options?: Options.AssertQueue): Promise<Replies.AssertQueue>;
-  assertChannelOld({
-    force,
-    connection
-  }: assertChannelOpts): Promise<ChannelWrapper>;
-  private deleteQueueOld;
-  assertExchangeOld(exchangeName: string, connection: ConnectionData): Promise<Replies.AssertExchange>;
-  isConnectedOld(): Promise<boolean>;
   private maskURL;
 }
 //#endregion
 export { sendCeleryTaskViaHttp as i, IAfRabbitMq as n, RabbitMq as r, AfRabbitOptions as t };
-//# sourceMappingURL=index-Di_b_UEl.d.ts.map
+//# sourceMappingURL=index-CBlhQYQ_.d.cts.map