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

package/dist/index.d.ts

@@ -4,6 +4,7 @@ import { AmqpConnectionManager, ChannelWrapper, CreateChannelOpts } from 'amqp-c
 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';
 export interface IAfRabbitMq {
     ack: any;
     nack: any;
@@ -94,8 +95,8 @@ 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>;
 }
 export default RabbitMq;
+export { sendCeleryTaskViaHttp, };

package/dist/index.js

@@ -4,6 +4,7 @@ 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 moment_1 = __importDefault(require("moment"));
@@ -17,6 +18,8 @@ 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;
@@ -505,47 +508,6 @@ 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/celery.d.ts

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

package/dist/lib/celery.js

@@ -0,0 +1,54 @@
+"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 || 'localhost',
+    username: process.env.RABBITMQ_USERNAME || 'guest',
+    password: process.env.RABBITMQ_PASSWORD || 'guest',
+};
+async function sendCeleryTaskViaHttp(data) {
+    const apiUrl = `http://${config.host}:15672/api/exchanges/%2f/amq.default/publish`;
+    const message = {
+        task: 'planning_tasks.process_planning_task',
+        id: (0, node_crypto_1.randomUUID)(),
+        args: [data],
+    };
+    const payload = {
+        properties: {
+            delivery_mode: 2,
+            content_type: 'application/json',
+        },
+        routing_key: 'planning-task',
+        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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/rabbit",
-  "version": "3.2.21-beta.0.1",
+  "version": "3.2.21-beta.0.3",
   "description": "",
   "main": "dist/index.js",
   "scripts": {

package/src/index.ts

@@ -41,6 +41,8 @@ import {
   AssertExchangePromisesDictionary,
 } from './lib/types';
 
+import { sendCeleryTaskViaHttp } from './lib/celery';
+
 // const debug = nodeDebug('af-rabbitmq')
 const debug = logger.debug.bind(logger);
 
@@ -697,60 +699,6 @@ 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();
@@ -789,3 +737,7 @@ class RabbitMq implements IAfRabbitMq {
 }
 
 export default RabbitMq;
+
+export {
+  sendCeleryTaskViaHttp,
+};

package/src/lib/celery.ts

@@ -0,0 +1,78 @@
+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',
+};
+
+// 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;
+}
+
+async function sendCeleryTaskViaHttp(data: TaskData): Promise<void> {
+  const apiUrl = `http://${config.host}:15672/api/exchanges/%2f/amq.default/publish`;
+
+  const message: TaskMessage = {
+    task: 'planning_tasks.process_planning_task',
+    id: randomUUID(),
+    args: [data],
+  };
+
+  const payload: PublishPayload = {
+    properties: {
+      delivery_mode: 2,
+      content_type: 'application/json',
+    },
+    routing_key: 'planning-task',
+    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 };