@autofleet/rabbit 3.2.19-beta.6 → 3.2.19-beta.7

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 } from './lib/types';
+import { CallbackFunction, ConsumeMessageOrNull, ConsumeOptions, CustomMessageHeaders, QueuesCache, RedisLockType, ExchangesCache, QueueSetupPromisesDictionary, ConnectionRole } from './lib/types';
 export interface IAfRabbitMq {
     ack: any;
     nack: any;
@@ -37,10 +37,12 @@ type newChannelOpts = {
     name?: string;
     onClose?: null | ((args: any | null) => void);
     options?: CreateChannelOpts | undefined;
+    connectionRole: ConnectionRole;
 };
 type assertChannelOpts = {
     channelName?: string;
     force?: boolean;
+    connectionRole: ConnectionRole;
 };
 declare class RabbitMq implements IAfRabbitMq {
     static parseMsg(msg: any): any;
@@ -58,10 +60,13 @@ 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;
+    consumeConnection: AmqpConnectionManager | null | undefined;
+    publishConnection: AmqpConnectionManager | null | undefined;
     em: EventEmitter;
-    creatingConnection: boolean;
+    creatingConsumeConnection: boolean;
+    creatingPublishConnection: boolean;
     exchanges: ExchangesCache;
     queues: QueuesCache;
     queueSetupPromises: QueueSetupPromisesDictionary;
@@ -75,15 +80,19 @@ declare class RabbitMq implements IAfRabbitMq {
     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(): Promise<AmqpConnectionManager>;
-    getNewChannel({ name, onClose, options }?: newChannelOpts): Promise<ChannelWrapper>;
-    assertChannel({ force }?: assertChannelOpts): Promise<ChannelWrapper>;
+    geConnectionByRole: (connectionRole: ConnectionRole) => {
+        connectionByRole: AmqpConnectionManager | null | undefined;
+        creatingConnectionByRole: boolean;
+    };
+    getConnection(connectionRole: ConnectionRole): Promise<AmqpConnectionManager | null | undefined>;
+    getNewChannel({ name, onClose, options, connectionRole, }?: newChannelOpts): Promise<ChannelWrapper>;
+    assertChannel({ force, connectionRole }?: assertChannelOpts): Promise<ChannelWrapper>;
     assertExchange(exchangeName: string, options?: any): Promise<any>;
-    getQueueLength(queue: string): Promise<Replies.AssertQueue>;
+    getQueueLength(queue: string, connectionRole?: ConnectionRole): Promise<Replies.AssertQueue>;
     private deleteQueue;
-    bindQueue(queue: string, exchange: string): Promise<void>;
-    setupQueue(queueName: string, options?: Options.AssertQueue): Promise<Replies.AssertQueue>;
-    assertQueue(queueName: string, options?: Options.AssertQueue): Promise<any>;
+    bindQueue(queue: string, exchange: string, connectionRole: ConnectionRole): Promise<void>;
+    setupQueue(queueName: string, connectionRole: ConnectionRole, options?: Options.AssertQueue): Promise<Replies.AssertQueue>;
+    assertQueue(queueName: string, connectionRole: ConnectionRole, options?: Options.AssertQueue): Promise<any>;
     private saveConsumer;
     consume(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<any>;
     private lockRedisIfNeeded;
@@ -91,8 +100,8 @@ declare class RabbitMq implements IAfRabbitMq {
     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(connectionRole: ConnectionRole): Promise<boolean>;
     gracefulShutdown(signal: string): Promise<void>;
 }
 export default RabbitMq;

package/dist/index.js

@@ -115,10 +115,16 @@ class RabbitMq {
                 });
             }
         };
+        this.geConnectionByRole = (connectionRole) => (connectionRole === types_1.ConnectionRole.Consumer
+            ? { connectionByRole: this.consumeConnection, creatingConnectionByRole: this.creatingConsumeConnection }
+            : { connectionByRole: this.publishConnection, creatingConnectionByRole: this.creatingPublishConnection });
         this.em = new events_1.EventEmitter();
         this.channel = null;
-        this.connection = null;
-        this.creatingConnection = false;
+        this.publishChannelSetupPromise = null;
+        this.consumeConnection = null;
+        this.publishConnection = null;
+        this.creatingPublishConnection = false;
+        this.creatingConsumeConnection = false;
         this.exchanges = {};
         this.queues = {};
         this.queueSetupPromises = {};
@@ -139,30 +145,31 @@ class RabbitMq {
             });
         }
     }
