@autofleet/rabbit 2.2.4-beta-2 → 2.2.6

package/dist/index.d.ts

@@ -25,6 +25,7 @@ declare type CustomMessageHeaders = {
     redisTimestampValidationKey?: string;
 };
 declare type RedisLockType = (args0?: string, arg1?: number) => Promise<any>;
+declare type ConsumeMessageOrNull = ConsumeMessage | null;
 interface ConsumeOptions {
     retries?: number;
     deadMessageTtl?: number;
@@ -58,8 +59,8 @@ declare class RabbitMq implements IAfRabbitMq {
     redisLock?: RedisLockType;
     constructor(options?: AfRabbitOptions, redisConfig?: RedisConfig);
     private shouldConsumeMessageByTimestamp;
-    ack: (channel: ChannelWrapper, shouldUpdateRedisTimestamp?: boolean) => (msg: ConsumeMessage) => Promise<any>;
-    nack: (channel: ChannelWrapper, queue: string, options: any, deadQueueOptions: Options.AssertQueue) => (msg: any, { skipRetry, }?: any) => Promise<void>;
+    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>;
     assertChannel(): Promise<ChannelWrapper>;
@@ -71,7 +72,7 @@ declare class RabbitMq implements IAfRabbitMq {
     private consumeWithLock;
     private consumeFromRabbit;
     consumeFromExchange(queue: string, exchange: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<any>;
-    publish(exchange: string, content: any, customHeaders?: any): Promise<any>;
+    publish(exchange: string, content: any, customHeaders?: any): Promise<boolean>;
     sendToQueue(queue: string, content: any, options?: any, customHeaders?: any): Promise<boolean>;
     isConnected(): Promise<boolean>;
 }

package/dist/index.js

@@ -25,6 +25,7 @@ const rabbitError_1 = __importDefault(require("./rabbitError"));
 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 defaultOptions = {
     limit: 1,
     retries: 1,
@@ -32,6 +33,17 @@ const defaultOptions = {
 };
 const assertExchangeFanout = (c, exchangeName) => c.assertExchange(exchangeName, 'fanout');
 const connectionCreatedConst = 'connectionCreated';
+const wrapSetImmediate = (callback) => new Promise((resolve, reject) => __awaiter(void 0, void 0, void 0, function* () {
+    setImmediate(() => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            const value = yield callback();
+            resolve(value);
+        }
+        catch (error) {
+            reject(error);
+        }
+    }));
+}));
 class RabbitMq {
     constructor(options, redisConfig) {
         this.PUBLISH_TIMEOUT = Number(process.env.RABBITMQ_PUBLISH_TIMEOUT) || 60000;
@@ -52,26 +64,34 @@ 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, { skipRetry = false, } = {}) => __awaiter(this, void 0, void 0, function* () {
-            if (channel) {
+        this.nack = (channel, queue, options, deadQueueOptions, msg) => (userMsg, { skipRetry = false, } = {}) => __awaiter(this, void 0, void 0, function* () {
+            if (channel && msg) {
                 if (!skipRetry
-                    && (!msg.content['x-retry-count']
-                        || msg.content['x-retry-count'] < options.retries)) {
-                    msg.content['x-retry-count'] = msg.content['x-retry-count'] ? msg.content['x-retry-count'] + 1 : 1;
-                    yield this.sendToQueue(queue, msg.content);
+                    && (!msg.properties.headers[RETRY_HEADER]
+                        || parseInt(msg.properties.headers[RETRY_HEADER], 10) < options.retries)) {
+                    yield this.sendToQueue(queue, RabbitMq.parseMsg(msg).content, options, {
+                        [RETRY_HEADER]: msg.properties.headers[RETRY_HEADER]
+                            ? msg.properties.headers[RETRY_HEADER] + 1
+                            : 1,
+                    });
                 }
                 else {
                     const deadQueue = `${queue}-dead`;
-                    yield this.assertQueue(deadQueue, deadQueueOptions);
-                    yield this.sendToQueue(deadQueue, msg.content, deadQueueOptions);
+                    yield this.sendToQueue(deadQueue, RabbitMq.parseMsg(msg).content, deadQueueOptions, {
+                        [RETRY_HEADER]: msg.properties.headers[RETRY_HEADER]
+                            ? msg.properties.headers[RETRY_HEADER] + 1
+                            : 1,
+                    });
                 }
                 yield channel.ack(msg);
             }
@@ -264,13 +284,13 @@ 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 }));
+                            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);
+                            yield this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg)(msg);
                         }
                     })),
                 ]);
