@autofleet/rabbit 2.2.5 → 2.2.6

package/dist/index.d.ts

@@ -59,7 +59,7 @@ declare class RabbitMq implements IAfRabbitMq {
     redisLock?: RedisLockType;
     constructor(options?: AfRabbitOptions, redisConfig?: RedisConfig);
     private shouldConsumeMessageByTimestamp;
-    ack: (channel: ChannelWrapper, shouldUpdateRedisTimestamp?: boolean) => (msg: ConsumeMessage) => Promise<any>;
+    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>;
     getConnection(): Promise<AmqpConnectionManager>;
     getNewChannel(): Promise<ChannelWrapper>;

package/dist/index.js

@@ -64,12 +64,14 @@ class RabbitMq {
             }
             return false;
         });
-        this.ack = (channel, shouldUpdateRedisTimestamp = false) => (msg) => __awaiter(this, void 0, void 0, function* () {
-            yield channel.ack(msg);
-            const { properties: { timestamp, headers } } = msg;
-            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);
+        this.ack = (channel, msg, shouldUpdateRedisTimestamp = false) => (userMsg) => __awaiter(this, void 0, void 0, function* () {
+            if (msg) {
+                yield channel.ack(msg);
+                const { properties: { timestamp, headers } } = msg;
+                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);
+                }
             }
         });
         this.nack = (channel, queue, options, deadQueueOptions, msg) => (userMsg, { skipRetry = false, } = {}) => __awaiter(this, void 0, void 0, function* () {
@@ -282,10 +284,10 @@ class RabbitMq {
                         const shouldConsume = yield this.shouldConsumeMessageByTimestamp(parsedMessage);
                         logger_1.default.info('rabbit: trying to consume', { queue, shouldConsume, msg });
                         if (!shouldConsume) {
-                            return this.ack(channel)(msg);
+                            return this.ack(channel, msg)(msg);
                         }
                         try {
-                            yield callback(parsedMessage, this.ack(channel, true), this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg));
+                            yield callback(parsedMessage, this.ack(channel, msg, true), this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg));
                         }
                         catch (e) {
                             yield this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg)(msg);

package/package.json

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

package/src/index.ts

@@ -160,12 +160,14 @@ class RabbitMq implements IAfRabbitMq {
     return false;
   }
 
-  public ack = (channel: ChannelWrapper, shouldUpdateRedisTimestamp = false) => async (msg: ConsumeMessage) : Promise<any> => {
-    await channel.ack(msg);
-    const { properties: { timestamp, headers } } = msg;
-    if (shouldUpdateRedisTimestamp && timestamp && headers?.redisTimestampValidationKey && this.redisClient) {
-      const parsedTimestamp = parseInt(timestamp, 10);
-      await this.redisClient.setAsync(headers.redisTimestampValidationKey, parsedTimestamp, 'EX', 3600);
+  public ack = (channel: ChannelWrapper, msg: ConsumeMessageOrNull, shouldUpdateRedisTimestamp = false) => async (userMsg: ConsumeMessage) : Promise<any> => {
+    if (msg) {
+      await channel.ack(msg);
+      const { properties: { timestamp, headers } } = msg;
+      if (shouldUpdateRedisTimestamp && timestamp && headers?.redisTimestampValidationKey && this.redisClient) {
+        const parsedTimestamp = parseInt(timestamp, 10);
+        await this.redisClient.setAsync(headers.redisTimestampValidationKey, parsedTimestamp, 'EX', 3600);
+      }
     }
   }
 
@@ -355,12 +357,12 @@ class RabbitMq implements IAfRabbitMq {
             const shouldConsume = await this.shouldConsumeMessageByTimestamp(parsedMessage);
             logger.info('rabbit: trying to consume', { queue, shouldConsume, msg });
             if (!shouldConsume) {
-              return this.ack(channel)(msg);
+              return this.ack(channel, msg)(msg);
             }
             try {
               await callback(
                 parsedMessage,
-                this.ack(channel, true),
+                this.ack(channel, msg, true),
                 this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg),
               );
             } catch (e) {