@discover-cloud/shared 1.4.0 → 1.5.0

package/dist/authorization/permission-cache.service.js

@@ -34,7 +34,7 @@ class PermissionCacheService {
      */
     constructor() {
         this.client = (0, redis_1.createClient)({
-            url: (0, env_util_1.getEnvOptional)('REDIS_URL') ?? 'redis://localhost:6379',
+            url: (0, env_util_1.getEnv)('REDIS_URL'),
         });
         this.client.on('error', (err) => {
             console.error('[PermissionCache] Redis error', err);

package/dist/messaging/rabbitmq.client.d.ts

@@ -2,14 +2,24 @@ import { ILogger } from '../utils/logger.util';
 export declare class RabbitMQClient {
     private connection;
     private channel;
-    private url;
-    private exchangeName;
-    private logger;
+    private readonly url;
+    private readonly exchangeName;
+    private readonly logger;
+    private reconnecting;
     constructor(url: string, logger?: ILogger);
+    /**
+     * Establishes a connection to RabbitMQ.
+     * Blocks until a connection is successfully established.
+     */
     connect(): Promise<void>;
+    /**
+     * Background reconnect loop.
+     */
+    private reconnect;
     publishEvent(routingKey: string, payload: unknown): Promise<void>;
     subscribe(queueName: string, routingKey: string, handler: (payload: unknown) => Promise<void>, options?: {
         prefetch?: number;
     }): Promise<void>;
     close(): Promise<void>;
+    private delay;
 }

package/dist/messaging/rabbitmq.client.js

@@ -41,35 +41,60 @@ class RabbitMQClient {
         this.connection = null;
         this.channel = null;
         this.exchangeName = 'discovercloud.topic';
+        this.reconnecting = false;
         this.url = url;
         this.logger = logger;
     }
+    /**
+     * Establishes a connection to RabbitMQ.
+     * Blocks until a connection is successfully established.
+     */
     async connect() {
         if (this.connection && this.channel) {
             return;
         }
-        try {
-            this.connection = await amqplib.connect(this.url);
-            this.connection.on('error', (err) => {
-                this.logger.error(err, 'RabbitMQ Connection Error');
-            });
-            this.connection.on('close', () => {
-                this.logger.warn('RabbitMQ Connection Closed. Reconnecting...');
-                this.connection = null;
-                this.channel = null;
-                setTimeout(() => this.connect(), 5000);
-            });
-            this.channel = await this.connection.createChannel();
-            // Ensure the main topic exchange exists
-            await this.channel.assertExchange(this.exchangeName, 'topic', {
-                durable: true,
-            });
-            this.logger.info('✅ Connected to RabbitMQ');
+        while (!this.channel) {
+            try {
+                this.logger.info('Connecting to RabbitMQ...');
+                this.connection = await amqplib.connect(this.url);
+                this.connection.on('error', (err) => {
+                    this.logger.error(err, 'RabbitMQ Connection Error');
+                });
+                this.connection.on('close', () => {
+                    this.logger.warn('RabbitMQ Connection Closed');
+                    this.connection = null;
+                    this.channel = null;
+                    if (!this.reconnecting) {
+                        void this.reconnect();
+                    }
+                });
+                this.channel = await this.connection.createChannel();
+                await this.channel.assertExchange(this.exchangeName, 'topic', {
+                    durable: true,
+                });
+                this.logger.info('✅ RabbitMQ connected');
+                return;
+            }
+            catch (err) {
+                this.logger.error(err, 'RabbitMQ unavailable. Retrying in 5 seconds...');
+                await this.delay(5000);
+            }
         }
-        catch (error) {
-            this.logger.error(error, '❌ Failed to connect to RabbitMQ');
-            setTimeout(() => this.connect(), 5000);
+    }
+    /**
+     * Background reconnect loop.
+     */
+    async reconnect() {
+        this.reconnecting = true;
+        while (!this.channel) {
+            try {
+                await this.connect();
+            }
+            catch {
+                await this.delay(5000);
+            }
         }
+        this.reconnecting = false;
     }
     async publishEvent(routingKey, payload) {
         if (!this.channel) {
@@ -89,45 +114,61 @@ class RabbitMQClient {
         if (options.prefetch) {
             await this.channel.prefetch(options.prefetch);
         }
-        // Dead Letter configuration
         const dlxName = `${this.exchangeName}.dlx`;
         const dlqName = `${queueName}.dlq`;
-        await this.channel.assertExchange(dlxName, 'topic', { durable: true });
-        await this.channel.assertQueue(dlqName, { durable: true });
+        await this.channel.assertExchange(dlxName, 'topic', {
+            durable: true,
+        });
+        await this.channel.assertQueue(dlqName, {
+            durable: true,
+        });
         await this.channel.bindQueue(dlqName, dlxName, routingKey);
-        // Assert main queue with DLX bindings
         await this.channel.assertQueue(queueName, {
             durable: true,
             deadLetterExchange: dlxName,
             deadLetterRoutingKey: routingKey,
         });
         await this.channel.bindQueue(queueName, this.exchangeName, routingKey);
-        this.channel.consume(queueName, async (msg) => {
-            if (!msg)
+        await this.channel.consume(queueName, async (msg) => {
+            if (!msg) {
                 return;
+            }
             try {
                 const payload = JSON.parse(msg.content.toString());
                 await handler(payload);
-                // Fix: Use optional chaining instead of non-null assertion (!)
                 this.channel?.ack(msg);
             }
-            catch (error) {
-                this.logger.error(error, `Error processing message from ${queueName}`);
-                // Fix: Use optional chaining instead of non-null assertion (!)
-                // Nack the message and don't requeue, so it goes to the DLX
+            catch (err) {
+                this.logger.error(err, `Error processing ${queueName}`);
                 this.channel?.nack(msg, false, false);
             }
         });
-        this.logger.info(`📡 Subscribed to queue [${queueName}] with routing key [${routingKey}]`);
+        this.logger.info(`📡 Subscribed to ${queueName} (${routingKey})`);
     }
     async close() {
-        if (this.channel) {
-            await this.channel.close();
+        try {
+            this.reconnecting = true; // Prevents triggering reconnect during manual close
+            if (this.connection) {
+                this.connection.removeAllListeners('close');
+            }
+            if (this.channel) {
+                await this.channel.close();
+            }
+            if (this.connection) {
+                await this.connection.close();
+            }
         }
-        if (this.connection) {
-            await this.connection.close();
+        finally {
+            this.channel = null;
+            this.connection = null;
+            this.reconnecting = false;
         }
-        this.logger.info('RabbitMQ connection closed.');
+        this.logger.info('RabbitMQ disconnected');
+    }
+    delay(ms) {
+        return new Promise((resolve) => {
+            setTimeout(resolve, ms);
+        });
     }
 }
 exports.RabbitMQClient = RabbitMQClient;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@discover-cloud/shared",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "private": false,
   "type": "commonjs",
   "main": "dist/index.js",