@tmlmobilidade/rabbitmq 20251202.1817.5

package/dist/index.d.ts

@@ -0,0 +1,37 @@
+import { Options, Replies } from 'amqplib';
+export interface RabbitMQConfig {
+    socketOptions?: any;
+    uri: Options.Connect | string;
+}
+export declare class RabbitMQConnector {
+    private channel?;
+    private config;
+    private connection?;
+    constructor(config: RabbitMQConfig);
+    /**
+     * Connects to RabbitMQ and creates a channel.
+     */
+    connect(): Promise<void>;
+    /**
+   * Disconnects from RabbitMQ.
+   */
+    disconnect(): Promise<void>;
+    /**
+     * Publishes a message to a queue.
+     */
+    publish(queue: string, message: Buffer | string, options?: Options.Publish): Promise<Replies.Empty>;
+    /**
+     * Subscribes to a queue and processes messages.
+     */
+    subscribe(queue: string, callback: (message: Buffer | string) => void): Promise<void>;
+}
+/**
+ * Singleton class for RabbitMQConnector.
+ */
+declare class RabbitMQService extends RabbitMQConnector {
+    private static _instance;
+    private constructor();
+    static getInstance(): Promise<RabbitMQService>;
+}
+export declare const rabbitMQ: RabbitMQService;
+export {};

package/dist/index.js

@@ -0,0 +1,97 @@
+/* * */
+import { AsyncSingletonProxy } from '@tmlmobilidade/utils';
+import { connect as amqpConnect } from 'amqplib';
+export class RabbitMQConnector {
+    channel;
+    config;
+    connection;
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Connects to RabbitMQ and creates a channel.
+     */
+    async connect() {
+        try {
+            this.connection = await amqpConnect(this.config.uri, this.config.socketOptions);
+            this.channel = await this.connection.createChannel();
+            console.log('Connected to RabbitMQ.');
+            this.channel.on('close', () => {
+                console.warn('Channel closed, reconnecting...');
+                setTimeout(this.connect.bind(this), 5000);
+            });
+            this.channel.on('error', (err) => {
+                console.error('Channel error:', err);
+            });
+        }
+        catch (error) {
+            console.error('Failed to connect to RabbitMQ:', error);
+            throw error;
+        }
+    }
+    /**
+   * Disconnects from RabbitMQ.
+   */
+    async disconnect() {
+        if (this.channel) {
+            await this.channel.close();
+            this.channel = undefined;
+        }
+        if (this.connection) {
+            await this.connection.close();
+            this.connection = undefined;
+        }
+        console.log('Disconnected from RabbitMQ.');
+    }
+    /**
+     * Publishes a message to a queue.
+     */
+    async publish(queue, message, options) {
+        if (!this.channel) {
+            throw new Error('Channel is not initialized. Call connect() first.');
+        }
+        await this.channel.assertQueue(queue, { durable: true });
+        const sent = this.channel.sendToQueue(queue, Buffer.isBuffer(message) ? message : Buffer.from(message), options);
+        if (!sent) {
+            throw new Error('Failed to send message to queue.');
+        }
+        return {};
+    }
+    /**
+     * Subscribes to a queue and processes messages.
+     */
+    async subscribe(queue, callback) {
+        if (!this.channel) {
+            throw new Error('Channel is not initialized. Call connect() first.');
+        }
+        await this.channel.assertQueue(queue, { durable: true });
+        await this.channel.consume(queue, (message) => {
+            if (message) {
+                callback(message.content);
+                this.channel?.ack(message);
+            }
+        });
+    }
+}
+/* * */
+/**
+ * Singleton class for RabbitMQConnector.
+ */
+class RabbitMQService extends RabbitMQConnector {
+    static _instance;
+    constructor() {
+        if (!process.env.RABBITMQ_URI) {
+            throw new Error('Missing "RABBITMQ_URI" environment variable');
+        }
+        super({ uri: process.env.RABBITMQ_URI });
+    }
+    static async getInstance() {
+        if (!RabbitMQService._instance) {
+            const instance = new RabbitMQService();
+            await instance.connect();
+            RabbitMQService._instance = instance;
+        }
+        return RabbitMQService._instance;
+    }
+}
+export const rabbitMQ = AsyncSingletonProxy(RabbitMQService);

package/package.json

@@ -0,0 +1,50 @@
+{
+	"name": "@tmlmobilidade/rabbitmq",
+	"version": "20251202.1817.5",
+	"author": {
+		"email": "iso@tmlmobilidade.pt",
+		"name": "TML-ISO"
+	},
+	"license": "AGPL-3.0-or-later",
+	"homepage": "https://github.com/tmlmobilidade/go#readme",
+	"bugs": {
+		"url": "https://github.com/tmlmobilidade/go/issues"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/tmlmobilidade/go.git"
+	},
+	"keywords": [
+		"public transit",
+		"tml",
+		"transportes metropolitanos de lisboa",
+		"go"
+	],
+	"publishConfig": {
+		"access": "public"
+	},
+	"type": "module",
+	"files": [
+		"dist"
+	],
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"scripts": {
+		"build": "tsc && resolve-tspaths",
+		"lint": "eslint ./src/ && tsc --noEmit",
+		"lint:fix": "eslint ./src/ --fix",
+		"watch": "tsc-watch --onSuccess 'resolve-tspaths'"
+	},
+	"dependencies": {
+		"@tmlmobilidade/utils": "*",
+		"amqplib": "0.10.9"
+	},
+	"devDependencies": {
+		"@tmlmobilidade/tsconfig": "*",
+		"@types/amqplib": "0.10.8",
+		"@types/node": "24.10.1",
+		"resolve-tspaths": "0.8.23",
+		"tsc-watch": "7.2.0",
+		"typescript": "5.9.3"
+	}
+}