refactor(database): database initialization and connection logic to handle errors and retries

Author: m-mdy-m

src/app.ts

@@ -6,7 +6,11 @@ async function main() {
   const botInstance = CopBot.getInstance();
 
   try {
-    await ServiceProvider.initialize();
+    const isInitialDatabase = await ServiceProvider.initialize();
+    if (!isInitialDatabase) {
+      logger.error('Failed to initialize the database after several attempts.');
+      process.exit(1);
+    }
     logger.info('Database initialized.');
 
     await botInstance.initial();
@@ -27,8 +31,9 @@ async function main() {
     await shutdown(botInstance);
   });
 
-  process.on('unhandledRejection', (reason) => {
+  process.on('unhandledRejection', async (reason) => {
     logger.error(`${reason}:`, 'Unhandled Rejection');
+    await shutdown(botInstance);
   });
 
   process.on('uncaughtException', async (err: any) => {

src/database/Client.ts

@@ -6,16 +6,27 @@ export class Client {
   constructor() {
     this._connectionPool = new ConnectionPool();
   }
-  async initialize() {
-    await this._connectionPool.connect();
-    const tablesService = new TablesService(this._connectionPool);
-    logger.info('Setting up initial tables...');
-    await tablesService.initialTables();
-    logger.info('Initial Tables Setup Completed.');
+  async initialize(): Promise<boolean> {
+    try {
+      const isConnected = await this._connectionPool.connect();
+      if (!isConnected) {
+        logger.error('Database connection failed.');
+        return false;
+      }
+      const tablesService = new TablesService(this._connectionPool);
+      logger.info('Setting up initial tables...');
+      await tablesService.initialTables();
+      logger.info('Initial Tables Setup Completed.');
 
-    logger.info('Seeding tables...');
-    await tablesService.seedTables();
-    logger.info('Tables seeded successfully.');
+      logger.info('Seeding tables...');
+      await tablesService.seedTables();
+      logger.info('Tables seeded successfully.');
+      return true;
+    } catch (error: any) {
+      // Log any error that occurs during the initialization process
+      logger.error(`Error during database initialization: ${error.message}`);
+      return false;
+    }
   }
   getConnectionPool(): ConnectionPool {
     return this._connectionPool;

src/database/ConnectionPool.ts

@@ -1,5 +1,6 @@
 import { Pool, PoolClient } from 'pg';
 import Config from '../config';
+import logger from '../utils/logger';
 export class ConnectionPool {
   private _pool: Pool;
   private _isProduction: 'development' | 'production';
@@ -8,19 +9,30 @@ export class ConnectionPool {
     this._isProduction = Config.environment;
     this._pool = this.initializePool(connectionString);
   }
-  async connect(): Promise<void> {
+  async connect(): Promise<boolean> {
     try {
       const client = await this._pool.connect();
-      client.release(); // Connection successful
+      client.release();
+      logger.info('Database connection successful');
+      return true;
     } catch (error: any) {
       console.error('Database connection error:', error.message);
       if (error.code === '3D000') {
         console.log(`Database does not exist. Creating database ${Config.database.databaseName}...`);
         await this.createDatabase();
         await this.reinitializePool();
-        await this._pool.connect();
+        try {
+          const client = await this._pool.connect();
+          client.release();
+          logger.info('Database connection successful after reinitialization');
+          return true;
+        } catch (reconnectError: any) {
+          console.error('Reconnection failed:', reconnectError.message);
+          return false;
+        }
       } else {
         console.error('Unexpected error connecting to the database:', error);
+        return false;
       }
     }
   }
@@ -56,8 +68,8 @@ export class ConnectionPool {
       connectionString,
       ssl: this._isProduction === 'production' ? { rejectUnauthorized: false } : false,
       max: 20,
-      idleTimeoutMillis: 10000,
-      connectionTimeoutMillis: 5000,
+      idleTimeoutMillis: 30000, // Increase idle timeout
+      connectionTimeoutMillis: 10000, // Increase connection timeout
       keepAlive: true,
     });
   }

src/decorators/Database.ts

@@ -45,6 +45,7 @@ export function EnsureUserAndGroup(userSource: 'from' | 'reply' = 'reply') {
       await Promise.all([
         service.getUserService().then((userService) => {
           if (!userService) {
+            console.error('UserService is unavailable.');
             close();
             return;
           }

src/service/database/ServiceProvider.ts

@@ -15,10 +15,14 @@ export class ServiceProvider {
     this._clientInstance = new Client();
   }
 
-  static async initialize(): Promise<ServiceProvider> {
+  static async initialize(): Promise<ServiceProvider|null> {
     if (!ServiceProvider.instance) {
       const instance = new ServiceProvider();
-      await instance._clientInstance.initialize();
+      const isInitialized = await instance._clientInstance.initialize();
+      if (!isInitialized) {
+        logger.error('Failed to initialize client instance. Returning null.');
+        return null; // Return null if initialization fails
+      }
       instance._connectionPool = instance._clientInstance.getConnectionPool();
       ServiceProvider.instance = instance;
     }
@@ -81,15 +85,15 @@ export class ServiceProvider {
 
     for (let attempt = 0; attempt < retries; attempt++) {
       try {
-        logger.info(`Database connection attempt ${attempt + 1}...`, 'Database');
+        logger.warn(`Database connection attempt ${attempt + 1}...`, 'Database');
         return await fn(); // Try executing the provided function
       } catch (error: any) {
         lastError = error;
         logger.warn(`Retry Attempt ${attempt + 1} failed with error: ${error.message || error}.`, 'Database');
 
         if (attempt < retries - 1) {
           const backoffTime = delay * Math.pow(2, attempt); // Exponential backoff
-          logger.info(`Retrying in ${backoffTime}ms...`, 'Database');
+          logger.warn(`Retrying in ${backoffTime}ms...`, 'Database');
           await new Promise((res) => setTimeout(res, backoffTime));
         }
       }