@autofleet/rabbit 2.3.1 → 2.3.4

package/dist/index.d.ts

@@ -62,8 +62,8 @@ declare class RabbitMq implements IAfRabbitMq {
     redisLock?: RedisLockType;
     constructor(options?: AfRabbitOptions, redisConfig?: RedisConfig);
     private shouldConsumeMessageByTimestamp;
-    ack: (channel: ChannelWrapper, msg: ConsumeMessageOrNull, shouldUpdateRedisTimestamp?: boolean) => (userMsg: ConsumeMessage) => Promise<any>;
-    nack: (channel: ChannelWrapper, queue: string, options: any, deadQueueOptions: Options.AssertQueue, msg: ConsumeMessageOrNull) => (userMsg: ConsumeMessageOrNull, { skipRetry, }?: any) => Promise<any>;
+    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(): Promise<ChannelWrapper>;
     assertChannel(): Promise<ChannelWrapper>;
@@ -72,7 +72,8 @@ declare class RabbitMq implements IAfRabbitMq {
     bindQueue(queue: string, exchange: string): Promise<void>;
     assertQueue(queueName: string, options?: Options.AssertQueue): Promise<any>;
     consume(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<any>;
-    private consumeWithLock;
+    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>;

package/dist/index.js

@@ -26,10 +26,13 @@ const redis_1 = __importDefault(require("./redis"));
 const DEFAULT_DEAD_TTL_TWO_DAYS = 60000 * 60 * 48;
 const DEFAULT_LOCK_TIMEOUT = 1000 * 5;
 const RETRY_HEADER = 'x-retry-count';
+const DEFAULT_USE_CONSUME_WITH_LOCK = false;
 const defaultOptions = {
     limit: 1,
     retries: 1,
     deadMessageTtl: DEFAULT_DEAD_TTL_TWO_DAYS,
+    lockTimeout: DEFAULT_LOCK_TIMEOUT,
+    useConsumeWithLock: DEFAULT_USE_CONSUME_WITH_LOCK,
 };
 const assertExchangeFanout = (c, exchangeName) => c.assertExchange(exchangeName, 'fanout');
 const connectionCreatedConst = 'connectionCreated';
@@ -62,7 +65,7 @@ class RabbitMq {
             }
             return false;
         });
-        this.ack = (channel, msg, shouldUpdateRedisTimestamp = false) => (userMsg) => __awaiter(this, void 0, void 0, function* () {
+        this.ack = (channel, msg, shouldUpdateRedisTimestamp = false, releaseLock = null) => (userMsg) => __awaiter(this, void 0, void 0, function* () {
             if (msg) {
                 yield channel.ack(msg);
                 const { properties: { headers } } = msg;
@@ -70,10 +73,12 @@ class RabbitMq {
                 if (shouldUpdateRedisTimestamp && timestamp && (headers === null || headers === void 0 ? void 0 : headers.redisTimestampValidationKey) && this.redisClient) {
                     const parsedTimestamp = parseInt(timestamp, 10);
                     yield this.redisClient.setAsync(headers.redisTimestampValidationKey, parsedTimestamp, 'EX', 3600);
+                    yield this.unlockRedisIfNeeded(releaseLock);
                 }
             }
         });
-        this.nack = (channel, queue, options, deadQueueOptions, msg) => (userMsg, { skipRetry = false, } = {}) => __awaiter(this, void 0, void 0, function* () {
+        this.nack = (channel, queue, options, deadQueueOptions, msg, releaseLock) => (userMsg, { skipRetry = false, } = {}) => __awaiter(this, void 0, void 0, function* () {
+            yield this.unlockRedisIfNeeded(releaseLock);
             if (channel && msg) {
                 if (!skipRetry
                     && (!msg.properties.headers[RETRY_HEADER]
@@ -223,52 +228,38 @@ class RabbitMq {
     }
     consume(queue, callback, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (options && options.useConsumeWithLock) {
-                return this.consumeWithLock(queue, callback, options);
-            }
             return this.consumeFromRabbit(queue, callback, options);
         });
     }
-    consumeWithLock(queue, callback, options) {
+    lockRedisIfNeeded(msg, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.redisLock) {
-                throw new Error('Usage of consumeWithLock requires RedisInstance');
+            const { properties: { headers } } = msg;
+            const timestamp = headers === null || headers === void 0 ? void 0 : headers.creationTimestamp;
+            let releaseLock = null;
+            if (options.useConsumeWithLock && timestamp && (headers === null || headers === void 0 ? void 0 : headers.redisTimestampValidationKey) && this.redisLock) {
+                releaseLock = yield this.redisLock(headers.redisTimestampValidationKey, (options === null || options === void 0 ? void 0 : options.lockTimeout) || DEFAULT_LOCK_TIMEOUT);
+            }
+            return releaseLock;
+        });
+    }
+    unlockRedisIfNeeded(releaseLock) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.redisLock && releaseLock) {
+                yield releaseLock();
             }
-            const lockTimeout = (options === null || options === void 0 ? void 0 : options.lockTimeout) || DEFAULT_LOCK_TIMEOUT;
-            logger_1.default.info(`Consuming with lock from queue ${queue} with lockTimeout: ${lockTimeout}ms`);
-            return this.consumeFromRabbit(queue, (msg, ack, nack) => __awaiter(this, void 0, void 0, function* () {
-                logger_1.default.info('Logs ');
-                if (!msg) {
-                    return null;
-                }
-                const { properties: { headers } } = msg;
-                const timestamp = headers === null || headers === void 0 ? void 0 : headers.creationTimestamp;
-                let releaseLock = null;
-                try {
-                    if (timestamp && (headers === null || headers === void 0 ? void 0 : headers.redisTimestampValidationKey)) {
-                        if (this.redisLock) {
-                            releaseLock = yield this.redisLock(headers.redisTimestampValidationKey, lockTimeout);
-                            yield callback(msg, ack, nack);
-                            yield releaseLock();
-                            return;
-                        }
-                    }
-                    yield callback(msg, ack, nack);
-                }
-                catch (err) {
-                    if (releaseLock) {
-                        yield releaseLock();
-                    }
-                    throw err;
-                }
-            }), options);
         });
     }
     consumeFromRabbit(queue, callback, options) {
         return __awaiter(this, void 0, void 0, function* () {
             const optionsWithDefaults = Object.assign(Object.assign({}, defaultOptions), options);
             RabbitMq.validateName('queue', queue);
-            const { limit, deadMessageTtl } = optionsWithDefaults;
+            const { limit, deadMessageTtl, useConsumeWithLock, lockTimeout, } = optionsWithDefaults;
+            if (useConsumeWithLock) {
+                if (!this.redisLock) {
+                    throw new Error('Usage of consumeWithLock requires RedisInstance');
+                }
+                logger_1.default.info(`Consuming with lock from queue ${queue} with lockTimeout: ${lockTimeout}ms`);
+            }
             const channel = yield this.getNewChannel();
             return channel.addSetup((c) => __awaiter(this, void 0, void 0, function* () {
                 yield c.assertQueue(queue);
@@ -279,15 +270,17 @@ class RabbitMq {
                             return null;
                         }
                         const parsedMessage = RabbitMq.parseMsg(msg);
+                        const releaseLock = yield this.lockRedisIfNeeded(parsedMessage, optionsWithDefaults);
                         const shouldConsume = yield this.shouldConsumeMessageByTimestamp(parsedMessage);
                         if (!shouldConsume) {
+                            yield this.unlockRedisIfNeeded(releaseLock);
                             return this.ack(channel, msg)(msg);
                         }
                         try {
-                            yield callback(parsedMessage, this.ack(channel, msg, true), this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg));
+                            yield callback(parsedMessage, this.ack(channel, msg, true, releaseLock), this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock));
                         }
                         catch (e) {
-                            yield this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg)(msg);
+                            yield this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock)(msg);
                         }
                     })),
                 ]);
@@ -325,7 +318,6 @@ class RabbitMq {
     }
     sendToQueue(queue, content, options, customHeaders) {
         return __awaiter(this, void 0, void 0, function* () {
-            logger_1.default.info('ss', RabbitMq.getPublishOptions(customHeaders));
             return wrapSetImmediate(() => __awaiter(this, void 0, void 0, function* () {
                 RabbitMq.validateName('queue', queue);
                 const channel = yield this.assertChannel();

package/package.json

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

package/src/index.ts

@@ -55,11 +55,14 @@ export interface AfRabbitOptions {
 const DEFAULT_DEAD_TTL_TWO_DAYS = 60000 * 60 * 48;
 const DEFAULT_LOCK_TIMEOUT = 1000 * 5;
 const RETRY_HEADER = 'x-retry-count';
+const DEFAULT_USE_CONSUME_WITH_LOCK = false;
 
 const defaultOptions = {
   limit: 1,
   retries: 1,
   deadMessageTtl: DEFAULT_DEAD_TTL_TWO_DAYS,
+  lockTimeout: DEFAULT_LOCK_TIMEOUT,
+  useConsumeWithLock: DEFAULT_USE_CONSUME_WITH_LOCK,
 };
 
 const assertExchangeFanout = (c: any, exchangeName: string) => c.assertExchange(exchangeName, 'fanout');
@@ -162,7 +165,7 @@ class RabbitMq implements IAfRabbitMq {
     return false;
   }
 
-  public ack = (channel: ChannelWrapper, msg: ConsumeMessageOrNull, shouldUpdateRedisTimestamp = false) => async (userMsg: ConsumeMessage) : Promise<any> => {
+  public ack = (channel: ChannelWrapper, msg: ConsumeMessageOrNull, shouldUpdateRedisTimestamp = false, releaseLock = null) => async (userMsg: ConsumeMessage) : Promise<any> => {
     if (msg) {
       await channel.ack(msg);
       const { properties: { headers } } = msg;
@@ -171,6 +174,7 @@ class RabbitMq implements IAfRabbitMq {
       if (shouldUpdateRedisTimestamp && timestamp && headers?.redisTimestampValidationKey && this.redisClient) {
         const parsedTimestamp = parseInt(timestamp, 10);
         await this.redisClient.setAsync(headers.redisTimestampValidationKey, parsedTimestamp, 'EX', 3600);
+        await this.unlockRedisIfNeeded(releaseLock);
       }
     }
   }
@@ -181,12 +185,14 @@ class RabbitMq implements IAfRabbitMq {
     options: any,
     deadQueueOptions: Options.AssertQueue,
     msg: ConsumeMessageOrNull,
+    releaseLock: any,
   ) => async (
     userMsg: ConsumeMessageOrNull,
     {
       skipRetry = false,
     }: any = { },
   ) : Promise<any> => {
+    await this.unlockRedisIfNeeded(releaseLock);
     if (channel && msg) {
       if (
         !skipRetry
@@ -305,53 +311,41 @@ class RabbitMq implements IAfRabbitMq {
   }
 
   async consume(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<any> {
-    if (options && options.useConsumeWithLock) {
-      return this.consumeWithLock(queue, callback, options);
-    }
     return this.consumeFromRabbit(queue, callback, options);
   }
 
-  private async consumeWithLock(queue: string, callback: CallbackFunction, options?: ConsumeOptions) : Promise<any> {
-    if (!this.redisLock) {
-      throw new Error('Usage of consumeWithLock requires RedisInstance');
+  private async lockRedisIfNeeded(msg: any, options: any) {
+    const { properties: { headers } } = msg;
+    const timestamp = headers?.creationTimestamp;
+    let releaseLock = null;
+
+    if (options.useConsumeWithLock && timestamp && headers?.redisTimestampValidationKey && this.redisLock) {
+      releaseLock = await this.redisLock(
+        headers.redisTimestampValidationKey,
+        options?.lockTimeout || DEFAULT_LOCK_TIMEOUT,
+      );
     }
-    const lockTimeout = options?.lockTimeout || DEFAULT_LOCK_TIMEOUT;
-    logger.info(`Consuming with lock from queue ${queue} with lockTimeout: ${lockTimeout}ms`);
-    return this.consumeFromRabbit(queue, async (msg, ack, nack) => {
-      logger.info('Logs ');
-      if (!msg) {
-        return null;
-      }
-      const { properties: { headers } } = msg;
-      const timestamp = headers?.creationTimestamp;
-      let releaseLock = null;
+    return releaseLock;
+  }
 
-      try {
-        if (timestamp && headers?.redisTimestampValidationKey) {
-          if (this.redisLock) {
-            releaseLock = await this.redisLock(
-              headers.redisTimestampValidationKey,
-              lockTimeout,
-            );
-            await callback(msg, ack, nack);
-            await releaseLock();
-            return;
-          }
-        }
-        await callback(msg, ack, nack);
-      } catch (err) {
-        if (releaseLock) {
-          await releaseLock();
-        }
-        throw err;
-      }
-    }, options);
+  private async unlockRedisIfNeeded(releaseLock: any) {
+    if (this.redisLock && releaseLock) {
+      await releaseLock();
+    }
   }
 
   private async consumeFromRabbit(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<any> {
     const optionsWithDefaults = { ...defaultOptions, ...options };
     RabbitMq.validateName('queue', queue);
-    const { limit, deadMessageTtl } = optionsWithDefaults;
+    const {
+      limit, deadMessageTtl, useConsumeWithLock, lockTimeout,
+    } = optionsWithDefaults;
+    if (useConsumeWithLock) {
+      if (!this.redisLock) {
+        throw new Error('Usage of consumeWithLock requires RedisInstance');
+      }
+      logger.info(`Consuming with lock from queue ${queue} with lockTimeout: ${lockTimeout}ms`);
+    }
     const channel: ChannelWrapper = await this.getNewChannel();
     return channel.addSetup(async (c: ConfirmChannel) => {
       await c.assertQueue(queue);
@@ -364,18 +358,20 @@ class RabbitMq implements IAfRabbitMq {
               return null;
             }
             const parsedMessage = RabbitMq.parseMsg(msg);
+            const releaseLock = await this.lockRedisIfNeeded(parsedMessage, optionsWithDefaults);
             const shouldConsume = await this.shouldConsumeMessageByTimestamp(parsedMessage);
             if (!shouldConsume) {
+              await this.unlockRedisIfNeeded(releaseLock);
               return this.ack(channel, msg)(msg);
             }
             try {
               await callback(
                 parsedMessage,
-                this.ack(channel, msg, true),
-                this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg),
+                this.ack(channel, msg, true, releaseLock),
+                this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock),
               );
             } catch (e) {
-              await this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg)(msg);
+              await this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock)(msg);
             }
           },
         ),
@@ -418,7 +414,6 @@ class RabbitMq implements IAfRabbitMq {
   }
 
   async sendToQueue(queue: string, content: any, options?: any, customHeaders?: any) : Promise<boolean> {
-    logger.info('ss', RabbitMq.getPublishOptions(customHeaders));
     return wrapSetImmediate(async () => {
       RabbitMq.validateName('queue', queue);
       const channel: ChannelWrapper = await this.assertChannel();