refactor: Refactor ConnectionPool and ServiceProvider to handle errors and reinitialization

Author: m-mdy-m

src/database/ConnectionPool.ts

@@ -60,9 +60,14 @@ export class ConnectionPool {
   }
 
   async close(): Promise<void> {
-    if (this._isClosed) return; // Prevent closing the pool more than once
+    if (this._isClosed) return;
     this._isClosed = true;
-    await this._pool.end();
+    try {
+      await this._pool.end();
+      logger.info('Connection pool closed successfully.');
+    } catch (err: any) {
+      logger.error('Error while closing the connection pool:', err.message);
+    }
   }
   private initializePool(connectionString: string): Pool {
     return new Pool({
@@ -80,10 +85,20 @@ export class ConnectionPool {
     }
 
     if (this._pool && !this._pool.ended) {
+      logger.warn('Ending the current pool before reinitialization...');
       await this._pool.end();
     }
+
     const newConnectionString = this.getConnectionString();
     this._pool = this.initializePool(newConnectionString);
-    console.warn('Connection pool reinitialized.');
+
+    try {
+      const testClient = await this._pool.connect();
+      testClient.release(); // Ensure the new pool is functional
+      logger.info('Connection pool reinitialized successfully.');
+    } catch (err: any) {
+      logger.error('Failed to reinitialize connection pool:', err.message);
+      throw err; // Let the caller handle this failure
+    }
   }
 }

src/service/database/ServiceProvider.ts

@@ -41,17 +41,25 @@ export class ServiceProvider {
     await this._connectionPool.close();
   }
   async getPoolClint(): Promise<PoolClient> {
-    try {
-      const client = await this._connectionPool.getClient();
-      client.on('error', (err: any) => {
-        logger.error('Unexpected client error:', err);
-      });
-      return client;
-    } catch (err: any) {
-      logger.error('Error getting client from pool:', err);
-      await this._connectionPool.reinitializePool();
-      return this.getPoolClint();
+    let retries = 3;
+    while (retries > 0) {
+      try {
+        const client = await this._connectionPool.getClient();
+        client.on('error', (err: any) => {
+          logger.error('Unexpected client error:', err);
+        });
+        return client;
+      } catch (err: any) {
+        logger.error('Error getting client from pool:', err.message);
+        if (retries === 1) {
+          logger.error('Maximum retries reached. Reinitializing the pool.');
+          await this._connectionPool.reinitializePool();
+        }
+        retries -= 1;
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+      }
     }
+    throw new Error('Failed to get a database client after multiple retries.');
   }
   async getGroupService() {
     const client = await this.getPoolClint();