@@ -298,29 +318,23 @@ class RabbitMq {
     }
     publish(exchange, content, customHeaders) {
         return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-                setImmediate(() => __awaiter(this, void 0, void 0, function* () {
-                    try {
-                        RabbitMq.validateName('exchange', exchange);
-                        const channel = yield this.assertChannel();
-                        yield this.assertExchange(exchange);
-                        yield channel.publish(exchange, '', Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions(customHeaders));
-                        resolve(true);
-                    }
-                    catch (error) {
-                        reject(error);
-                    }
-                }));
+            return wrapSetImmediate(() => __awaiter(this, void 0, void 0, function* () {
+                RabbitMq.validateName('exchange', exchange);
+                const channel = yield this.assertChannel();
+                yield this.assertExchange(exchange);
+                yield channel.publish(exchange, '', Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions(customHeaders));
             }));
         });
     }
     sendToQueue(queue, content, options, customHeaders) {
         return __awaiter(this, void 0, void 0, function* () {
-            RabbitMq.validateName('queue', queue);
-            const channel = yield this.assertChannel();
-            yield this.assertQueue(queue, options);
-            logger_1.default.info('rabbit: sending to queue', { queue, content, customHeaders });
-            return channel.sendToQueue(queue, Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions(customHeaders));
+            return wrapSetImmediate(() => __awaiter(this, void 0, void 0, function* () {
+                RabbitMq.validateName('queue', queue);
+                const channel = yield this.assertChannel();
+                yield this.assertQueue(queue, options);
+                logger_1.default.info('rabbit: sending to queue', { queue, content, customHeaders });
+                return channel.sendToQueue(queue, Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions(customHeaders));
+            }));
         });
     }
     isConnected() {

package/package.json

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

package/src/index.ts

@@ -54,6 +54,7 @@ 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 defaultOptions = {
   limit: 1,
@@ -65,6 +66,17 @@ const assertExchangeFanout = (c: any, exchangeName: string) => c.assertExchange(
 
 const connectionCreatedConst = 'connectionCreated';
 
+const wrapSetImmediate = (callback: () => any) => new Promise<any>(async (resolve, reject) => {
+  setImmediate(async () => {
+    try {
+      const value = await callback();
+      resolve(value);
+    } catch (error) {
+      reject(error);
+    }
+  });
+});
+
 class RabbitMq implements IAfRabbitMq {
   static parseMsg(msg: any) : any {
     let { content } = msg;
@@ -148,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);
+      }
     }
   }
 
@@ -162,24 +176,33 @@ class RabbitMq implements IAfRabbitMq {
     queue: string,
     options: any,
     deadQueueOptions: Options.AssertQueue,
+    msg: ConsumeMessageOrNull,
   ) => async (
-    msg: any,
+    userMsg: ConsumeMessageOrNull,
     {
       skipRetry = false,
     }: any = { },
-  ) => {
-    if (channel) {
+  ) : Promise<any> => {
+    if (channel && msg) {
       if (
         !skipRetry
-        && (!msg.content['x-retry-count']
-        || msg.content['x-retry-count'] < options.retries)
+        && (
+          !msg.properties.headers[RETRY_HEADER]
+          || parseInt(msg.properties.headers[RETRY_HEADER], 10) < options.retries
+        )
       ) {
-        msg.content['x-retry-count'] = msg.content['x-retry-count'] ? msg.content['x-retry-count'] + 1 : 1;
-        await this.sendToQueue(queue, msg.content);
+        await this.sendToQueue(queue, RabbitMq.parseMsg(msg).content, options, {
+          [RETRY_HEADER]: msg.properties.headers[RETRY_HEADER]
+            ? msg.properties.headers[RETRY_HEADER] + 1
+            : 1,
+        });
       } else {
         const deadQueue = `${queue}-dead`;
-        await this.assertQueue(deadQueue, deadQueueOptions);
-        await this.sendToQueue(deadQueue, msg.content, deadQueueOptions);
+        await this.sendToQueue(deadQueue, RabbitMq.parseMsg(msg).content, deadQueueOptions, {
+          [RETRY_HEADER]: msg.properties.headers[RETRY_HEADER]
+            ? msg.properties.headers[RETRY_HEADER] + 1
+            : 1,
+        });
       }
       await channel.ack(msg);
     }
@@ -334,16 +357,16 @@ 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.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }),
+                this.ack(channel, msg, true),
+                this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg),
               );
             } catch (e) {
-              await this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl })(msg);
+              await this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg)(msg);
             }
           },
         ),
@@ -374,32 +397,27 @@ class RabbitMq implements IAfRabbitMq {
     });
   }
 
-  async publish(exchange: string, content: any, customHeaders?: any) : Promise<any> {
-    return new Promise<any>(async (resolve, reject) => {
-      setImmediate(async () => {
-        try {
-          RabbitMq.validateName('exchange', exchange);
-          const channel: ChannelWrapper = await this.assertChannel();
-          await this.assertExchange(exchange);
-          await channel.publish(exchange, '',
-            Buffer.from(JSON.stringify(content)),
-            RabbitMq.getPublishOptions(customHeaders));
-          resolve(true);
-        } catch (error) {
-          reject(error);
-        }
-      });
+  async publish(exchange: string, content: any, customHeaders?: any) : Promise<boolean> {
+    return wrapSetImmediate(async () => {
+      RabbitMq.validateName('exchange', exchange);
+      const channel: ChannelWrapper = await this.assertChannel();
+      await this.assertExchange(exchange);
+      await channel.publish(exchange, '',
+        Buffer.from(JSON.stringify(content)),
+        RabbitMq.getPublishOptions(customHeaders));
     });
   }
 
   async sendToQueue(queue: string, content: any, options?: any, customHeaders?: any) : Promise<boolean> {
-    RabbitMq.validateName('queue', queue);
-    const channel: ChannelWrapper = await this.assertChannel();
-    await this.assertQueue(queue, options);
-    logger.info('rabbit: sending to queue', { queue, content, customHeaders });
-    return channel.sendToQueue(queue,
-      Buffer.from(JSON.stringify(content)),
-      RabbitMq.getPublishOptions(customHeaders));
+    return wrapSetImmediate(async () => {
+      RabbitMq.validateName('queue', queue);
+      const channel: ChannelWrapper = await this.assertChannel();
+      await this.assertQueue(queue, options);
+      logger.info('rabbit: sending to queue', { queue, content, customHeaders });
+      return channel.sendToQueue(queue,
+        Buffer.from(JSON.stringify(content)),
+        RabbitMq.getPublishOptions(customHeaders));
+    });
   }
 
   async isConnected() : Promise<boolean> {

package/tsconfig.json

@@ -5,7 +5,9 @@
     "declaration": true,
     "outDir": "./dist",
     "strict": true,
-    "esModuleInterop": true
+    "esModuleInterop": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true
   },
   "exclude": ["node_modules", "**/*.test.ts"]
 }