@autofleet/rabbit 3.2.16-beta.2 → 3.2.16-beta.3

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 } from './lib/types';
+import { CallbackFunction, ConsumeMessageOrNull, ConsumeOptions, CustomMessageHeaders, QueuesCache, RedisLockType, ExchangesCache, QueueSetupPromisesDictionary } from './lib/types';
 export interface IAfRabbitMq {
     ack: any;
     nack: any;
@@ -64,7 +64,7 @@ declare class RabbitMq implements IAfRabbitMq {
     creatingConnection: boolean;
     exchanges: ExchangesCache;
     queues: QueuesCache;
-    queueAssertionPromises: Map<string, Promise<Replies.AssertQueue>>;
+    queueSetupPromises: QueueSetupPromisesDictionary;
     options: AfRabbitOptions | undefined;
     redisClient: any;
     redisLock?: RedisLockType;
@@ -82,6 +82,7 @@ declare class RabbitMq implements IAfRabbitMq {
     getQueueLength(queue: string): 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>;
     private saveConsumer;
     consume(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<any>;

package/dist/index.js

@@ -18,7 +18,7 @@ const utils_1 = require("./lib/utils");
 const consts_1 = require("./lib/consts");
 const types_1 = require("./lib/types");
 // const debug = nodeDebug('af-rabbitmq')
-const debug = logger_1.default.info.bind(logger_1.default);
+const debug = logger_1.default.debug.bind(logger_1.default);
 const PUBLISH_TIMEOUT = 1000 * 10;
 const HEARTBEAT = '60';
 class RabbitMq {
@@ -121,7 +121,7 @@ class RabbitMq {
         this.creatingConnection = false;
         this.exchanges = {};
         this.queues = {};
-        this.queueAssertionPromises = new Map();
+        this.queueSetupPromises = {};
         this.consumers = [];
         this.options = options;
         this.redisClient = redisConfig && (0, redis_1.default)(redisConfig);
@@ -289,41 +289,44 @@ class RabbitMq {
         await channel.addSetup((setupChannel) => setupChannel.bindQueue(queue, exchange, ''));
         return channel.bindQueue(queue, exchange, '');
     }
+    async setupQueue(queueName, options) {
+        let queue;
+        try {
+            const channel = await this.assertChannel();
+            debug('assertQueue->channel.addSetup', { queueName });
+            await channel.addSetup((setupChannel) => setupChannel.assertQueue(queueName, options));
+            debug('assertQueue->channel.assertQueue', { queueName });
+            queue = await channel.assertQueue(queueName, options);
+        }
+        catch (e) {
+            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);
+                debug('retrying assertQueue->channel.addSetup', { queueName });
+                await channel.addSetup((setupChannel) => setupChannel.assertQueue(queueName, options));
+                debug('retrying assertQueue->channel.assertQueue', { queueName });
+                queue = await channel.assertQueue(queueName, options);
+            }
+            else {
+                throw e;
+            }
+        }
+        this.queues[queueName] = queueName;
+        return queue;
+    }
     async assertQueue(queueName, options) {
         RabbitMq.validateName('queue', queueName);
         if (this.queues[queueName]) {
+            delete this.queueSetupPromises[queueName];
             return this.queues[queueName];
         }
-        if (this.queueAssertionPromises.has(queueName)) {
-            return this.queueAssertionPromises.get(queueName);
+        if (this.queueSetupPromises[queueName]) {
+            return this.queueSetupPromises[queueName];
         }
-        this.queueAssertionPromises.set(queueName, (async () => {
-            let queue;
-            try {
-                const channel = await this.assertChannel();
-                debug('assertQueue->channel.addSetup', { queueName });
-                await channel.addSetup((setupChannel) => setupChannel.assertQueue(queueName, options));
-                debug('assertQueue->channel.assertQueue', { queueName });
-                queue = await channel.assertQueue(queueName, options);
-            }
-            catch (e) {
-                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);
-                    debug('1assertQueue->channel.addSetup', { queueName });
-                    await channel.addSetup((setupChannel) => setupChannel.assertQueue(queueName, options));
-                    debug('1assertQueue->channel.assertQueue', { queueName });
-                    queue = await channel.assertQueue(queueName, options);
-                }
-                else {
-                    throw e;
-                }
-            }
-            this.queues[queueName] = queueName;
-            return queue;
-        })());
+        this.queueSetupPromises[queueName] = this.setupQueue(queueName, options);
+        return this.queueSetupPromises[queueName];
     }
     saveConsumer(queue, callback, options) {
         const isConsumerExist = this.consumers.some((consumer) => consumer.queue === queue);

package/dist/lib/types.d.ts

@@ -1,10 +1,13 @@
-import { ConsumeMessage, Options } from 'amqplib';
+import { ConsumeMessage, Options, Replies } from 'amqplib';
 export interface ExchangesCache {
     [key: string]: any;
 }
 export interface QueuesCache {
     [key: string]: any;
 }
+export interface QueueSetupPromisesDictionary {
+    [key: string]: Promise<Replies.AssertQueue> | undefined;
+}
 export type CustomMessageHeaders = {
     redisTimestampValidationKey?: string;
 };

package/package.json

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

package/src/index.ts

@@ -35,11 +35,11 @@ import {
   CustomMessageHeaders,
   QueuesCache,
   RedisLockType,
-  ExchangesCache, CONSUMER_DEFAULT_OPTIONS,
+  ExchangesCache, CONSUMER_DEFAULT_OPTIONS, QueueSetupPromisesDictionary,
 } from './lib/types';
 
 // const debug = nodeDebug('af-rabbitmq')
-const debug = logger.info.bind(logger);
+const debug = logger.debug.bind(logger);
 
 const PUBLISH_TIMEOUT = 1000 * 10;
 
@@ -153,7 +153,7 @@ class RabbitMq implements IAfRabbitMq {
 
   queues: QueuesCache;
 
-  queueAssertionPromises: Map<string, Promise<Replies.AssertQueue>>;
+  queueSetupPromises: QueueSetupPromisesDictionary;
 
   options: AfRabbitOptions | undefined;
 
@@ -173,7 +173,7 @@ class RabbitMq implements IAfRabbitMq {
     this.creatingConnection = false;
     this.exchanges = {};
     this.queues = {};
-    this.queueAssertionPromises = new Map<string, Promise<Replies.AssertQueue>>();
+    this.queueSetupPromises = {};
     this.consumers = [];
     this.options = options;
     this.redisClient = redisConfig && getRedisInstance(redisConfig);
@@ -428,43 +428,47 @@ class RabbitMq implements IAfRabbitMq {
     return channel.bindQueue(queue, exchange, '');
   }
 
+  async setupQueue(queueName: string, options?: Options.AssertQueue): Promise<Replies.AssertQueue> {
+    let queue: Replies.AssertQueue;
+    try {
+      const channel: ChannelWrapper = await this.assertChannel();
+      debug('assertQueue->channel.addSetup', { queueName });
+      await channel.addSetup((setupChannel: ConfirmChannel) => setupChannel.assertQueue(queueName, options));
+      debug('assertQueue->channel.assertQueue', { queueName });
+      queue = await channel.assertQueue(queueName, options);
+    } catch (e) {
+      logger.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);
+
+        debug('retrying assertQueue->channel.addSetup', { queueName });
+        await channel.addSetup((setupChannel: ConfirmChannel) => setupChannel.assertQueue(queueName, options));
+        debug('retrying assertQueue->channel.assertQueue', { queueName });
+        queue = await channel.assertQueue(queueName, options);
+      } else {
+        throw e;
+      }
+    }
+
+    this.queues[queueName] = queueName;
+    return queue;
+  }
+
   async assertQueue(queueName: string, options?: Options.AssertQueue) {
     RabbitMq.validateName('queue', queueName);
     if (this.queues[queueName]) {
+      delete this.queueSetupPromises[queueName];
       return this.queues[queueName];
     }
 
-    if (this.queueAssertionPromises.has(queueName)) {
-      return this.queueAssertionPromises.get(queueName);
+    if (this.queueSetupPromises[queueName]) {
+      return this.queueSetupPromises[queueName];
     }
 
-    this.queueAssertionPromises.set(queueName, (async () => {
-      let queue: Replies.AssertQueue;
-      try {
-        const channel: ChannelWrapper = await this.assertChannel();
-        debug('assertQueue->channel.addSetup', { queueName });
-        await channel.addSetup((setupChannel: ConfirmChannel) => setupChannel.assertQueue(queueName, options));
-        debug('assertQueue->channel.assertQueue', { queueName });
-        queue = await channel.assertQueue(queueName, options);
-      } catch (e) {
-        logger.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);
-
-          debug('1assertQueue->channel.addSetup', { queueName });
-          await channel.addSetup((setupChannel: ConfirmChannel) => setupChannel.assertQueue(queueName, options));
-          debug('1assertQueue->channel.assertQueue', { queueName });
-          queue = await channel.assertQueue(queueName, options);
-        } else {
-          throw e;
-        }
-      }
-
-      this.queues[queueName] = queueName;
-      return queue;
-    })());
+    this.queueSetupPromises[queueName] = this.setupQueue(queueName, options);
+    return this.queueSetupPromises[queueName];
   }
 
   private saveConsumer(queue: string, callback: CallbackFunction, options: ConsumeOptions | undefined) {

package/src/lib/types.ts

@@ -1,4 +1,4 @@
-import { ConsumeMessage, Options } from 'amqplib';
+import { ConsumeMessage, Options, Replies } from 'amqplib';
 
 export interface ExchangesCache {
   [key: string]: any
@@ -8,6 +8,10 @@ export interface QueuesCache {
   [key: string]: any
 }
 
+export interface QueueSetupPromisesDictionary {
+  [key: string]: Promise<Replies.AssertQueue> | undefined
+}
+
 export type CustomMessageHeaders = {
   redisTimestampValidationKey?: string;
 }