@autofleet/rabbit 3.2.21-beta.0 → 3.2.21-beta.0.1

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, AssertExchangePromisesDictionary } from './lib/types';
 export interface IAfRabbitMq {
     ack: any;
     nack: any;
@@ -66,6 +66,7 @@ declare class RabbitMq implements IAfRabbitMq {
     exchanges: ExchangesCache;
     queues: QueuesCache;
     queueSetupPromises: QueueSetupPromisesDictionary;
+    assertExchangePromises: AssertExchangePromisesDictionary;
     options: AfRabbitOptions | undefined;
     redisClient: any;
     redisLock?: RedisLockType;
@@ -93,6 +94,7 @@ declare class RabbitMq implements IAfRabbitMq {
     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): Promise<boolean | undefined>;
+    sendToCeleryQueue(queue: string, taskName: string, data: any, options?: any, customHeaders?: any): Promise<boolean | undefined>;
     isConnected(): Promise<boolean>;
     gracefulShutdown(signal: string): Promise<void>;
 }

package/dist/index.js

@@ -6,7 +6,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const events_1 = require("events");
 const util_1 = require("util");
-const lodash_1 = __importDefault(require("lodash"));
 const moment_1 = __importDefault(require("moment"));
 const redis_lock_1 = __importDefault(require("redis-lock"));
 const amqp_connection_manager_1 = require("amqp-connection-manager");
@@ -124,6 +123,7 @@ class RabbitMq {
         this.exchanges = {};
         this.queues = {};
         this.queueSetupPromises = {};
+        this.assertExchangePromises = {};
         this.consumers = [];
         this.options = options;
         this.redisClient = redisConfig && (0, redis_1.default)(redisConfig);
@@ -199,6 +199,7 @@ class RabbitMq {
                 }
             });
             this.connection.on('disconnect', ({ err }) => {
+                // this.channel = null;
                 this.consumersTags = [];
                 debug('rabbit: connection closed');
                 if (this.options?.disableReconnect) {
@@ -266,11 +267,15 @@ class RabbitMq {
     async assertExchange(exchangeName, options) {
         const channel = await this.assertChannel();
         if (this.exchanges[exchangeName]) {
+            delete this.assertExchangePromises[exchangeName];
             return this.exchanges[exchangeName];
         }
-        const exchange = await (0, utils_1.assertExchangeFanout)(channel, exchangeName);
-        this.exchanges[exchangeName] = exchange;
-        return exchange;
+        if (this.assertExchangePromises[exchangeName]) {
+            return this.assertExchangePromises[exchangeName];
+        }
+        this.assertExchangePromises[exchangeName] = (0, utils_1.assertExchangeFanout)(channel, exchangeName);
+        this.exchanges[exchangeName] = await this.assertExchangePromises[exchangeName];
+        return this.exchanges[exchangeName];
     }
     async getQueueLength(queue) {
         RabbitMq.validateName('queue', queue);
@@ -377,7 +382,6 @@ class RabbitMq {
         return channel.addSetup(async (confirmChannel) => {
             await confirmChannel.assertQueue(queue, options ? { messageTtl: options.messageTtl } : undefined);
             await confirmChannel.prefetch(limit, true);
-            const channelConsumerOptions = optionsWithDefaults.channelConsumeOptions ? lodash_1.default.merge(types_1.CONSUMER_DEFAULT_OPTIONS, optionsWithDefaults.channelConsumeOptions) : types_1.CONSUMER_DEFAULT_OPTIONS;
             const { consumerTag } = await confirmChannel.consume(queue, async (msg) => {
                 if (!msg) {
                     return null;
@@ -438,7 +442,7 @@ class RabbitMq {
                 catch (e) {
                     await localNack(msg);
                 }
-            }, channelConsumerOptions);
+            }, types_1.CONSUMER_DEFAULT_OPTIONS);
             if (!consumerTag) {
                 logger_1.default.error(`rabbit: failed to consume from queue ${queue}`);
             }
@@ -501,6 +505,47 @@ class RabbitMq {
             throw e;
         }
     }
+    async sendToCeleryQueue(queue, taskName, data, options, customHeaders) {
+        try {
+            await this.assertChannel();
+        }
+        catch (e) {
+            logger_1.default.error(`rabbit sendToCeleryQueue: failed to assert channel when sending to queue ${queue}`, { e });
+            throw e;
+        }
+        try {
+            RabbitMq.validateName('queue', queue);
+            await this.assertQueue(queue, options);
+        }
+        catch (e) {
+            logger_1.default.error(`rabbit sendToCeleryQueue: failed to assert queue ${queue}`, { e });
+            throw e;
+        }
+        try {
+            // Create Celery-compatible message format
+            const celeryMessage = {
+                task: taskName,
+                id: (0, node_crypto_1.randomUUID)(),
+                args: [data],
+            };
+            const celeryHeaders = {
+                ...RabbitMq.getPublishOptions(customHeaders),
+                properties: {
+                    delivery_mode: 2,
+                    content_type: 'application/json',
+                    content_encoding: 'utf-8',
+                },
+            };
+            const res = await this.channel?.sendToQueue(queue, Buffer.from(JSON.stringify(celeryMessage)), celeryHeaders);
+            debug(`rabbit: sending to celery queue ${queue}`, { res });
+            return res;
+        }
+        catch (e) {
+            const isConnected = await this.isConnected();
+            logger_1.default.error(`rabbit sendToCeleryQueue: failed to send to queue ${queue}, isConnected: ${isConnected}`, { e });
+            throw e;
+        }
+    }
     async isConnected() {
         const connection = await this.getConnection();
         const isConnected = connection.isConnected();

package/dist/lib/types.d.ts

@@ -8,6 +8,9 @@ export interface QueuesCache {
 export interface QueueSetupPromisesDictionary {
     [key: string]: Promise<Replies.AssertQueue> | undefined;
 }
+export interface AssertExchangePromisesDictionary {
+    [key: string]: Promise<Replies.AssertExchange> | undefined;
+}
 export type CustomMessageHeaders = {
     redisTimestampValidationKey?: string;
 };
@@ -22,7 +25,6 @@ export interface ConsumeOptions {
     useConsumeWithLock?: boolean;
     auditContext?: any;
     enableRabbitTrace?: boolean;
-    channelConsumeOptions?: Options.Consume;
 }
 export type CallbackFunction = (msg: ConsumeMessage, ack: any, nack: any) => Promise<any>;
 export type newChannelOpts = {

package/dist/lib/utils.d.ts

@@ -1,5 +1,5 @@
 import { ChannelWrapper } from 'amqp-connection-manager';
-import { ConfirmChannel } from 'amqplib';
-export declare const assertExchangeFanout: (c: ChannelWrapper | ConfirmChannel, exchangeName: string) => Promise<import("amqplib").Replies.AssertExchange>;
+import { ConfirmChannel, Replies } from 'amqplib';
+export declare const assertExchangeFanout: (c: ChannelWrapper | ConfirmChannel, exchangeName: string) => Promise<Replies.AssertExchange>;
 export declare const wrapSetImmediate: (callback: () => any) => Promise<any>;
 export declare const rand: () => number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/rabbit",
-  "version": "3.2.21-beta.0",
+  "version": "3.2.21-beta.0.1",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
@@ -19,7 +19,6 @@
     "amqp-connection-manager": "4.1.9",
     "amqplib": "0.10.3",
     "bluebird": "^3.7.2",
-    "lodash": "^4.17.21",
     "moment": "^2.29.1",
     "redis": "^3.1.2",
     "redis-lock": "^0.1.4"
@@ -31,7 +30,6 @@
     "@autofleet/logger": "4.0.6",
     "@types/amqplib": "0.8.2",
     "@types/jest": "^29.5.12",
-    "@types/lodash": "^4.17.12",
     "@types/node": "^20.14.11",
     "@typescript-eslint/eslint-plugin": "^4.8.1",
     "eslint": "^7.13.0",

package/src/index.ts

@@ -2,7 +2,6 @@
 
 import { EventEmitter, once } from 'events';
 import { promisify } from 'util';
-import _ from 'lodash';
 import moment from 'moment';
 import RedisLock from 'redis-lock';
 import {
@@ -36,7 +35,10 @@ import {
   CustomMessageHeaders,
   QueuesCache,
   RedisLockType,
-  ExchangesCache, CONSUMER_DEFAULT_OPTIONS, QueueSetupPromisesDictionary,
+  ExchangesCache,
+  CONSUMER_DEFAULT_OPTIONS,
+  QueueSetupPromisesDictionary,
+  AssertExchangePromisesDictionary,
 } from './lib/types';
 
 // const debug = nodeDebug('af-rabbitmq')
@@ -158,6 +160,8 @@ class RabbitMq implements IAfRabbitMq {
 
   queueSetupPromises: QueueSetupPromisesDictionary;
 
+  assertExchangePromises: AssertExchangePromisesDictionary;
+
   options: AfRabbitOptions | undefined;
 
   redisClient: any;
@@ -178,6 +182,7 @@ class RabbitMq implements IAfRabbitMq {
     this.exchanges = {};
     this.queues = {};
     this.queueSetupPromises = {};
+    this.assertExchangePromises = {};
     this.consumers = [];
     this.options = options;
     this.redisClient = redisConfig && getRedisInstance(redisConfig);
@@ -336,6 +341,7 @@ class RabbitMq implements IAfRabbitMq {
       });
 
       this.connection.on('disconnect', ({ err }) => {
+        // this.channel = null;
         this.consumersTags = [];
         debug('rabbit: connection closed');
         if (this.options?.disableReconnect) {
@@ -345,6 +351,7 @@ class RabbitMq implements IAfRabbitMq {
           logger.error(`${this.RECONNECT_MSG}${err && ` - ${err}`}`);
         }
       });
+
       this.connection.once('connect', async () => {
         debug('rabbit: connection established');
         this.creatingConnection = false;
@@ -402,12 +409,19 @@ class RabbitMq implements IAfRabbitMq {
 
   async assertExchange(exchangeName: string, options?: any) {
     const channel: ChannelWrapper = await this.assertChannel();
+
     if (this.exchanges[exchangeName]) {
+      delete this.assertExchangePromises[exchangeName];
       return this.exchanges[exchangeName];
     }
-    const exchange = await assertExchangeFanout(channel, exchangeName);
-    this.exchanges[exchangeName] = exchange;
-    return exchange;
+
+    if (this.assertExchangePromises[exchangeName]) {
+      return this.assertExchangePromises[exchangeName];
+    }
+
+    this.assertExchangePromises[exchangeName] = assertExchangeFanout(channel, exchangeName);
+    this.exchanges[exchangeName] = await this.assertExchangePromises[exchangeName];
+    return this.exchanges[exchangeName];
   }
 
   async getQueueLength(queue: string) {
@@ -532,7 +546,6 @@ class RabbitMq implements IAfRabbitMq {
     return channel.addSetup(async (confirmChannel: ConfirmChannel) => {
       await confirmChannel.assertQueue(queue, options ? { messageTtl: options.messageTtl } : undefined);
       await confirmChannel.prefetch(limit, true);
-      const channelConsumerOptions = optionsWithDefaults.channelConsumeOptions ? _.merge(CONSUMER_DEFAULT_OPTIONS, optionsWithDefaults.channelConsumeOptions) : CONSUMER_DEFAULT_OPTIONS;
       const { consumerTag } = await confirmChannel.consume(
         queue,
         async (msg: ConsumeMessageOrNull) => {
@@ -604,8 +617,7 @@ class RabbitMq implements IAfRabbitMq {
           } catch (e) {
             await localNack(msg);
           }
-        },
-        channelConsumerOptions,
+        }, CONSUMER_DEFAULT_OPTIONS,
       );
       if (!consumerTag) {
         logger.error(`rabbit: failed to consume from queue ${queue}`);
@@ -685,6 +697,60 @@ class RabbitMq implements IAfRabbitMq {
     }
   }
 
+  async sendToCeleryQueue(
+    queue: string,
+    taskName: string,
+    data: any,
+    options?: any,
+    customHeaders?: any,
+  ): Promise<boolean | undefined> {
+    try {
+      await this.assertChannel();
+    } catch (e) {
+      logger.error(`rabbit sendToCeleryQueue: failed to assert channel when sending to queue ${queue}`, { e });
+      throw e;
+    }
+
+    try {
+      RabbitMq.validateName('queue', queue);
+      await this.assertQueue(queue, options);
+    } catch (e) {
+      logger.error(`rabbit sendToCeleryQueue: failed to assert queue ${queue}`, { e });
+      throw e;
+    }
+
+    try {
+      // Create Celery-compatible message format
+      const celeryMessage = {
+        task: taskName,
+        id: randomUUID(),
+        args: [data],
+      };
+
+      const celeryHeaders = {
+        ...RabbitMq.getPublishOptions(customHeaders),
+        properties: {
+          delivery_mode: 2,
+          content_type: 'application/json',
+          content_encoding: 'utf-8',
+        },
+      };
+
+      const res = await this.channel?.sendToQueue(
+        queue,
+        Buffer.from(JSON.stringify(celeryMessage)),
+        celeryHeaders,
+      );
+
+      debug(`rabbit: sending to celery queue ${queue}`, { res });
+      return res;
+    } catch (e) {
+      const isConnected = await this.isConnected();
+      logger.error(`rabbit sendToCeleryQueue: failed to send to queue ${queue}, isConnected: ${isConnected}`, { e });
+      throw e;
+    }
+  }
+
   async isConnected() : Promise<boolean> {
     const connection = await this.getConnection();
     const isConnected = connection.isConnected();

package/src/lib/types.ts

@@ -12,6 +12,10 @@ export interface QueueSetupPromisesDictionary {
   [key: string]: Promise<Replies.AssertQueue> | undefined
 }
 
+export interface AssertExchangePromisesDictionary {
+  [key: string]: Promise<Replies.AssertExchange> | undefined
+}
+
 export type CustomMessageHeaders = {
   redisTimestampValidationKey?: string;
 }
@@ -27,7 +31,6 @@ export interface ConsumeOptions {
   useConsumeWithLock?: boolean;
   auditContext?: any;
   enableRabbitTrace?: boolean;
-  channelConsumeOptions?: Options.Consume;
 }
 
 export type CallbackFunction = (msg: ConsumeMessage, ack: any, nack: any) => Promise<any>

package/src/lib/utils.ts

@@ -1,7 +1,11 @@
 import { ChannelWrapper } from 'amqp-connection-manager';
-import { ConfirmChannel } from 'amqplib';
+import { ConfirmChannel, Replies } from 'amqplib';
+
+export const assertExchangeFanout = async (
+  c: ChannelWrapper | ConfirmChannel,
+  exchangeName: string,
+): Promise<Replies.AssertExchange> => c.assertExchange(exchangeName, 'fanout');
 
-export const assertExchangeFanout = async (c: ChannelWrapper | ConfirmChannel, exchangeName: string) => c.assertExchange(exchangeName, 'fanout');
 export const wrapSetImmediate = (callback: () => any) => new Promise<any>((resolve, reject) => {
   setImmediate(async () => {
     try {