@autofleet/rabbit 4.0.2 → 4.1.0-beta.0

package/dist/index.d.ts

@@ -3,7 +3,7 @@ import { EventEmitter } from 'events';
 import { AmqpConnectionManager, ChannelWrapper, CreateChannelOpts } from 'amqp-connection-manager';
 import { ConfirmChannel, ConsumeMessage, Options, Replies } from 'amqplib';
 import { RedisConfig } from './lib/redis';
-import { CallbackFunction, ConsumeMessageOrNull, ConsumeOptions, CustomMessageHeaders, QueuesCache, RedisLockType, ExchangesCache, QueueSetupPromisesDictionary, AssertExchangePromisesDictionary, ConnectionData } from './lib/types';
+import { CallbackFunction, ConsumeMessageOrNull, ConsumeOptions, CustomMessageHeaders, QueuesCache, RedisLockType, ExchangesCache, QueueSetupPromisesDictionary, AssertExchangePromisesDictionary } from './lib/types';
 export interface IAfRabbitMq {
     ack: any;
     nack: any;
@@ -38,12 +38,10 @@ type newChannelOpts = {
     name?: string;
     onClose?: null | ((args: any | null) => void);
     options?: CreateChannelOpts | undefined;
-    connection: ConnectionData;
 };
 type assertChannelOpts = {
     channelName?: string;
     force?: boolean;
-    connection: ConnectionData;
 };
 declare class RabbitMq implements IAfRabbitMq {
     static parseMsg(msg: any): any;
@@ -60,54 +58,44 @@ declare class RabbitMq implements IAfRabbitMq {
     };
     DISCONNECT_MSG: string;
     RECONNECT_MSG: string;
-    publishChannel: ChannelWrapper | null;
+    channel: ChannelWrapper | null;
     publishChannelSetupPromise: Promise<ChannelWrapper> | null;
     blockReconnect: boolean | null | undefined;
-    publishConnection: ConnectionData;
-    consumeConnection: ConnectionData;
+    connection: AmqpConnectionManager | null | undefined;
     em: EventEmitter;
     creatingConnection: boolean;
     exchanges: ExchangesCache;
     queues: QueuesCache;
     queueSetupPromises: QueueSetupPromisesDictionary;
     assertExchangePromises: AssertExchangePromisesDictionary;
-    options: AfRabbitOptions;
+    options: AfRabbitOptions | undefined;
     redisClient: any;
     redisLock?: RedisLockType;
     /** Array of consumers tags used for canceling consumption */
-    consumersTags: Map<string, {
-        channel: ConfirmChannel;
-        consumerTag: string;
-    }>;
-    private consumersToRegister;
-    private doesVHostExist;
-    private vhost;
-    private gracefulShutdownStarted;
-    oldPublishChannel: ChannelWrapper | null;
+    consumersTags: Array<[ConfirmChannel, string]>;
+    private consumers;
+    private isVHostExist;
+    oldChannel: ChannelWrapper | null;
     oldPublishChannelSetupPromise: Promise<ChannelWrapper> | null;
     oldBlockReconnect: boolean | null | undefined;
-    oldPublishConnection: ConnectionData;
-    oldConsumeConnection: ConnectionData;
+    oldConnection: AmqpConnectionManager | null | undefined;
     oldEm: EventEmitter;
     oldCreatingConnection: boolean;
     oldExchanges: ExchangesCache;
     oldQueues: QueuesCache;
     oldQueueSetupPromises: QueueSetupPromisesDictionary;
     oldAssertExchangePromises: AssertExchangePromisesDictionary;
-    oldConsumersTags: Map<string, {
-        channel: ConfirmChannel;
-        consumerTag: string;
-    }>;
-    private oldConsumersToRegister;
+    oldConsumersTags: Array<[ConfirmChannel, string]>;
+    private oldConsumers;
     constructor(options?: AfRabbitOptions, redisConfig?: RedisConfig);
     private assertVHost;
     private shouldConsumeMessageByTimestamp;
     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(connection: ConnectionData): Promise<AmqpConnectionManager>;
-    getNewChannel({ name, onClose, options, connection, }: newChannelOpts): Promise<import("amqp-connection-manager/dist/types/ChannelWrapper").default>;
-    assertChannel({ force, connection }: assertChannelOpts): Promise<ChannelWrapper>;
-    assertExchange(exchangeName: string, connection: ConnectionData): Promise<any>;
+    getConnection(): Promise<AmqpConnectionManager>;
+    getNewChannel({ name, onClose, options }?: newChannelOpts): Promise<ChannelWrapper>;
+    assertChannel({ force }?: assertChannelOpts): Promise<ChannelWrapper>;
+    assertExchange(exchangeName: string, options?: any): Promise<any>;
     getQueueLength(queue: string): Promise<Replies.AssertQueue>;
     private deleteQueue;
     bindQueue(queue: string, exchange: string): Promise<void>;
@@ -127,16 +115,14 @@ declare class RabbitMq implements IAfRabbitMq {
     isConnected(): Promise<boolean>;
     gracefulShutdown(signal: string): Promise<void>;
     private consumeFromRabbitOld;
-    getNewChannelOld({ name, onClose, options, connection, }: newChannelOpts): Promise<import("amqp-connection-manager/dist/types/ChannelWrapper").default>;
-    getConnectionOld(connection: ConnectionData): Promise<AmqpConnectionManager>;
+    getNewChannelOld({ name, onClose, options }?: newChannelOpts): Promise<ChannelWrapper>;
+    getConnectionOld(): Promise<AmqpConnectionManager>;
     private saveConsumerOld;
     assertQueueOld(queueName: string, options?: Options.AssertQueue): Promise<any>;
     setupQueueOld(queueName: string, options?: Options.AssertQueue): Promise<Replies.AssertQueue>;
-    assertChannelOld({ force, connection }: assertChannelOpts): Promise<ChannelWrapper>;
+    assertChannelOld({ force }?: assertChannelOpts): Promise<ChannelWrapper>;
     private deleteQueueOld;
-    assertExchangeOld(exchangeName: string, connection: ConnectionData): Promise<any>;
-    isConnectedOld(): Promise<boolean>;
-    private maskURL;
+    assertExchangeOld(exchangeName: string, options?: any): Promise<any>;
 }
 export default RabbitMq;
 export { sendCeleryTaskViaHttp, } from './lib/celery';