@autofleet/rabbit 3.2.22-beta.5 → 3.2.23-beta.0.0

package/src/index.ts

@@ -18,7 +18,9 @@ import logger from './logger';
 import RabbitError from './lib/rabbitError';
 import getRedisInstance, { RedisConfig } from './lib/redis';
 import { assertExchangeFanout, rand, wrapSetImmediate } from './lib/utils';
+import { sendCeleryTaskViaHttp } from './lib/celery';
 import {
+  AUTOMATION_ID_HEADER,
   CONNECTION_CREATED_CONST,
   CONNECTION_FAILED_CONST,
   DEFAULT_LOCK_TIMEOUT,
@@ -35,15 +37,17 @@ import {
   CustomMessageHeaders,
   QueuesCache,
   RedisLockType,
-  ExchangesCache, CONSUMER_DEFAULT_OPTIONS, QueueSetupPromisesDictionary,
-  ConnectionPurpose,
-  ConnectionData,
+  ExchangesCache,
+  CONSUMER_DEFAULT_OPTIONS,
+  QueueSetupPromisesDictionary,
+  AssertExchangePromisesDictionary,
 } from './lib/types';
 
 // const debug = nodeDebug('af-rabbitmq')
 const debug = logger.debug.bind(logger);
 
 const PUBLISH_TIMEOUT = 1000 * 10;
+
 export interface IAfRabbitMq {
   ack: any;
   nack: any;
@@ -83,13 +87,11 @@ type newChannelOpts = {
   name?: string;
   onClose?: null | ((args: any | null) => void);
   options?: CreateChannelOpts | undefined;
-  connectionPurpose?: ConnectionPurpose,
 };
 
 type assertChannelOpts = {
   channelName?: string;
   force?: boolean;
-  connectionPurpose?: ConnectionPurpose;
 }
 
 type AfConsumer = {
@@ -101,7 +103,7 @@ type AfConsumer = {
 const HEARTBEAT = '60';
 
 class RabbitMq implements IAfRabbitMq {
-  static parseMsg(msg: any): any {
+  static parseMsg(msg: any) : any {
     let { content } = msg;
     content = content.toString();
 
@@ -146,21 +148,22 @@ class RabbitMq implements IAfRabbitMq {
 
   publishChannelSetupPromise: Promise<ChannelWrapper> | null;
 
-  blockReconnect: boolean | null | undefined;
+  blockReconnect: boolean | null | undefined
 
-  connectionsMap: {
-    [ConnectionPurpose.Consume]: ConnectionData;
-    [ConnectionPurpose.Publish]: ConnectionData;
-  };
+  connection: AmqpConnectionManager | null | undefined
 
   em: EventEmitter;
 
+  creatingConnection: boolean;
+
   exchanges: ExchangesCache;
 
   queues: QueuesCache;
 
   queueSetupPromises: QueueSetupPromisesDictionary;
 
+  assertExchangePromises: AssertExchangePromisesDictionary;
+
   options: AfRabbitOptions | undefined;
 
   redisClient: any;
@@ -176,13 +179,12 @@ class RabbitMq implements IAfRabbitMq {
     this.em = new EventEmitter();
     this.channel = null;
     this.publishChannelSetupPromise = null;
-    this.connectionsMap = {
-      [ConnectionPurpose.Consume]: { connection: null, creatingConnection: false },
-      [ConnectionPurpose.Publish]: { connection: null, creatingConnection: false },
-    };
+    this.connection = null;
+    this.creatingConnection = false;
     this.exchanges = {};
     this.queues = {};
     this.queueSetupPromises = {};
+    this.assertExchangePromises = {};
     this.consumers = [];
     this.options = options;
     this.redisClient = redisConfig && getRedisInstance(redisConfig);
@@ -215,7 +217,7 @@ class RabbitMq implements IAfRabbitMq {
     return false;
   }
 
-  public ack = (channel: ConfirmChannel, msg: ConsumeMessageOrNull, shouldUpdateRedisTimestamp = false, releaseLock = null) => async (userMsg: ConsumeMessage): Promise<any> => {
+  public ack = (channel: ConfirmChannel, msg: ConsumeMessageOrNull, shouldUpdateRedisTimestamp = false, releaseLock = null) => async (userMsg: ConsumeMessage) : Promise<any> => {
     if (msg) {
       debug('rabbit acking message', { deliveryTag: msg.fields.deliveryTag });
       await channel.ack(msg);
@@ -241,8 +243,8 @@ class RabbitMq implements IAfRabbitMq {
     userMsg: ConsumeMessageOrNull,
     {
       skipRetry = false,
-    }: NackOptions = {},
-  ): Promise<any> => {
+    }: NackOptions = { },
+  ) : Promise<any> => {
     await this.unlockRedisIfNeeded(releaseLock);
     if (channel && msg) {
       if (
@@ -276,32 +278,30 @@ class RabbitMq implements IAfRabbitMq {
     }
   }
 
-  async getConnection(connectionPurpose: ConnectionPurpose) {
-    return new Promise<AmqpConnectionManager | undefined | null>(async (resolve, reject) => {
-      const { connection, creatingConnection } = this.connectionsMap[connectionPurpose];
-      debug('rabbit: start getting new connection', { connection, creatingConnection, connectionPurpose });
+  async getConnection() {
+    return new Promise<AmqpConnectionManager>(async (resolve, reject) => {
       if (this.blockReconnect) {
         debug('rabbit: block reconnect');
         // eslint-disable-next-line @typescript-eslint/ban-ts-comment
         // @ts-ignore
         return resolve();
       }
-      if (connection !== null) {
-        if (this.options?.disableReconnect || connection?.isConnected()) {
+      if (this.connection !== null) {
+        if (this.options?.disableReconnect || this.connection?.isConnected()) {
           debug('rabbit: connection - is connected');
           // eslint-disable-next-line @typescript-eslint/ban-ts-comment
           // @ts-ignore
-          return resolve(connection);
+          return resolve(this.connection);
         }
         debug('rabbit: connection - reconnecting');
       }
-      if (creatingConnection) {
+      if (this.creatingConnection) {
         debug('rabbit: creating connection emi');
         this.em.once(CONNECTION_CREATED_CONST, resolve);
         this.em.once(CONNECTION_FAILED_CONST, reject);
         return;
       }
-      this.connectionsMap[connectionPurpose].creatingConnection = true;
+      this.creatingConnection = true;
       let isResolved = false;
 
       // It is import to use it as a function and not as a variable
@@ -318,13 +318,12 @@ class RabbitMq implements IAfRabbitMq {
       };
 
       const defaultUrls = findServers();
-      const newConnection: AmqpConnectionManager = await connect(defaultUrls, {
+      const connection: AmqpConnectionManager = await connect(defaultUrls, {
         findServers,
       });
 
-      this.connectionsMap[connectionPurpose].connection = newConnection;
-
-      newConnection.on('error', (err) => {
+      this.connection = connection;
+      this.connection.on('error', (err) => {
         logger.error('rabbit: connection error', { err });
         if (!isResolved) {
           isResolved = true;
@@ -333,7 +332,7 @@ class RabbitMq implements IAfRabbitMq {
         }
       });
 
-      newConnection.on('connectFailed', (err) => {
+      this.connection.on('connectFailed', (err) => {
         this.consumersTags = [];
         logger.error('rabbit: connection connectFailed', { err });
         if (!isResolved) {
@@ -343,7 +342,8 @@ class RabbitMq implements IAfRabbitMq {
         }
       });
 
-      newConnection.on('disconnect', ({ err }) => {
+      this.connection.on('disconnect', ({ err }) => {
+        // this.channel = null;
         this.consumersTags = [];
         debug('rabbit: connection closed');
         if (this.options?.disableReconnect) {
@@ -353,29 +353,25 @@ class RabbitMq implements IAfRabbitMq {
           logger.error(`${this.RECONNECT_MSG}${err && ` - ${err}`}`);
         }
       });
-      newConnection.once('connect', async () => {
-        debug('rabbit: connection established', { connectionPurpose, connection: this.connectionsMap[connectionPurpose] });
-        this.connectionsMap[connectionPurpose].creatingConnection = false;
-        this.em.emit(CONNECTION_CREATED_CONST, newConnection);
+
+      this.connection.once('connect', async () => {
+        debug('rabbit: connection established');
+        this.creatingConnection = false;
+        this.em.emit(CONNECTION_CREATED_CONST, connection);
         isResolved = true;
-        resolve(newConnection);
+        resolve(connection);
       });
     });
   }
 
-  async getNewChannel({
-    name = rand().toString(), onClose = null, options = {}, connectionPurpose = ConnectionPurpose.Consume,
-  }: newChannelOpts): Promise<ChannelWrapper> {
-    let connection!: AmqpConnectionManager | undefined | null;
+  async getNewChannel({ name = rand().toString(), onClose = null, options = {} }: newChannelOpts = {}) {
+    let connection!: AmqpConnectionManager;
     try {
-      connection = await this.getConnection(connectionPurpose);
+      connection = await this.getConnection();
     } catch (e) {
       logger.error(`rabbit: error on get connection for new channel ${name} `, { e });
       throw e;
     }
-    if (!connection) {
-      throw new Error(`rabbit: couldnt get connection for new channel ${name}`);
-    }
     const channel = connection.createChannel({ ...options });
     once(channel, 'close').then((args) => {
       logger.error(`rabbit: channel ${name} closed`);
@@ -391,8 +387,7 @@ class RabbitMq implements IAfRabbitMq {
     }
   }
 
-  async assertChannel({ force = false, connectionPurpose = ConnectionPurpose.Consume }: assertChannelOpts): Promise<ChannelWrapper> {
-    debug('rabbit: start assert channel', { connectionPurpose, publishPromise: this.publishChannelSetupPromise, channel: this.channel });
+  async assertChannel({ force = false } : assertChannelOpts = {}): Promise<ChannelWrapper> {
     if (!this.publishChannelSetupPromise) {
       this.publishChannelSetupPromise = new Promise<ChannelWrapper>(async (resolve, reject) => {
         if (this.channel && !force) {
@@ -400,8 +395,7 @@ class RabbitMq implements IAfRabbitMq {
         }
 
         try {
-          const channel = await this.getNewChannel({ connectionPurpose });
-          debug('rabbit: new channel got', { connectionPurpose, channel: this.channel });
+          const channel = await this.getNewChannel({});
           channel.on('error', (err) => {
             logger.error('rabbit: channel error', { err });
           });
@@ -415,73 +409,102 @@ class RabbitMq implements IAfRabbitMq {
     return this.publishChannelSetupPromise;
   }
 
-  async assertExchange(exchangeName: string, options: any = { connectionPurpose: ConnectionPurpose.Consume }) {
-    const channel: ChannelWrapper = await this.assertChannel({ connectionPurpose: options.connectionPurpose });
+  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, connectionPurpose: ConnectionPurpose = ConnectionPurpose.Consume): Promise<Replies.AssertQueue> {
+  async getQueueLength(queue: string) {
     RabbitMq.validateName('queue', queue);
-    const { connection } = this.connectionsMap[connectionPurpose];
     const { channel } = this;
     if (!channel) {
       throw new Error('channel is not defined');
     }
-    debug('rabbit: getting queue length', { queue, connected: connection?.isConnected() });
+    debug('rabbit: getting queue length', { queue, connected: this.connection?.isConnected() });
     return channel?.checkQueue(queue);
   }
 
-  private async deleteQueue(queue: string, connectionPurpose: ConnectionPurpose) {
+  private async deleteQueue(queue: string) {
     RabbitMq.validateName('queue', queue);
-    const channel: ChannelWrapper = await this.assertChannel({ connectionPurpose });
+    const channel: ChannelWrapper = await this.assertChannel();
     logger.info('rabbit: deleting queue', { queue });
     const deleteQueueRes = await channel.deleteQueue(queue);
     debug('queue deleted', deleteQueueRes);
     return deleteQueueRes;
   }
 
-  async bindQueue(queue: string, exchange: string, connectionPurpose: ConnectionPurpose) {
-    const channel: ChannelWrapper = await this.assertChannel({ connectionPurpose });
+  async bindQueue(queue: string, exchange: string) {
+    const channel: ChannelWrapper = await this.assertChannel();
     await channel.addSetup((setupChannel: ConfirmChannel) => setupChannel.bindQueue(queue, exchange, ''));
     return channel.bindQueue(queue, exchange, '');
   }
 
-  async setupQueue(queueName: string, connectionPurpose: ConnectionPurpose, options?: Options.AssertQueue): Promise<Replies.AssertQueue> {
+  async setupQueue(queueName: string, options?: Options.AssertQueue): Promise<Replies.AssertQueue> {
     let queue: Replies.AssertQueue;
-    debug('rabbit: start setup queue', { queueName, connectionPurpose });
+    const shouldUseQuorum = RabbitMq.shouldUseQuorum(queueName);
+    const localeOptions = {
+      ...options,
+      durable: true,
+      arguments: {
+        ...options?.arguments,
+        'x-consumer-timeout': 1000 * 60 * 60 * 24,
+        'x-queue-type': shouldUseQuorum ? 'quorum' : 'classic',
+      },
+    };
     try {
-      const channel: ChannelWrapper = await this.assertChannel({ connectionPurpose });
+      const channel: ChannelWrapper = await this.assertChannel();
       debug('assertQueue->channel.addSetup', { queueName });
-      await channel.addSetup((setupChannel: ConfirmChannel) => setupChannel.assertQueue(queueName, options));
+      await channel.addSetup((setupChannel: ConfirmChannel) => setupChannel.assertQueue(queueName, localeOptions));
       debug('assertQueue->channel.assertQueue', { queueName });
-      queue = await channel.assertQueue(queueName, options);
+      queue = await channel.assertQueue(queueName, localeOptions);
     } 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, connectionPurpose });
-        await this.deleteQueue(queueName, connectionPurpose);
+        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));
+        await channel.addSetup((setupChannel: ConfirmChannel) => setupChannel.assertQueue(queueName, localeOptions));
         debug('retrying assertQueue->channel.assertQueue', { queueName });
-        queue = await channel.assertQueue(queueName, options);
+        queue = await channel.assertQueue(queueName, localeOptions);
       } else {
         throw e;
       }
     }
-    debug('rabbit: done setup queue', { queueName, connectionPurpose });
-    this.queues[queueName] = queueName;
+
+    this.queues[queueName] = queue;
     return queue;
   }
 
-  async assertQueue(queueName: string, connectionPurpose: ConnectionPurpose, options?: Options.AssertQueue) {
-    debug('rabbit: start assert queue', { connectionPurpose, queueName });
+  static shouldUseQuorum(queueName: string): boolean {
+    const envQuorumQueuesWhitelist = process.env.QUORUM_QUEUES_WHITELIST;
+
+    if (envQuorumQueuesWhitelist === '*') {
+      return true;
+    }
+
+    if (envQuorumQueuesWhitelist) {
+      const whitelist = envQuorumQueuesWhitelist.split(',');
+      return whitelist.includes(queueName);
+    }
+
+    return false;
+  }
+
+  async assertQueue(queueName: string, options?: Options.AssertQueue): Promise<any> {
     RabbitMq.validateName('queue', queueName);
     if (this.queues[queueName]) {
       delete this.queueSetupPromises[queueName];
@@ -492,13 +515,12 @@ class RabbitMq implements IAfRabbitMq {
       return this.queueSetupPromises[queueName];
     }
 
-    this.queueSetupPromises[queueName] = this.setupQueue(queueName, connectionPurpose, options);
-    debug('rabbit: done assert queue', { connectionPurpose, queueName });
+    this.queueSetupPromises[queueName] = this.setupQueue(queueName, options);
     return this.queueSetupPromises[queueName];
   }
 
   private saveConsumer(queue: string, callback: CallbackFunction, options: ConsumeOptions | undefined) {
-    const isConsumerExist: boolean = this.consumers.some((consumer) => consumer.queue === queue);
+    const isConsumerExist :boolean = this.consumers.some((consumer) => consumer.queue === queue);
     if (!isConsumerExist) {
       logger.info(`rabbit: consumer: ${queue} saved in consumer array`);
       this.consumers.push({
@@ -547,10 +569,10 @@ class RabbitMq implements IAfRabbitMq {
       }
       logger.info(`rabbit: Consuming with lock from queue ${queue} with lockTimeout: ${lockTimeout}ms`);
     }
-    const channel = await this.getNewChannel({ connectionPurpose: ConnectionPurpose.Consume });
+    const channel = await this.getNewChannel({});
     return channel.addSetup(async (confirmChannel: ConfirmChannel) => {
-      await confirmChannel.assertQueue(queue, options ? { messageTtl: options.messageTtl } : undefined);
-      await confirmChannel.prefetch(limit, true);
+      const q = await this.assertQueue(queue, optionsWithDefaults);
+      await confirmChannel.prefetch(limit, false);
       const { consumerTag } = await confirmChannel.consume(
         queue,
         async (msg: ConsumeMessageOrNull) => {
@@ -560,6 +582,7 @@ class RabbitMq implements IAfRabbitMq {
 
           const traceId = msg.properties.headers[TRACING_HEADER];
           const userId = msg.properties.headers[USER_TRACING_HEADER];
+          const automationId = msg.properties.headers[AUTOMATION_ID_HEADER];
           const parsedMessage = RabbitMq.parseMsg(msg);
           const releaseLock = await this.lockRedisIfNeeded(parsedMessage, optionsWithDefaults);
           const trace = newTrace(traceTypes.RABBIT);
@@ -585,7 +608,10 @@ class RabbitMq implements IAfRabbitMq {
           }
 
           if (auditContext) {
-            await auditContext(queue);
+            await auditContext(queue, {
+              userId,
+              automationId,
+            });
           }
           const shouldConsume = await this.shouldConsumeMessageByTimestamp(parsedMessage);
           if (!shouldConsume) {
@@ -633,13 +659,13 @@ class RabbitMq implements IAfRabbitMq {
     });
   }
 
-  async consumeFromExchange(queue: string, exchange: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<any> {
+  async consumeFromExchange(queue: string, exchange: string, callback: CallbackFunction, options?: ConsumeOptions) : Promise<any> {
     const optionsWithDefaults = { ...DEFAULT_OPTIONS, ...options };
     RabbitMq.validateName('exchange', exchange);
     RabbitMq.validateName('queue', queue);
     const { limit, deadMessageTtl } = optionsWithDefaults;
     await this.saveConsumer(queue, callback, options);
-    const channel: ChannelWrapper = await this.getNewChannel({ name: `consume - exchange - ${exchange} -queue - ${queue}` });
+    const channel: ChannelWrapper = await this.getNewChannel({ name: `consume-exchange-${exchange}-queue-${queue}` });
 
     return channel.addSetup(async (c: ConfirmChannel) => {
       const assertExchange = await assertExchangeFanout(c, exchange);
@@ -657,11 +683,11 @@ class RabbitMq implements IAfRabbitMq {
     });
   }
 
-  async publish(exchange: string, content: any, customHeaders?: any): Promise<boolean> {
+  async publish(exchange: string, content: any, customHeaders?: any) : Promise<boolean> {
     return wrapSetImmediate(async () => {
       RabbitMq.validateName('exchange', exchange);
-      const channel: ChannelWrapper = await this.assertChannel({ connectionPurpose: ConnectionPurpose.Publish });
-      await this.assertExchange(exchange, { connectionPurpose: ConnectionPurpose.Publish });
+      const channel: ChannelWrapper = await this.assertChannel();
+      await this.assertExchange(exchange);
       await channel.publish(exchange, '',
         Buffer.from(JSON.stringify(content)),
         RabbitMq.getPublishOptions(customHeaders));
@@ -675,7 +701,7 @@ class RabbitMq implements IAfRabbitMq {
     customHeaders?: any,
   ): Promise<boolean | undefined> {
     try {
-      await this.assertChannel({ connectionPurpose: ConnectionPurpose.Publish });
+      await this.assertChannel();
     } catch (e) {
       logger.error(`rabbit sendToQueue: failed to send assert channel when sending to queue ${queue}`, { e });
       throw e;
@@ -683,7 +709,7 @@ class RabbitMq implements IAfRabbitMq {
 
     try {
       RabbitMq.validateName('queue', queue);
-      await this.assertQueue(queue, ConnectionPurpose.Publish, options);
+      await this.assertQueue(queue, options);
     } catch (e) {
       logger.error(`rabbit sendToQueue: failed to assert queue ${queue}`, { e });
       throw e;
@@ -696,41 +722,34 @@ class RabbitMq implements IAfRabbitMq {
       debug(`rabbit: sending to queue ${queue}`, { res });
       return res;
     } catch (e) {
-      logger.error(`rabbit sendToQueue: failed to send to queue ${queue}`, { e });
+      const isConnected = await this.isConnected();
+      logger.error(`rabbit sendToQueue: failed to send to queue ${queue}, isConnected: ${isConnected}`, { e });
       throw e;
     }
   }
 
-  async isConnected(): Promise<boolean> {
-    const isEachConnectionConnected = await Promise.all(
-      Object.entries(this.connectionsMap).map(async ([connectionPurpose, connectionData]) => {
-        const { connection } = connectionData;
-        if (connectionPurpose === ConnectionPurpose.Publish && !connection) {
-          return true; // The connection hasn't been initialized yet, as no messages have been sent through it
-        }
-        const isConnected = connection?.isConnected();
-        if (!isConnected) {
-          logger.error('rabbit: isConnected - false');
-          return false;
-        }
-        const channel: any = await this.assertChannel({ connectionPurpose: connectionPurpose as ConnectionPurpose });
-        try {
-          await Promise.all([
-            channel.waitForConnect(),
-            ...this.consumers.map((c: AfConsumer) => channel.checkQueue(c.queue)),
-          ]);
-        } catch (e) {
-          logger.error('rabbit: isConnected - false');
-          return false;
-        }
-        logger.info('rabbit: isConnected - true');
-        return true;
-      }),
-    );
-    return isEachConnectionConnected.every((isConnected) => isConnected === true);
+  async isConnected() : Promise<boolean> {
+    const connection = await this.getConnection();
+    const isConnected = connection.isConnected();
+    if (!isConnected) {
+      logger.error('rabbit: isConnected - false');
+      return false;
+    }
+    const channel: any = await this.assertChannel();
+    try {
+      await Promise.all([
+        channel.waitForConnect(),
+        ...this.consumers.map((c: AfConsumer) => channel.checkQueue(c.queue)),
+      ]);
+    } catch (e) {
+      logger.error('rabbit: isConnected - false');
+      return false;
+    }
+    logger.info('rabbit: isConnected - true');
+    return true;
   }
 
-  async gracefulShutdown(signal: string): Promise<void> {
+  async gracefulShutdown(signal: string) : Promise<void> {
     const tagsNumber = this.consumersTags.length;
     logger.info(`rabbit: [gracefully-shutdown] received ${signal}! canceling #${tagsNumber} tags...`);
     const cancelTagPromises = this.consumersTags.map(([channel, tag]) => channel.cancel(tag));
@@ -747,3 +766,7 @@ class RabbitMq implements IAfRabbitMq {
 }
 
 export default RabbitMq;
+
+export {
+  sendCeleryTaskViaHttp,
+};

package/src/lib/celery.ts

@@ -0,0 +1,89 @@
+import { randomUUID } from 'node:crypto';
+import logger from '../logger';
+// Environment configuration
+const config = {
+    host: process.env.RABBITMQ_SERVICE_HOST || 'localhost',
+    username: process.env.RABBITMQ_USERNAME || 'guest',
+    password: process.env.RABBITMQ_PASSWORD || 'guest',
+} as const;
+
+// Type definitions
+interface TaskData {
+    [key: string]: any;
+}
+
+interface TaskMessage {
+    task: string;
+    id: string;
+    args: TaskData[];
+}
+
+interface PublishPayload {
+    properties: {
+        // eslint-disable-next-line camelcase
+        delivery_mode: number;
+        // eslint-disable-next-line camelcase
+        content_type: string;
+    };
+    // eslint-disable-next-line camelcase
+    routing_key: string;
+    payload: string;
+    // eslint-disable-next-line camelcase
+    payload_encoding: string;
+}
+
+interface PublishResponse {
+    routed: boolean;
+}
+
+interface SendTaskOptions {
+    taskName: string;
+    queueName: string;
+}
+
+async function sendCeleryTaskViaHttp(
+    data: TaskData,
+    { taskName, queueName }: SendTaskOptions,
+): Promise<void> {
+    const apiUrl = `http://${config.host}:15672/api/exchanges/%2f/amq.default/publish`;
+
+    const message: TaskMessage = {
+        task: taskName,
+        id: randomUUID(),
+        args: [data],
+    };
+
+    const payload: PublishPayload = {
+        properties: {
+            delivery_mode: 2,
+            content_type: 'application/json',
+        },
+        routing_key: queueName,
+        payload: JSON.stringify(message),
+        payload_encoding: 'string',
+    };
+
+    try {
+        const response = await fetch(apiUrl, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Basic ${Buffer.from(`${config.username}:${config.password}`).toString('base64')}`,
+            },
+            body: JSON.stringify(payload),
+        });
+
+        if (response.ok) {
+            const result: PublishResponse = await response.json();
+            logger.info('Successfully published message:', result);
+        } else {
+            logger.error(`Failed to publish message. Status code: ${response.status}`);
+            logger.error(`Response: ${await response.text()}`);
+        }
+    } catch (error) {
+        logger.error('Error sending request:', error instanceof Error ? error.message : String(error));
+        throw error;
+    }
+}
+
+export { sendCeleryTaskViaHttp, TaskData, SendTaskOptions };

package/src/lib/consts.ts

@@ -3,6 +3,7 @@ export const DEFAULT_LOCK_TIMEOUT = 1000 * 5;
 export const RETRY_HEADER = 'x-retry-count';
 export const TRACING_HEADER = 'x-trace-id';
 export const USER_TRACING_HEADER = 'x-af-user-id';
+export const AUTOMATION_ID_HEADER = 'x-af-automation-id';
 export const USER_OBJECT = 'userObject';
 export const DEFAULT_USE_CONSUME_WITH_LOCK = false;
 export const CONNECTION_CREATED_CONST = 'connectionCreated';

package/src/lib/types.ts

@@ -1,4 +1,3 @@
-import { AmqpConnectionManager } from 'amqp-connection-manager';
 import { ConsumeMessage, Options, Replies } from 'amqplib';
 
 export interface ExchangesCache {
@@ -13,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;
 }
@@ -56,13 +59,3 @@ export const CONSUMER_DEFAULT_OPTIONS: Options.Consume = {
     [HA_PROMOTE_ON_SHUTDOWN]: 'always',
   },
 };
-
-export type ConnectionData = {
-  connection: AmqpConnectionManager | null;
-  creatingConnection: boolean;
-};
-
-export enum ConnectionPurpose {
-  Consume = 'consume',
-  Publish = 'publish',
-}