@mulingai-npm/message-broker 1.0.1

package/dist/managers/tts-manager.d.ts

@@ -0,0 +1,8 @@
+import { RabbitMQClient } from '../rabbitmq-client';
+export declare class TtsManager {
+    private client;
+    constructor(client: RabbitMQClient);
+    initialize(): Promise<void>;
+    publishTtsCompleted(data: any): Promise<void>;
+    subscribeTtsCompleted(queueName: string, onMessage: (data: any) => Promise<void> | void): Promise<void>;
+}

package/dist/managers/tts-manager.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TtsManager = void 0;
+const TTS_EXCHANGE = 'tts-exchange';
+const TTS_EXCHANGE_TYPE = 'fanout'; // fanout means every queue bound to it gets every message.
+class TtsManager {
+    constructor(client) {
+        this.client = client;
+    }
+    async initialize() {
+        const channel = this.client.getChannelOrThrow();
+        await channel.assertExchange(TTS_EXCHANGE, TTS_EXCHANGE_TYPE, {
+            durable: false
+        });
+        console.log(`TTS exchange '${TTS_EXCHANGE}' asserted.`);
+    }
+    async publishTtsCompleted(data) {
+        const channel = this.client.getChannelOrThrow();
+        const payload = Buffer.from(JSON.stringify(data));
+        // With a fanout exchange, the routingKey is usually '' (ignored).
+        channel.publish(TTS_EXCHANGE, '', payload);
+        console.log('Published TTS completed event:', data);
+    }
+    async subscribeTtsCompleted(queueName, onMessage) {
+        const channel = this.client.getChannelOrThrow();
+        // 1) Assert a queue (unique name for each microservice).
+        await channel.assertQueue(queueName, { durable: true });
+        // 2) Bind the queue to the TTS exchange. (Fanout -> routingKey usually ignored.)
+        await channel.bindQueue(queueName, TTS_EXCHANGE, '');
+        // 3) Consume messages:
+        await channel.consume(queueName, async (msg) => {
+            if (!msg) {
+                return;
+            }
+            try {
+                const data = JSON.parse(msg.content.toString());
+                await onMessage(data);
+                channel.ack(msg);
+            }
+            catch (error) {
+                console.error(`Error in TTS subscription queue ${queueName}:`, error);
+                channel.nack(msg);
+            }
+        });
+        console.log(`Subscribed to TTS completed events on queue "${queueName}".`);
+    }
+}
+exports.TtsManager = TtsManager;

package/dist/rabbitmq-client.d.ts

@@ -0,0 +1,10 @@
+import { Channel } from 'amqplib';
+export declare class RabbitMQClient {
+    private url;
+    private connection;
+    private channel;
+    constructor(rabbitUrl: string);
+    connect(): Promise<void>;
+    close(): Promise<void>;
+    getChannelOrThrow(): Channel;
+}

package/dist/rabbitmq-client.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RabbitMQClient = void 0;
+const amqplib_1 = require("amqplib");
+class RabbitMQClient {
+    constructor(rabbitUrl) {
+        this.connection = null;
+        this.channel = null;
+        this.url = rabbitUrl;
+    }
+    async connect() {
+        if (this.connection) {
+            return;
+        }
+        this.connection = await (0, amqplib_1.connect)(this.url);
+        this.channel = await this.connection.createChannel();
+        console.log('RabbitMQ connected and channel created.');
+        // Cleanup on close
+        this.connection.on('close', () => {
+            console.warn('RabbitMQ connection closed.');
+            this.connection = null;
+            this.channel = null;
+        });
+        this.connection.on('error', (err) => {
+            console.error('RabbitMQ connection error:', err);
+        });
+    }
+    async close() {
+        if (this.channel) {
+            await this.channel.close();
+            this.channel = null;
+        }
+        if (this.connection) {
+            await this.connection.close();
+            this.connection = null;
+        }
+        console.log('RabbitMQ connection closed.');
+    }
+    getChannelOrThrow() {
+        if (!this.channel) {
+            throw new Error('RabbitMQ channel not initialized. Call connect() first.');
+        }
+        return this.channel;
+    }
+}
+exports.RabbitMQClient = RabbitMQClient;

package/dist/use-case-examples/tts-consumer-service.js

@@ -0,0 +1,14 @@
+// import { RabbitMQClient } from '@mulingai-npm/message-broker/dist/rabbitmq-client';
+// import { TtsManager } from '@mulingai-npm/message-broker/dist/tts-manager';
+// const rabbitUrl = process.env.RABBIT_MQ_URL || 'amqp://guest:guest@localhost:5672';
+// const rabbitClient = new RabbitMQClient(rabbitUrl);
+// (async () => {
+//     await rabbitClient.connect();
+//     const ttsManager = new TtsManager(rabbitClient);
+//     await ttsManager.initialize();
+//     // Each subscribing service uses a unique queue name so they each get the message.
+//     await ttsManager.subscribeTtsCompleted('my-queue-other-service', async (msgData) => {
+//         console.log('Other service got TTS completed event:', msgData);
+//         // do something with msgData (e.g., store in DB, call another service, etc.)
+//     });
+// })();

package/dist/use-case-examples/tts-microservice-publisher.js

@@ -0,0 +1,17 @@
+// import { RabbitMQClient } from '@mulingai-npm/message-broker/dist/rabbitmq-client';
+// import { TtsManager } from '@mulingai-npm/message-broker/dist/tts-manager';
+// // 1) Create the RabbitMQ client with your single URL
+// const rabbitUrl = process.env.RABBIT_MQ_URL || 'amqp://guest:guest@localhost:5672';
+// const rabbitClient = new RabbitMQClient(rabbitUrl);
+// (async () => {
+//     // 2) Connect
+//     await rabbitClient.connect();
+//     // 3) Initialize the TTS manager
+//     const ttsManager = new TtsManager(rabbitClient);
+//     await ttsManager.initialize();
+//     // 4) Suppose your TTS logic finishes some job, then:
+//     // e.g., after processing text into audio, you publish an event
+//     const resultData = { jobId: '123', audioUrl: 'https://my-bucket/xyz.wav' };
+//     await ttsManager.publishTtsCompleted(resultData);
+//     // 5) Keep your service running; handle more TTS requests...
+// })();

package/package.json

@@ -0,0 +1,32 @@
+{
+    "name": "@mulingai-npm/message-broker",
+    "version": "1.0.1",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/mulingai/mulingai-backend.git"
+    },
+    "publishConfig": {
+        "registry": "https://registry.npmjs.org/"
+    },
+    "private": false,
+    "scripts": {
+        "dev": "rm -f tsconfig.tsbuildinfo && tsc --watch",
+        "build": "rm -f tsconfig.tsbuildinfo && tsc",
+        "prepublishOnly": "npm run build"
+    },
+    "dependencies": {
+        "amqplib": "^0.10.5"
+    },
+    "devDependencies": {
+        "concurrently": "^9.1.2",
+        "nodemon": "^3.1.9",
+        "typescript": "^4.9.5"
+    },
+    "files": [
+        "dist",
+        "package.json",
+        "README.md"
+    ]
+}