refactor(database): database service and related classes to improve error handling and connection management

Author: m-mdy-m

src/bot/index.ts

@@ -137,7 +137,9 @@ export class CopBot {
   }
   @MessageValidator()
   @SaveUserData()
-  async handleMessage(ctx: Context) {}
+  async handleMessage(ctx: Context) {
+    return;
+  }
   @SaveUserData()
   async handleJoinNewChat(ctx: Context) {
     if (!ctx.message?.text) {

src/bot/service/admin/Approved.ts

@@ -1,4 +1,3 @@
-import { Context } from 'grammy';
 import { ServiceProvider } from '../../../service/database/ServiceProvider';
 import logger from '../../../utils/logger';
 export class ApprovedService {

src/database/models/Group.ts

@@ -3,7 +3,6 @@ import { Group } from '../../types/database/TablesTypes';
 import { Context } from 'grammy';
 import { MembersService } from '../service/Members';
 import { DatabaseService } from '../service/Database';
-import { Catch } from '../../decorators/Catch';
 export class GroupService {
   private _db: DatabaseService;
   constructor(private _client: PoolClient) {

src/database/service/Database.ts

@@ -1,14 +1,25 @@
 import { PoolClient, QueryResult, QueryResultRow } from 'pg';
 export class DatabaseService {
-  constructor(private _client: PoolClient) {}
+  private _client: PoolClient;
+
+  constructor(client: PoolClient) {
+    if (!client) {
+      throw new Error('Database client must be provided.');
+    }
+    this._client = client;
+  }
 
   /**
    * Runs a query with parameters and returns the result.
    */
   async query<T extends QueryResultRow>(sql: string, params: any[] = []): Promise<QueryResult<T>> {
-    return await this._client.query<T>(sql, params);
+    try {
+      return await this._client.query<T>(sql, params);
+    } catch (error: any) {
+      console.error(`Error executing query: ${sql}`, error);
+      throw new Error(`Database query failed: ${error.message}`);
+    }
   }
-
   /**
    * Inserts a new record and returns the inserted row.
    */

src/database/service/Tables.ts

@@ -6,36 +6,38 @@ import Config from '../../config/index';
 import logger from '../../utils/logger';
 export class TablesService {
   constructor(private _connectionPool: ConnectionPool) {}
-  @Catch({
-    category: 'Database',
-    message: 'Failed to set up initial tables.',
-    statusCode: 500,
-  })
   async initialTables() {
     const client = await this._connectionPool.getClient();
-    const productionPath = path.join(process.cwd(), 'src', 'database', 'sql', 'Tables.sql');
-    const sqlFilePath = Config.environment === 'production' ? productionPath : path.join(__dirname, '..', './sql/Tables.sql');
-    const sql = await fs.readFile(sqlFilePath, 'utf-8');
-    await client.query(sql);
-    logger.info('Initial tables have been set up successfully.');
+    try {
+      const productionPath = path.join(process.cwd(), 'src', 'database', 'sql', 'Tables.sql');
+      const sqlFilePath = Config.environment === 'production' ? productionPath : path.join(__dirname, '..', './sql/Tables.sql');
+      const sql = await fs.readFile(sqlFilePath, 'utf-8');
+      await client.query(sql);
+      logger.info('Initial tables have been set up successfully.');
+    } catch (error) {
+      throw error;
+    } finally {
+      client.release(); // Release connection
+    }
   }
-  @Catch({
-    category: 'Database',
-    message: 'Failed to seed tables.',
-    statusCode: 500,
-  })
   async seedTables() {
     const client = await this._connectionPool.getClient();
-    const result = await client.query(`SELECT COUNT(*) FROM "User";`);
-    const userCount = parseInt(result.rows[0].count, 10);
-    if (userCount > 0) {
-      logger.info('The tables have already been seeded. Skipping seeding process.');
-      return; // Skip seeding if there's already data in the User table
+    try {
+      const result = await client.query(`SELECT COUNT(*) FROM "User";`);
+      const userCount = parseInt(result.rows[0].count, 10);
+      if (userCount > 0) {
+        logger.info('The tables have already been seeded. Skipping seeding process.');
+        return; // Skip seeding if there's already data in the User table
+      }
+      const productionPath = path.join(process.cwd(), 'src', 'database', 'sql', 'seed', 'SeedDataTables.sql');
+      const sqlFilePath = Config.environment === 'production' ? productionPath : path.join(__dirname, '..', './sql/seed/SeedDataTables.sql');
+      const sql = await fs.readFile(sqlFilePath, 'utf-8');
+      await client.query(sql);
+      logger.info('All tables have been seeded successfully.');
+    } catch (error) {
+      throw error;
+    } finally {
+      client.release();
     }
-    const productionPath = path.join(process.cwd(), 'src', 'database', 'sql', 'seed', 'SeedDataTables.sql');
-    const sqlFilePath = Config.environment === 'production' ? productionPath : path.join(__dirname, '..', './sql/seed/SeedDataTables.sql');
-    const sql = await fs.readFile(sqlFilePath, 'utf-8');
-    await client.query(sql);
-    logger.info('All tables have been seeded successfully.');
   }
 }

src/decorators/index.ts

@@ -1,29 +1,34 @@
 import { Context } from 'grammy';
 import { handleDecoratorError } from '../errors/decoratorErrorHandler';
+import logger from '../utils/logger';
+
 export function createDecorator(middleware: (ctx: Context, next: () => Promise<void>, close: () => void) => Promise<void>) {
   return function (_target: any, _propertyKey: string | symbol, descriptor: PropertyDescriptor) {
     const originalMethod = descriptor.value;
+
     descriptor.value = async function (...args: any[]) {
       try {
         const ctx: Context = (this as any)?.ctx || args[0];
+
         let shouldContinue = true;
         const close = () => {
           shouldContinue = false;
+          logger.debug(`Execution stopped by close() in ${originalMethod.name}`);
         };
         return await middleware(
           ctx,
           async () => {
             if (shouldContinue) {
               try {
-                return await originalMethod.apply(this, [...args]);
-              } catch (error: any) {
+                return await originalMethod.apply(this, args);
+              } catch (error) {
                 handleDecoratorError(error);
               }
             }
           },
           close
         );
-      } catch (error: any) {
+      } catch (error) {
         handleDecoratorError(error);
       }
     };

src/service/database/ServiceProvider.ts

@@ -14,14 +14,13 @@ export class ServiceProvider {
   private constructor() {
     this._clientInstance = new Client();
   }
-
   static async initialize(): Promise<ServiceProvider | null> {
     if (!ServiceProvider.instance) {
       const instance = new ServiceProvider();
       const isInitialized = await instance._clientInstance.initialize();
       if (!isInitialized) {
         logger.error('Failed to initialize client instance. Returning null.');
-        return null; // Return null if initialization fails
+        return null;
       }
       instance._connectionPool = instance._clientInstance.getConnectionPool();
       ServiceProvider.instance = instance;
@@ -42,61 +41,41 @@ export class ServiceProvider {
     await this._connectionPool.close();
   }
   async getPoolClint(): Promise<PoolClient> {
-    return await this._connectionPool.getClient();
+    const client = await this._connectionPool.getClient();
+    client.on('error', (err: any) => {
+      logger.error('Unexpected client error:', err);
+      client.release();
+    });
+    return client;
   }
   async getGroupService() {
-    return await this.retryConnect(async () => {
-      const client = await this.getPoolClint();
-      return new GroupService(client);
-    });
+    const client = await this.getPoolClint();
+    return new GroupService(client);
   }
   async getUserService() {
-    return await this.retryConnect(async () => {
-      const client = await this.getPoolClint();
-      return new UserService(client);
-    });
+    const client = await this.getPoolClint();
+    return new UserService(client);
   }
   async getRulesService() {
-    return await this.retryConnect(async () => {
-      const client = await this.getPoolClint();
-      return new GroupRuleService(client);
-    });
+    const client = await this.getPoolClint();
+    return new GroupRuleService(client);
   }
   async getWarnsService() {
-    return await this.retryConnect(async () => {
-      const clint = await this.getPoolClint();
-      return new WarningDatabaseService(clint);
-    });
+    const clint = await this.getPoolClint();
+    return new WarningDatabaseService(clint);
   }
   async healthCheck(): Promise<boolean> {
+    const client = await this.getPoolClint();
     try {
-      const client = await this.getPoolClint();
       await client.query('SELECT NOW()');
       client.release();
       logger.info('Database is healthy.');
       return true;
     } catch (err: any) {
       logger.error('Database health check failed:', err.message);
       return false;
+    } finally {
+      client.release();
     }
   }
-  private async retryConnect<T>(fn: () => Promise<T>, retries = 3, delay = 5000): Promise<T | null> {
-    let lastError: any;
-
-    for (let attempt = 0; attempt < retries; attempt++) {
-      try {
-        return await fn();
-      } 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);
-          logger.warn(`Retrying in ${backoffTime}ms...`, 'Database');
-          await new Promise((res) => setTimeout(res, backoffTime));
-        }
-      }
-    }
-    logger.error(`All ${retries} retry attempts failed. Last error: ${lastError?.message || lastError}`, 'Database');
-    return null;
-  }
 }