@seidor-cloud-produtos/orbit-backend-lib 2.0.125 → 2.0.128

package/dist/clean-arch/infra/queue/rabbitmq/amqp-lib.d.ts

@@ -31,7 +31,8 @@ export default class AmqpQueue implements QueueConnection {
     private static instance;
     private vHost;
     private connection;
-    private isReconnecting;
+    private isConnected;
+    private reconnectionPromise?;
     private messagesInMemory;
     private channels;
     protected socketOptions?: SocketOptions;
@@ -118,6 +119,8 @@ export default class AmqpQueue implements QueueConnection {
      * Quando a conexão fecha, a lib tenta reconectar em loop e, ao
      * reconectar, reativa consumidores e reenvia mensagens em memória.
      */
+    private getActiveConnection;
+    private scheduleReconnection;
     private treatReconnection;
     /**
      * Reinscreve todos os consumidores registrados anteriormente.

package/dist/clean-arch/infra/queue/rabbitmq/amqp-lib.js

@@ -20,7 +20,8 @@ class AmqpQueue {
     static instance;
     vHost;
     connection;
-    isReconnecting = false;
+    isConnected = false;
+    reconnectionPromise;
     messagesInMemory = [];
     channels = new Map();
     socketOptions;
@@ -58,11 +59,12 @@ class AmqpQueue {
             const urlConnection = `${this.uri}${buildedVhost}`;
             this.connection = await amqplib_1.default.connect(urlConnection, this.socketOptions);
             this.vHost = vHost;
-            this.connection.on('error', async (e) => {
-                return await this.treatReconnection(vHost);
+            this.isConnected = true;
+            this.connection.on('error', async () => {
+                return await this.scheduleReconnection(vHost);
             });
             this.connection.on('close', async () => {
-                return await this.treatReconnection(vHost);
+                return await this.scheduleReconnection(vHost);
             });
             if (process.env.NODE_ENV !== 'test') {
                 this.logger.info(`⚙️ PROCESS ${this.vHost} PID: `, process.pid);
@@ -75,6 +77,9 @@ class AmqpQueue {
                 retryCount >= this.socketOptions?.retry?.maxCount) {
                 throw e;
             }
+            if (retryCount === 0) {
+                await this.close().catch(() => null);
+            }
             this.logger.info(`Retrying connection in... ${this.socketOptions.retry.intervalMs || 0}ms`);
             await (0, timeout_1.sleep)(this.socketOptions.retry.intervalMs);
             return await this.connect(vHost, retryCount + 1);
@@ -84,6 +89,7 @@ class AmqpQueue {
      * Fecha a conexão atual com o broker.
      */
     async close() {
+        this.isConnected = false;
         this.connection.removeAllListeners('close');
         await this.connection.close();
         if (process.env.NODE_ENV !== 'test') {
@@ -92,7 +98,8 @@ class AmqpQueue {
     }
     async get(queueName, options) {
         try {
-            const channel = await this.connection.createChannel();
+            const connection = await this.getActiveConnection();
+            const channel = await connection.createChannel();
             const rawMessage = await channel.get(queueName, options);
             if (!rawMessage) {
                 await channel.close();
@@ -142,7 +149,8 @@ class AmqpQueue {
      */
     async on(queueName, callback) {
         try {
-            const channel = await this.connection.createChannel();
+            const connection = await this.getActiveConnection();
+            const channel = await connection.createChannel();
             this.channels.set(queueName, callback);
             await channel.prefetch(callback.getSimultaneity());
             await channel.consume(queueName, async (message) => {
@@ -251,7 +259,8 @@ class AmqpQueue {
         }
     }
     async publishToServerWaitForConfirms(exchangeName, domainEvent, buildedConfigs) {
-        const channel = await this.connection.createConfirmChannel();
+        const connection = await this.getActiveConnection();
+        const channel = await connection.createConfirmChannel();
         channel.publish(exchangeName, domainEvent.name || '', Buffer.from(JSON.stringify(domainEvent)), {
             persistent: true,
             ...buildedConfigs,
@@ -260,7 +269,8 @@ class AmqpQueue {
         await channel.close();
     }
     async publishToServer(exchangeName, domainEvent, buildedConfigs) {
-        const channel = await this.connection.createChannel();
+        const connection = await this.getActiveConnection();
+        const channel = await connection.createChannel();
         channel.publish(exchangeName, domainEvent.name || '', Buffer.from(JSON.stringify(domainEvent)), {
             persistent: true,
             ...buildedConfigs,
@@ -278,7 +288,8 @@ class AmqpQueue {
      */
     async createConsumers(queueName, configs) {
         try {
-            const channel = await this.connection.createChannel();
+            const connection = await this.getActiveConnection();
+            const channel = await connection.createChannel();
             await channel.assertExchange(configs.exchangeName, configs.exchangeType, {
                 durable: true,
             });
@@ -347,14 +358,29 @@ class AmqpQueue {
      * Quando a conexão fecha, a lib tenta reconectar em loop e, ao
      * reconectar, reativa consumidores e reenvia mensagens em memória.
      */
-    async treatReconnection(vHost) {
-        if (this.isReconnecting) {
-            return;
+    async getActiveConnection() {
+        if (!this.isConnected && this.reconnectionPromise) {
+            await this.reconnectionPromise;
+        }
+        if (!this.connection) {
+            throw new infra_error_1.default('RabbitMQ connection is not available!');
+        }
+        return this.connection;
+    }
+    async scheduleReconnection(vHost) {
+        this.isConnected = false;
+        if (!this.reconnectionPromise) {
+            this.reconnectionPromise = this.treatReconnection(vHost).finally(() => {
+                this.reconnectionPromise = undefined;
+            });
         }
-        this.isReconnecting = true;
+        return await this.reconnectionPromise;
+    }
+    async treatReconnection(vHost) {
+        this.isConnected = false;
         this.logger.info('⛔ Connection Error!!');
         this.logger.info(`🔄 Try connection to the vHost ${vHost}`);
-        await this.connect(vHost);
+        AmqpQueue.instance = await this.connect(vHost);
         await this.reconnectionChannels();
         await this.publishMessagesOfMemory();
     }

package/dist/clean-arch/infra/queue/rabbitmq/amqp-lib.spec.js

@@ -333,6 +333,36 @@ const createLogger = () => ({
                 },
             ]);
         });
+        (0, vitest_1.it)('should wait for an in-flight reconnection before publishing', async () => {
+            let finishReconnection;
+            const oldConnection = createConnection();
+            const channel = createChannel();
+            const newConnection = createConnection(channel);
+            const queue = new amqp_lib_1.default(undefined, 'amqp://broker', createLogger());
+            const event = { name: 'domain.event' };
+            queue['connection'] = oldConnection;
+            queue['vHost'] = 'jobs';
+            queue['isConnected'] = false;
+            queue['reconnectionPromise'] = new Promise(resolve => {
+                finishReconnection = () => {
+                    queue['connection'] = newConnection;
+                    queue['isConnected'] = true;
+                    resolve();
+                };
+            });
+            const publishPromise = queue.publish('exchange', event);
+            await Promise.resolve();
+            (0, vitest_1.expect)(oldConnection.createChannel).not.toHaveBeenCalled();
+            (0, vitest_1.expect)(newConnection.createChannel).not.toHaveBeenCalled();
+            finishReconnection();
+            await publishPromise;
+            (0, vitest_1.expect)(oldConnection.createChannel).not.toHaveBeenCalled();
+            (0, vitest_1.expect)(newConnection.createChannel).toHaveBeenCalledTimes(1);
+            (0, vitest_1.expect)(channel.publish).toHaveBeenCalledWith('exchange', 'domain.event', Buffer.from(JSON.stringify(event)), {
+                persistent: true,
+                expiration: FOURTEEN_DAYS_IN_MS,
+            });
+        });
         (0, vitest_1.it)('should not store messages when storeMessageOnError is false', async () => {
             const queue = new amqp_lib_1.default(undefined, 'amqp://broker', createLogger());
             queue['publishToServer'] = vitest_1.vi.fn().mockRejectedValue(new Error('fail'));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seidor-cloud-produtos/orbit-backend-lib",
-  "version": "2.0.125",
+  "version": "2.0.128",
   "description": "Internal lib for backend components",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",