-    async getConnection() {
+    async getConnection(connectionRole) {
         return new Promise(async (resolve, reject) => {
+            let { connectionByRole, creatingConnectionByRole } = this.geConnectionByRole(connectionRole);
             if (this.blockReconnect) {
                 debug('rabbit: block reconnect');
                 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
                 // @ts-ignore
                 return resolve();
             }
-            if (this.connection !== null) {
-                if (this.options?.disableReconnect || this.connection?.isConnected()) {
+            if (connectionByRole !== null) {
+                if (this.options?.disableReconnect || connectionByRole?.isConnected()) {
                     debug('rabbit: connection - is connected');
                     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
                     // @ts-ignore
-                    return resolve(this.connection);
+                    return resolve(connectionByRole);
                 }
                 debug('rabbit: connection - reconnecting');
             }
-            if (this.creatingConnection) {
+            if (creatingConnectionByRole) {
                 debug('rabbit: creating connection emi');
                 this.em.once(consts_1.CONNECTION_CREATED_CONST, resolve);
                 this.em.once(consts_1.CONNECTION_FAILED_CONST, reject);
                 return;
             }
-            this.creatingConnection = true;
+            creatingConnectionByRole = true;
             let isResolved = false;
             // It is import to use it as a function and not as a variable
             // because of k8s changes the env variables
@@ -175,11 +182,15 @@ class RabbitMq {
                 return [`amqp://${userName}:${password}@${host}?heartbeat=${HEARTBEAT}`];
             };
             const defaultUrls = findServers();
-            const connection = await (0, amqp_connection_manager_1.connect)(defaultUrls, {
+            const newConnection = await (0, amqp_connection_manager_1.connect)(defaultUrls, {
                 findServers,
             });
-            this.connection = connection;
-            this.connection.on('error', (err) => {
+            if (!newConnection) {
+                logger_1.default.error('rabbit: couldnt create a connection');
+                return resolve(connectionByRole);
+            }
+            connectionByRole = newConnection;
+            connectionByRole.on('error', (err) => {
                 logger_1.default.error('rabbit: connection error', { err });
                 if (!isResolved) {
                     isResolved = true;
@@ -187,7 +198,7 @@ class RabbitMq {
                     this.em.emit(consts_1.CONNECTION_FAILED_CONST, err);
                 }
             });
-            this.connection.on('connectFailed', (err) => {
+            connectionByRole.on('connectFailed', (err) => {
                 this.consumersTags = [];
                 logger_1.default.error('rabbit: connection connectFailed', { err });
                 if (!isResolved) {
@@ -196,7 +207,7 @@ class RabbitMq {
                     this.em.emit(consts_1.CONNECTION_FAILED_CONST, err);
                 }
             });
-            this.connection.on('disconnect', ({ err }) => {
+            connectionByRole.on('disconnect', ({ err }) => {
                 this.consumersTags = [];
                 debug('rabbit: connection closed');
                 if (this.options?.disableReconnect) {
@@ -207,24 +218,27 @@ class RabbitMq {
                     logger_1.default.error(`${this.RECONNECT_MSG}${err && ` - ${err}`}`);
                 }
             });
-            this.connection.once('connect', async () => {
+            connectionByRole.once('connect', async () => {
                 debug('rabbit: connection established');
-                this.creatingConnection = false;
-                this.em.emit(consts_1.CONNECTION_CREATED_CONST, connection);
+                creatingConnectionByRole = false;
+                this.em.emit(consts_1.CONNECTION_CREATED_CONST, connectionByRole);
                 isResolved = true;
-                resolve(connection);
+                resolve(connectionByRole);
             });
         });
     }
-    async getNewChannel({ name = (0, utils_1.rand)().toString(), onClose = null, options = {} } = {}) {
+    async getNewChannel({ name = (0, utils_1.rand)().toString(), onClose = null, options = {}, connectionRole, } = { connectionRole: types_1.ConnectionRole.Consumer }) {
         let connection;
         try {
-            connection = await this.getConnection();
+            connection = await this.getConnection(connectionRole);
         }
         catch (e) {
             logger_1.default.error(`rabbit: error on get connection for new channel ${name} `, { e });
             throw e;
         }
+        if (!connection) {
+            throw new Error(`rabbit: couldnt get connection for new channel ${name}`);
+        }
         const channel = connection.createChannel({ ...options });
         (0, events_1.once)(channel, 'close').then((args) => {
             logger_1.default.error(`rabbit: channel ${name} closed`);
@@ -240,26 +254,29 @@ class RabbitMq {
             throw err;
         }
     }
-    async assertChannel({ force = false } = {}) {
-        return new Promise(async (resolve, reject) => {
-            if (this.channel && !force) {
-                return resolve(this.channel);
-            }
-            try {
-                const channel = await this.getNewChannel({});
-                channel.on('error', (err) => {
-                    logger_1.default.error('rabbit: channel error', { err });
-                });
-                this.channel = channel;
-                resolve(channel);
-            }
-            catch (e) {
-                reject(e);
-            }
-        });
+    async assertChannel({ force = false, connectionRole } = { connectionRole: types_1.ConnectionRole.Consumer }) {
+        if (!this.publishChannelSetupPromise) {
+            this.publishChannelSetupPromise = new Promise(async (resolve, reject) => {
+                if (this.channel && !force) {
+                    return resolve(this.channel);
+                }
+                try {
+                    const channel = await this.getNewChannel({ connectionRole });
+                    channel.on('error', (err) => {
+                        logger_1.default.error('rabbit: channel error', { err });
+                    });
+                    this.channel = channel;
+                    resolve(channel);
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
+        }
+        return this.publishChannelSetupPromise;
     }
     async assertExchange(exchangeName, options) {
-        const channel = await this.assertChannel();
+        const channel = await this.assertChannel({ connectionRole: options.connectionRole });
         if (this.exchanges[exchangeName]) {
             return this.exchanges[exchangeName];
         }
@@ -267,32 +284,33 @@ class RabbitMq {
         this.exchanges[exchangeName] = exchange;
         return exchange;
     }
-    async getQueueLength(queue) {
+    async getQueueLength(queue, connectionRole = types_1.ConnectionRole.Consumer) {
         RabbitMq.validateName('queue', queue);
+        const { connectionByRole } = this.geConnectionByRole(connectionRole);
         const { channel } = this;
         if (!channel) {
             throw new Error('channel is not defined');
         }
-        debug('rabbit: getting queue length', { queue, connected: this.connection?.isConnected() });
+        debug('rabbit: getting queue length', { queue, connected: connectionByRole?.isConnected() });
         return channel?.checkQueue(queue);
     }
-    async deleteQueue(queue) {
+    async deleteQueue(queue, connectionRole) {
         RabbitMq.validateName('queue', queue);
-        const channel = await this.assertChannel();
+        const channel = await this.assertChannel({ connectionRole });
         logger_1.default.info('rabbit: deleting queue', { queue });
         const deleteQueueRes = await channel.deleteQueue(queue);
         debug('queue deleted', deleteQueueRes);
         return deleteQueueRes;
     }
-    async bindQueue(queue, exchange) {
-        const channel = await this.assertChannel();
+    async bindQueue(queue, exchange, connectionRole) {
+        const channel = await this.assertChannel({ connectionRole });
         await channel.addSetup((setupChannel) => setupChannel.bindQueue(queue, exchange, ''));
         return channel.bindQueue(queue, exchange, '');
     }
-    async setupQueue(queueName, options) {
+    async setupQueue(queueName, connectionRole, options) {
         let queue;
         try {
-            const channel = await this.assertChannel();
+            const channel = await this.assertChannel({ connectionRole });
             debug('assertQueue->channel.addSetup', { queueName });
             await channel.addSetup((setupChannel) => setupChannel.assertQueue(queueName, options));
             debug('assertQueue->channel.assertQueue', { queueName });
@@ -302,8 +320,8 @@ class RabbitMq {
             logger_1.default.error('rabbit: assertQueue error', { queueName, options, error: e });
             if (!this.options?.dontRetryAssert) {
                 debug('retrying assertQueue', { queueName });
-                const channel = await this.assertChannel({ force: true });
-                await this.deleteQueue(queueName);
+                const channel = await this.assertChannel({ force: true, connectionRole });
+                await this.deleteQueue(queueName, connectionRole);
                 debug('retrying assertQueue->channel.addSetup', { queueName });
                 await channel.addSetup((setupChannel) => setupChannel.assertQueue(queueName, options));
                 debug('retrying assertQueue->channel.assertQueue', { queueName });
@@ -316,7 +334,7 @@ class RabbitMq {
         this.queues[queueName] = queueName;
         return queue;
     }
-    async assertQueue(queueName, options) {
+    async assertQueue(queueName, connectionRole, options) {
         RabbitMq.validateName('queue', queueName);
         if (this.queues[queueName]) {
             delete this.queueSetupPromises[queueName];
@@ -325,7 +343,7 @@ class RabbitMq {
         if (this.queueSetupPromises[queueName]) {
             return this.queueSetupPromises[queueName];
         }
-        this.queueSetupPromises[queueName] = this.setupQueue(queueName, options);
+        this.queueSetupPromises[queueName] = this.setupQueue(queueName, connectionRole, options);
         return this.queueSetupPromises[queueName];
     }
     saveConsumer(queue, callback, options) {
@@ -368,7 +386,7 @@ class RabbitMq {
             }
             logger_1.default.info(`rabbit: Consuming with lock from queue ${queue} with lockTimeout: ${lockTimeout}ms`);
         }
-        const channel = await this.getNewChannel({});
+        const channel = await this.getNewChannel({ connectionRole: types_1.ConnectionRole.Consumer });
         return channel.addSetup(async (confirmChannel) => {
             await confirmChannel.assertQueue(queue, options ? { messageTtl: options.messageTtl } : undefined);
             await confirmChannel.prefetch(limit, true);
@@ -448,7 +466,7 @@ class RabbitMq {
         RabbitMq.validateName('queue', queue);
         const { limit, deadMessageTtl } = optionsWithDefaults;
         await this.saveConsumer(queue, callback, options);
-        const channel = await this.getNewChannel({ name: `consume-exchange-${exchange}-queue-${queue}` });
+        const channel = await this.getNewChannel({ name: `consume - exchange - ${exchange} -queue - ${queue}`, connectionRole: types_1.ConnectionRole.Consumer });
         return channel.addSetup(async (c) => {
             const assertExchange = await (0, utils_1.assertExchangeFanout)(c, exchange);
             await c.assertQueue(queue);
@@ -463,33 +481,44 @@ class RabbitMq {
     async publish(exchange, content, customHeaders) {
         return (0, utils_1.wrapSetImmediate)(async () => {
             RabbitMq.validateName('exchange', exchange);
-            const channel = await this.assertChannel();
-            await this.assertExchange(exchange);
+            const channel = await this.assertChannel({ connectionRole: types_1.ConnectionRole.Publisher });
+            await this.assertExchange(exchange, { connectionRole: types_1.ConnectionRole.Publisher });
             await channel.publish(exchange, '', Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions(customHeaders));
         });
     }
-    async sendToQueue(queue, content, options, customHeaders, isBlocking) {
-        const callback = async () => {
-            try {
-                RabbitMq.validateName('queue', queue);
-                await this.assertChannel();
-                await this.assertQueue(queue, options);
-                const res = await this.channel?.sendToQueue(queue, Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions(customHeaders));
-                debug(`rabbit: sending to queue ${queue}`, { res });
-                return res;
-            }
-            catch (e) {
-                logger_1.default.error(`rabbit: failed to send to queue ${queue}`, { e });
-                throw e;
-            }
-        };
-        if (isBlocking) {
-            return callback();
+    async sendToQueue(queue, content, options, customHeaders) {
+        try {
+            await this.assertChannel({ connectionRole: types_1.ConnectionRole.Publisher });
+        }
+        catch (e) {
+            logger_1.default.error(`rabbit sendToQueue: failed to send assert channel when sending to queue ${queue}`, { e });
+            throw e;
+        }
+        try {
+            RabbitMq.validateName('queue', queue);
+            await this.assertQueue(queue, types_1.ConnectionRole.Publisher, options);
+        }
+        catch (e) {
+            logger_1.default.error(`rabbit sendToQueue: failed to assert queue ${queue}`, { e });
+            throw e;
+        }
+        try {
+            const res = await this.channel?.sendToQueue(queue, Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions(customHeaders));
+            debug(`rabbit: sending to queue ${queue}`, { res });
+            return res;
+        }
+        catch (e) {
+            const isConnected = await this.isConnected(types_1.ConnectionRole.Publisher);
+            logger_1.default.error(`rabbit sendToQueue: failed to send to queue ${queue}, isConnected: ${isConnected}`, { e });
+            throw e;
         }
-        return (0, utils_1.wrapSetImmediate)(callback);
     }
-    async isConnected() {
-        const connection = await this.getConnection();
+    async isConnected(connectionRole) {
+        const connection = await this.getConnection(connectionRole);
+        if (!connection) {
+            logger_1.default.error('rabbit: isConnected - false');
+            return false;
+        }
         const isConnected = connection.isConnected();
         if (!isConnected) {
             logger_1.default.error('rabbit: isConnected - false');

package/dist/lib/types.d.ts

@@ -38,3 +38,7 @@ export type AfConsumer = {
     options: ConsumeOptions | undefined;
 };
 export declare const CONSUMER_DEFAULT_OPTIONS: Options.Consume;
+export declare enum ConnectionRole {
+    Consumer = "consumer",
+    Publisher = "publisher"
+}

package/dist/lib/types.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CONSUMER_DEFAULT_OPTIONS = void 0;
+exports.ConnectionRole = exports.CONSUMER_DEFAULT_OPTIONS = void 0;
 const HA_PROMOTE_ON_FAILURE = 'ha-promote-on-failure';
 const HA_PROMOTE_ON_SHUTDOWN = 'ha-promote-on-shutdown';
 exports.CONSUMER_DEFAULT_OPTIONS = {
@@ -9,3 +9,8 @@ exports.CONSUMER_DEFAULT_OPTIONS = {
         [HA_PROMOTE_ON_SHUTDOWN]: 'always',
     },
 };
+var ConnectionRole;
+(function (ConnectionRole) {
+    ConnectionRole["Consumer"] = "consumer";
+    ConnectionRole["Publisher"] = "publisher";
+})(ConnectionRole = exports.ConnectionRole || (exports.ConnectionRole = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/rabbit",
-  "version": "3.2.19-beta.6",
+  "version": "3.2.19-beta.7",
   "description": "",
   "main": "dist/index.js",
   "scripts": {

package/src/index.ts

@@ -283,7 +283,7 @@ class RabbitMq implements IAfRabbitMq {
     : { connectionByRole: this.publishConnection, creatingConnectionByRole: this.creatingPublishConnection });
 
   async getConnection(connectionRole: ConnectionRole) {
-    return new Promise<AmqpConnectionManager>(async (resolve, reject) => {
+    return new Promise<AmqpConnectionManager | undefined | null>(async (resolve, reject) => {
       let { connectionByRole, creatingConnectionByRole } = this.geConnectionByRole(connectionRole);
       if (this.blockReconnect) {
         debug('rabbit: block reconnect');
@@ -296,7 +296,7 @@ class RabbitMq implements IAfRabbitMq {
           debug('rabbit: connection - is connected');
           // eslint-disable-next-line @typescript-eslint/ban-ts-comment
           // @ts-ignore
-          return resolve(this.connection);
+          return resolve(connectionByRole);
         }
         debug('rabbit: connection - reconnecting');
       }
@@ -327,7 +327,13 @@ class RabbitMq implements IAfRabbitMq {
         findServers,
       });
 
+      if (!newConnection) {
+        logger.error('rabbit: couldnt create a connection');
+        return resolve(connectionByRole);
+      }
+
       connectionByRole = newConnection;
+
       connectionByRole.on('error', (err) => {
         logger.error('rabbit: connection error', { err });
         if (!isResolved) {
@@ -370,13 +376,16 @@ class RabbitMq implements IAfRabbitMq {
   async getNewChannel({
     name = rand().toString(), onClose = null, options = {}, connectionRole,
   }: newChannelOpts = { connectionRole: ConnectionRole.Consumer }): Promise<ChannelWrapper> {
-    let connection!: AmqpConnectionManager;
+    let connection!: AmqpConnectionManager | undefined | null;
     try {
       connection = await this.getConnection(connectionRole);
     } catch (e) {
       logger.error(`rabbit: error on get connection for new channel ${name} `, { e });
       throw e;
     }
+    if (!connection) {
+      throw new Error(`rabbit: couldnt get connection for new channel ${name}`);
+    }
     const channel = connection.createChannel({ ...options });
     once(channel, 'close').then((args) => {
       logger.error(`rabbit: channel ${name} closed`);
@@ -424,7 +433,7 @@ class RabbitMq implements IAfRabbitMq {
     return exchange;
   }
 
-  async getQueueLength(queue: string, connectionRole: ConnectionRole) {
+  async getQueueLength(queue: string, connectionRole: ConnectionRole = ConnectionRole.Consumer): Promise<Replies.AssertQueue> {
     RabbitMq.validateName('queue', queue);
     const { connectionByRole } = this.geConnectionByRole(connectionRole);
     const { channel } = this;
@@ -700,6 +709,10 @@ class RabbitMq implements IAfRabbitMq {
 
   async isConnected(connectionRole: ConnectionRole): Promise<boolean> {
     const connection = await this.getConnection(connectionRole);
+    if (!connection) {
+      logger.error('rabbit: isConnected - false');
+      return false;
+    }
     const isConnected = connection.isConnected();
     if (!isConnected) {
       logger.error('rabbit: isConnected - false');

package/src/lib/types.ts

@@ -56,4 +56,7 @@ export const CONSUMER_DEFAULT_OPTIONS: Options.Consume = {
   },
 };
 
-export type ConnectionRole = 'consumer' | 'publisher';
+export enum ConnectionRole {
+  Consumer = 'consumer',
+  Publisher = 'publisher',
+}