@autofleet/rabbit 3.2.21-beta.0.6 → 3.2.21-beta.1

package/dist/index.d.ts

@@ -1,10 +1,9 @@
 /// <reference types="node" />
 import { EventEmitter } from 'events';
-import { AmqpConnectionManager, ChannelWrapper, CreateChannelOpts } from 'amqp-connection-manager';
+import { AmqpConnectionManager, ChannelWrapper } 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, AssertExchangePromisesDictionary } from './lib/types';
-import { sendCeleryTaskViaHttp } from './lib/celery';
+import { CallbackFunction, ConsumeMessageOrNull, ConsumeOptions, CustomMessageHeaders, QueuesCache, RedisLockType, ExchangesCache, QueueSetupPromisesDictionary, assertChannelOpts, newChannelOpts, PublishOptions } from './lib/types';
 export interface IAfRabbitMq {
     ack: any;
     nack: any;
@@ -34,15 +33,6 @@ export interface AfRabbitOptions {
     dontRetryAssert?: boolean;
     rabbitHost?: string;
 }
-type newChannelOpts = {
-    name?: string;
-    onClose?: null | ((args: any | null) => void);
-    options?: CreateChannelOpts | undefined;
-};
-type assertChannelOpts = {
-    channelName?: string;
-    force?: boolean;
-};
 declare class RabbitMq implements IAfRabbitMq {
     static parseMsg(msg: any): any;
     static validateName(type: string, name: string): void;
@@ -67,7 +57,6 @@ declare class RabbitMq implements IAfRabbitMq {
     exchanges: ExchangesCache;
     queues: QueuesCache;
     queueSetupPromises: QueueSetupPromisesDictionary;
-    assertExchangePromises: AssertExchangePromisesDictionary;
     options: AfRabbitOptions | undefined;
     redisClient: any;
     redisLock?: RedisLockType;
@@ -80,8 +69,8 @@ declare class RabbitMq implements IAfRabbitMq {
     nack: (channel: ConfirmChannel, queue: string, options: any, deadQueueOptions: Options.AssertQueue, msg: ConsumeMessageOrNull, releaseLock: any) => (userMsg: ConsumeMessageOrNull, { skipRetry, }?: NackOptions) => Promise<any>;
     getConnection(): Promise<AmqpConnectionManager>;
     getNewChannel({ name, onClose, options }?: newChannelOpts): Promise<ChannelWrapper>;
-    assertChannel({ force }?: assertChannelOpts): Promise<ChannelWrapper>;
-    assertExchange(exchangeName: string, options?: any): Promise<any>;
+    assertChannel({ force, newChannelOptions }?: assertChannelOpts): Promise<ChannelWrapper>;
+    assertExchange(exchangeName: string): Promise<any>;
     getQueueLength(queue: string): Promise<Replies.AssertQueue>;
     private deleteQueue;
     bindQueue(queue: string, exchange: string): Promise<void>;
@@ -93,10 +82,9 @@ declare class RabbitMq implements IAfRabbitMq {
     private unlockRedisIfNeeded;
     private consumeFromRabbit;
     consumeFromExchange(queue: string, exchange: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<any>;
-    publish(exchange: string, content: any, customHeaders?: any): Promise<boolean>;
+    publish(exchange: string, content: any, customHeaders?: any, options?: PublishOptions): Promise<boolean>;
     sendToQueue(queue: string, content: any, options?: any, customHeaders?: any): Promise<boolean | undefined>;
     isConnected(): Promise<boolean>;
     gracefulShutdown(signal: string): Promise<void>;
 }
 export default RabbitMq;
-export { sendCeleryTaskViaHttp, };

package/dist/index.js

@@ -4,9 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sendCeleryTaskViaHttp = void 0;
 const events_1 = require("events");
 const util_1 = require("util");
+const lodash_1 = 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");
@@ -18,8 +18,6 @@ const redis_1 = __importDefault(require("./lib/redis"));
 const utils_1 = require("./lib/utils");
 const consts_1 = require("./lib/consts");
 const types_1 = require("./lib/types");
-const celery_1 = require("./lib/celery");
-Object.defineProperty(exports, "sendCeleryTaskViaHttp", { enumerable: true, get: function () { return celery_1.sendCeleryTaskViaHttp; } });
 // const debug = nodeDebug('af-rabbitmq')
 const debug = logger_1.default.debug.bind(logger_1.default);
 const PUBLISH_TIMEOUT = 1000 * 10;
@@ -126,7 +124,6 @@ class RabbitMq {
         this.exchanges = {};
         this.queues = {};
         this.queueSetupPromises = {};
-        this.assertExchangePromises = {};
         this.consumers = [];
         this.options = options;
         this.redisClient = redisConfig && (0, redis_1.default)(redisConfig);
@@ -246,14 +243,14 @@ class RabbitMq {
             throw err;
         }
     }
-    async assertChannel({ force = false } = {}) {
+    async assertChannel({ force = false, newChannelOptions = {} } = {}) {
         if (!this.publishChannelSetupPromise) {
             this.publishChannelSetupPromise = new Promise(async (resolve, reject) => {
                 if (this.channel && !force) {
                     return resolve(this.channel);
                 }
                 try {
-                    const channel = await this.getNewChannel({});
+                    const channel = await this.getNewChannel({ options: newChannelOptions });
                     channel.on('error', (err) => {
                         logger_1.default.error('rabbit: channel error', { err });
                     });
@@ -267,18 +264,14 @@ class RabbitMq {
         }
         return this.publishChannelSetupPromise;
     }
-    async assertExchange(exchangeName, options) {
+    async assertExchange(exchangeName) {
         const channel = await this.assertChannel();
         if (this.exchanges[exchangeName]) {
-            delete this.assertExchangePromises[exchangeName];
             return this.exchanges[exchangeName];
         }
-        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];
+        const exchange = await (0, utils_1.assertExchangeFanout)(channel, exchangeName);
+        this.exchanges[exchangeName] = exchange;
+        return exchange;
     }
     async getQueueLength(queue) {
         RabbitMq.validateName('queue', queue);
@@ -385,6 +378,7 @@ 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 ? (0, lodash_1.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;
@@ -445,7 +439,7 @@ class RabbitMq {
                 catch (e) {
                     await localNack(msg);
                 }
-            }, types_1.CONSUMER_DEFAULT_OPTIONS);
+            }, channelConsumerOptions);
             if (!consumerTag) {
                 logger_1.default.error(`rabbit: failed to consume from queue ${queue}`);
             }
@@ -473,17 +467,17 @@ class RabbitMq {
             ]);
         });
     }
-    async publish(exchange, content, customHeaders) {
+    async publish(exchange, content, customHeaders, options) {
         return (0, utils_1.wrapSetImmediate)(async () => {
             RabbitMq.validateName('exchange', exchange);
-            const channel = await this.assertChannel();
+            const channel = await this.assertChannel({ newChannelOptions: options?.newChannelOptions });
             await this.assertExchange(exchange);
             await channel.publish(exchange, '', Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions(customHeaders));
         });
     }
     async sendToQueue(queue, content, options, customHeaders) {
         try {
-            await this.assertChannel();
+            await this.assertChannel({ newChannelOptions: options?.newChannelOptions });
         }
         catch (e) {
             logger_1.default.error(`rabbit sendToQueue: failed to send assert channel when sending to queue ${queue}`, { e });

package/dist/lib/types.d.ts

@@ -1,3 +1,4 @@
+import { CreateChannelOpts } from 'amqp-connection-manager';
 import { ConsumeMessage, Options, Replies } from 'amqplib';
 export interface ExchangesCache {
     [key: string]: any;
@@ -8,9 +9,6 @@ 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;
 };
@@ -25,16 +23,22 @@ 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 = {
     name?: string;
     onClose?: null | ((args: any | null) => void);
+    options?: CreateChannelOpts | undefined;
 };
 export type assertChannelOpts = {
     channelName?: string;
     force?: boolean;
+    newChannelOptions?: newChannelOpts;
 };
+export interface PublishOptions {
+    newChannelOptions?: newChannelOpts;
+}
 export type AfConsumer = {
     queue: string;
     callback: CallbackFunction;

package/dist/lib/utils.d.ts

@@ -1,5 +1,5 @@
 import { ChannelWrapper } from 'amqp-connection-manager';
-import { ConfirmChannel, Replies } from 'amqplib';
-export declare const assertExchangeFanout: (c: ChannelWrapper | ConfirmChannel, exchangeName: string) => Promise<Replies.AssertExchange>;
+import { ConfirmChannel } from 'amqplib';
+export declare const assertExchangeFanout: (c: ChannelWrapper | ConfirmChannel, exchangeName: string) => Promise<import("amqplib").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.6",
+  "version": "3.2.21-beta.1",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
@@ -19,6 +19,7 @@
     "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"
@@ -30,6 +31,7 @@
     "@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,10 +2,11 @@
 
 import { EventEmitter, once } from 'events';
 import { promisify } from 'util';
+import { merge } from 'lodash';
 import moment from 'moment';
 import RedisLock from 'redis-lock';
 import {
-  AmqpConnectionManager, ChannelWrapper, connect, CreateChannelOpts,
+  AmqpConnectionManager, ChannelWrapper, connect,
 } from 'amqp-connection-manager';
 import {
   ConfirmChannel, ConsumeMessage, Options, Replies,
@@ -35,14 +36,12 @@ import {
   CustomMessageHeaders,
   QueuesCache,
   RedisLockType,
-  ExchangesCache,
-  CONSUMER_DEFAULT_OPTIONS,
-  QueueSetupPromisesDictionary,
-  AssertExchangePromisesDictionary,
+  ExchangesCache, CONSUMER_DEFAULT_OPTIONS, QueueSetupPromisesDictionary,
+  assertChannelOpts,
+  newChannelOpts,
+  PublishOptions,
 } from './lib/types';
 
-import { sendCeleryTaskViaHttp } from './lib/celery';
-
 // const debug = nodeDebug('af-rabbitmq')
 const debug = logger.debug.bind(logger);
 
@@ -83,17 +82,6 @@ export interface AfRabbitOptions {
   rabbitHost?: string;
 }
 
-type newChannelOpts = {
-  name?: string;
-  onClose?: null | ((args: any | null) => void);
-  options?: CreateChannelOpts | undefined;
-};
-
-type assertChannelOpts = {
-  channelName?: string;
-  force?: boolean;
-}
-
 type AfConsumer = {
   queue: string;
   callback: CallbackFunction;
@@ -162,8 +150,6 @@ class RabbitMq implements IAfRabbitMq {
 
   queueSetupPromises: QueueSetupPromisesDictionary;
 
-  assertExchangePromises: AssertExchangePromisesDictionary;
-
   options: AfRabbitOptions | undefined;
 
   redisClient: any;
@@ -184,7 +170,6 @@ class RabbitMq implements IAfRabbitMq {
     this.exchanges = {};
     this.queues = {};
     this.queueSetupPromises = {};
-    this.assertExchangePromises = {};
     this.consumers = [];
     this.options = options;
     this.redisClient = redisConfig && getRedisInstance(redisConfig);
@@ -387,7 +372,7 @@ class RabbitMq implements IAfRabbitMq {
     }
   }
 
-  async assertChannel({ force = false } : assertChannelOpts = {}): Promise<ChannelWrapper> {
+  async assertChannel({ force = false, newChannelOptions = {} }: assertChannelOpts = {}): Promise<ChannelWrapper> {
     if (!this.publishChannelSetupPromise) {
       this.publishChannelSetupPromise = new Promise<ChannelWrapper>(async (resolve, reject) => {
         if (this.channel && !force) {
@@ -395,7 +380,7 @@ class RabbitMq implements IAfRabbitMq {
         }
 
         try {
-          const channel = await this.getNewChannel({});
+          const channel = await this.getNewChannel({ options: newChannelOptions });
           channel.on('error', (err) => {
             logger.error('rabbit: channel error', { err });
           });
@@ -409,21 +394,14 @@ class RabbitMq implements IAfRabbitMq {
     return this.publishChannelSetupPromise;
   }
 
-  async assertExchange(exchangeName: string, options?: any) {
+  async assertExchange(exchangeName: string) {
     const channel: ChannelWrapper = await this.assertChannel();
-
     if (this.exchanges[exchangeName]) {
-      delete this.assertExchangePromises[exchangeName];
       return this.exchanges[exchangeName];
     }
-
-    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];
+    const exchange = await assertExchangeFanout(channel, exchangeName);
+    this.exchanges[exchangeName] = exchange;
+    return exchange;
   }
 
   async getQueueLength(queue: string) {
@@ -548,6 +526,7 @@ 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) => {
@@ -619,7 +598,8 @@ class RabbitMq implements IAfRabbitMq {
           } catch (e) {
             await localNack(msg);
           }
-        }, CONSUMER_DEFAULT_OPTIONS,
+        },
+        channelConsumerOptions,
       );
       if (!consumerTag) {
         logger.error(`rabbit: failed to consume from queue ${queue}`);
@@ -654,10 +634,10 @@ class RabbitMq implements IAfRabbitMq {
     });
   }
 
-  async publish(exchange: string, content: any, customHeaders?: any) : Promise<boolean> {
+  async publish(exchange: string, content: any, customHeaders?: any, options?: PublishOptions): Promise<boolean> {
     return wrapSetImmediate(async () => {
       RabbitMq.validateName('exchange', exchange);
-      const channel: ChannelWrapper = await this.assertChannel();
+      const channel: ChannelWrapper = await this.assertChannel({ newChannelOptions: options?.newChannelOptions });
       await this.assertExchange(exchange);
       await channel.publish(exchange, '',
         Buffer.from(JSON.stringify(content)),
@@ -672,7 +652,7 @@ class RabbitMq implements IAfRabbitMq {
     customHeaders?: any,
   ): Promise<boolean | undefined> {
     try {
-      await this.assertChannel();
+      await this.assertChannel({ newChannelOptions: options?.newChannelOptions });
     } catch (e) {
       logger.error(`rabbit sendToQueue: failed to send assert channel when sending to queue ${queue}`, { e });
       throw e;
@@ -737,7 +717,3 @@ class RabbitMq implements IAfRabbitMq {
 }
 
 export default RabbitMq;
-
-export {
-  sendCeleryTaskViaHttp,
-};

package/src/lib/types.ts

@@ -1,3 +1,4 @@
+import { CreateChannelOpts } from 'amqp-connection-manager';
 import { ConsumeMessage, Options, Replies } from 'amqplib';
 
 export interface ExchangesCache {
@@ -12,10 +13,6 @@ export interface QueueSetupPromisesDictionary {
   [key: string]: Promise<Replies.AssertQueue> | undefined
 }
 
-export interface AssertExchangePromisesDictionary {
-  [key: string]: Promise<Replies.AssertExchange> | undefined
-}
-
 export type CustomMessageHeaders = {
   redisTimestampValidationKey?: string;
 }
@@ -31,6 +28,7 @@ export interface ConsumeOptions {
   useConsumeWithLock?: boolean;
   auditContext?: any;
   enableRabbitTrace?: boolean;
+  channelConsumeOptions?: Options.Consume;
 }
 
 export type CallbackFunction = (msg: ConsumeMessage, ack: any, nack: any) => Promise<any>
@@ -38,11 +36,18 @@ export type CallbackFunction = (msg: ConsumeMessage, ack: any, nack: any) => Pro
 export type newChannelOpts = {
   name?: string;
   onClose?: null | ((args: any | null) => void);
+  options?: CreateChannelOpts | undefined;
 };
 export type assertChannelOpts = {
   channelName?: string;
   force?: boolean;
+  newChannelOptions?: newChannelOpts;
 }
+
+export interface PublishOptions {
+  newChannelOptions?: newChannelOpts;
+}
+
 export type AfConsumer = {
   queue: string;
   callback: CallbackFunction;

package/src/lib/utils.ts

@@ -1,11 +1,7 @@
 import { ChannelWrapper } from 'amqp-connection-manager';
-import { ConfirmChannel, Replies } from 'amqplib';
-
-export const assertExchangeFanout = async (
-  c: ChannelWrapper | ConfirmChannel,
-  exchangeName: string,
-): Promise<Replies.AssertExchange> => c.assertExchange(exchangeName, 'fanout');
+import { ConfirmChannel } from 'amqplib';
 
+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 {

package/dist/lib/celery.d.ts

@@ -1,9 +0,0 @@
-interface TaskData {
-    [key: string]: any;
-}
-interface SendTaskOptions {
-    taskName: string;
-    queueName: string;
-}
-declare function sendCeleryTaskViaHttp(data: TaskData, { taskName, queueName }: SendTaskOptions): Promise<void>;
-export { sendCeleryTaskViaHttp, TaskData, SendTaskOptions };

package/dist/lib/celery.js

@@ -1,54 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sendCeleryTaskViaHttp = void 0;
-const node_crypto_1 = require("node:crypto");
-const logger_1 = __importDefault(require("../logger"));
-// Environment configuration
-const config = {
-    host: process.env.RABBITMQ_SERVICE_HOST || '10.132.15.204',
-    username: process.env.RABBITMQ_USERNAME || 'default_user_Zjlb8cnBF-jwc61bbC8',
-    password: process.env.RABBITMQ_PASSWORD || 'SDjnZWKAgz9TROLDV85OUZb6FOLlfw1b',
-};
-async function sendCeleryTaskViaHttp(data, { taskName, queueName }) {
-    const apiUrl = `http://${config.host}:15672/api/exchanges/%2f/amq.default/publish`;
-    const message = {
-        task: taskName,
-        id: (0, node_crypto_1.randomUUID)(),
-        args: [data],
-    };
-    const payload = {
-        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 = await response.json();
-            logger_1.default.info('Successfully published message:', result);
-        }
-        else {
-            logger_1.default.error(`Failed to publish message. Status code: ${response.status}`);
-            logger_1.default.error(`Response: ${await response.text()}`);
-        }
-    }
-    catch (error) {
-        logger_1.default.error('Error sending request:', error instanceof Error ? error.message : String(error));
-        throw error;
-    }
-}
-exports.sendCeleryTaskViaHttp = sendCeleryTaskViaHttp;

package/src/lib/celery.ts

@@ -1,85 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import logger from '../logger';
-// Environment configuration
-const config = {
-  host: process.env.RABBITMQ_SERVICE_HOST || '10.132.15.204',
-  username: process.env.RABBITMQ_USERNAME || 'default_user_Zjlb8cnBF-jwc61bbC8',
-  password: process.env.RABBITMQ_PASSWORD || 'SDjnZWKAgz9TROLDV85OUZb6FOLlfw1b',
-};
-
-// Type definitions
-interface TaskData {
-    [key: string]: any;
-}
-
-interface TaskMessage {
-    task: string;
-    id: string;
-    args: TaskData[];
-}
-
-interface PublishPayload {
-    properties: {
-        delivery_mode: number;
-        content_type: string;
-    };
-    routing_key: string;
-    payload: string;
-    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 };