@autofleet/rabbit 3.2.0 → 3.2.2-2.beta-0

package/.nvmrc

@@ -1 +1 @@
-v16
+v20

package/dist/index.d.ts

@@ -1,10 +1,9 @@
 /// <reference types="node" />
 import { EventEmitter } from 'events';
-import { AmqpConnectionManager, ChannelWrapper } from 'amqp-connection-manager';
+import { AmqpConnectionManager, ChannelWrapper, CreateChannelOpts } from 'amqp-connection-manager';
 import { ConfirmChannel, ConsumeMessage, Options, Replies } from 'amqplib';
 import { RedisConfig } from './lib/redis';
-import { TRACING_HEADER, USER_TRACING_HEADER } from './lib/consts';
-import { CallbackFunction, ConsumeMessageOrNull, ConsumeOptions, CustomMessageHeaders, QueuesCache, RedisLockType, ExchangesCache } from './lib/types';
+import { CallbackFunction, ConsumeMessageOrNull, ConsumeOptions, CustomMessageHeaders, QueuesCache, RedisLockType, ExchangesCache, QueueSetupPromisesDictionary, ConnectionPurpose, ConnectionData } from './lib/types';
 export interface IAfRabbitMq {
     ack: any;
     nack: any;
@@ -17,6 +16,9 @@ export interface IAfRabbitMq {
     sendToQueue: any;
     redisClient?: any;
 }
+interface NackOptions {
+    skipRetry?: boolean;
+}
 export interface AfRabbitOptions {
     disableReconnect?: boolean;
     /**
@@ -31,13 +33,16 @@ export interface AfRabbitOptions {
     dontRetryAssert?: boolean;
     rabbitHost?: string;
 }
-declare type newChannelOpts = {
+type newChannelOpts = {
     name?: string;
     onClose?: null | ((args: any | null) => void);
+    options?: CreateChannelOpts | undefined;
+    connectionPurpose: ConnectionPurpose;
 };
-declare type assertChannelOpts = {
+type assertChannelOpts = {
     channelName?: string;
     force?: boolean;
+    connectionPurpose: ConnectionPurpose;
 };
 declare class RabbitMq implements IAfRabbitMq {
     static parseMsg(msg: any): any;
@@ -55,43 +60,44 @@ declare class RabbitMq implements IAfRabbitMq {
     DISCONNECT_MSG: string;
     RECONNECT_MSG: string;
     channel: ChannelWrapper | null;
+    publishChannelSetupPromise: Promise<ChannelWrapper> | null;
     blockReconnect: boolean | null | undefined;
-    connection: AmqpConnectionManager | null | undefined;
+    connectionsMap: {
+        [ConnectionPurpose.Consume]: ConnectionData;
+        [ConnectionPurpose.Publish]: ConnectionData;
+    };
     em: EventEmitter;
-    creatingConnection: boolean;
     exchanges: ExchangesCache;
     queues: QueuesCache;
+    queueSetupPromises: QueueSetupPromisesDictionary;
     options: AfRabbitOptions | undefined;
     redisClient: any;
     redisLock?: RedisLockType;
-    userName: string;
-    password: string;
-    host: string;
     /** Array of consumers tags used for canceling consumption */
     consumersTags: Array<[ConfirmChannel, string]>;
     private consumers;
     constructor(options?: AfRabbitOptions, redisConfig?: RedisConfig);
     private shouldConsumeMessageByTimestamp;
-    ack: (channel: ChannelWrapper, msg: ConsumeMessageOrNull, shouldUpdateRedisTimestamp?: boolean, releaseLock?: null) => (userMsg: ConsumeMessage) => Promise<any>;
-    nack: (channel: ChannelWrapper, queue: string, options: any, deadQueueOptions: Options.AssertQueue, msg: ConsumeMessageOrNull, releaseLock: any) => (userMsg: ConsumeMessageOrNull, { skipRetry, }?: any) => Promise<any>;
-    getConnection(): Promise<AmqpConnectionManager>;
-    getNewChannel({ name, onClose }?: newChannelOpts): Promise<ChannelWrapper>;
-    assertChannel({ force }?: assertChannelOpts): Promise<ChannelWrapper>;
+    ack: (channel: ConfirmChannel, msg: ConsumeMessageOrNull, shouldUpdateRedisTimestamp?: boolean, releaseLock?: null) => (userMsg: ConsumeMessage) => Promise<any>;
+    nack: (channel: ConfirmChannel, queue: string, options: any, deadQueueOptions: Options.AssertQueue, msg: ConsumeMessageOrNull, releaseLock: any) => (userMsg: ConsumeMessageOrNull, { skipRetry, }?: NackOptions) => Promise<any>;
+    getConnection(connectionPurpose: ConnectionPurpose): Promise<AmqpConnectionManager | null | undefined>;
+    getNewChannel({ name, onClose, options, connectionPurpose, }: newChannelOpts): Promise<ChannelWrapper>;
+    assertChannel({ force, connectionPurpose }: assertChannelOpts): Promise<ChannelWrapper>;
     assertExchange(exchangeName: string, options?: any): Promise<any>;
-    getQueueLength(queue: string): Promise<Replies.AssertQueue>;
+    getQueueLength(queue: string, connectionPurpose?: ConnectionPurpose): Promise<Replies.AssertQueue>;
     private deleteQueue;
-    bindQueue(queue: string, exchange: string): Promise<void>;
-    assertQueue(queueName: string, options?: Options.AssertQueue): Promise<any>;
+    bindQueue(queue: string, exchange: string, connectionPurpose: ConnectionPurpose): Promise<void>;
+    setupQueue(queueName: string, connectionPurpose: ConnectionPurpose, options?: Options.AssertQueue): Promise<Replies.AssertQueue>;
+    assertQueue(queueName: string, connectionPurpose: ConnectionPurpose, options?: Options.AssertQueue): Promise<any>;
     private saveConsumer;
-    private loadConsumers;
     consume(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<any>;
     private lockRedisIfNeeded;
     private unlockRedisIfNeeded;
     private consumeFromRabbit;
     consumeFromExchange(queue: string, exchange: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<any>;
     publish(exchange: string, content: any, customHeaders?: any): Promise<boolean>;
-    sendToQueue(queue: string, content: any, options?: any, customHeaders?: any, isBlocking?: boolean): Promise<boolean | undefined>;
-    isConnected(): Promise<boolean>;
+    sendToQueue(queue: string, content: any, options?: any, customHeaders?: any): Promise<boolean | undefined>;
+    isConnected(connectionPurpose: ConnectionPurpose): Promise<boolean>;
     gracefulShutdown(signal: string): Promise<void>;
 }
 export default RabbitMq;