feat: updated code with various changes to improve functionality and error handling

Author: m-mdy-m

src/bot/handlers/GenerateCommands.ts

@@ -3,30 +3,46 @@ import { CommandName, COMMANDS } from '../../utils';
 import { GeneralCommands } from '../../bot/commands/genearl/GeneralCommands';
 import { UserCommands } from '../commands/user/UserCommands';
 import { AdminCommands } from '../commands/admin/AdminCommands';
+import logger from '../../utils/logger';
 export class GenerateCommand {
   private bot: Bot;
   constructor(bot: Bot) {
     this.bot = bot;
   }
 
   private registerCommand(name: CommandName) {
-    // Safely access the command handler on GeneralCommands
-    const generalCommandHandler = (GeneralCommands as any)[name];
-    const userCommandHandler = (UserCommands as any)[name];
-    const adminCommandsHandler = (AdminCommands as any)[name];
-    if (generalCommandHandler) {
-      this.bot.command(name, generalCommandHandler.bind(GeneralCommands));
-    } else if (userCommandHandler) {
-      this.bot.command(name, userCommandHandler.bind(UserCommands));
-    } else if (adminCommandsHandler) {
-      this.bot.command(name, adminCommandsHandler.bind(AdminCommands));
+    try {
+      // Safely access the command handler from the appropriate module
+      const generalCommandHandler = (GeneralCommands as any)[name];
+      const userCommandHandler = (UserCommands as any)[name];
+      const adminCommandHandler = (AdminCommands as any)[name];
+
+      if (generalCommandHandler) {
+        this.bot.command(name, generalCommandHandler.bind(GeneralCommands));
+      } else if (userCommandHandler) {
+        this.bot.command(name, userCommandHandler.bind(UserCommands));
+      } else if (adminCommandHandler) {
+        this.bot.command(name, adminCommandHandler.bind(AdminCommands));
+      } else {
+        logger.warn(`Command not found in any module: ${name}`);
+      }
+    } catch (error: any) {
+      logger.error(`Error registering command "${name}": ${error.message}`);
     }
   }
 
   /**
    * Registers all commands defined in COMMANDS.
    */
   generate() {
-    COMMANDS.forEach((command) => this.registerCommand(command));
+    logger.info('Starting command generation.');
+    try {
+      COMMANDS.forEach((command) => {
+        this.registerCommand(command);
+      });
+      logger.info('All commands have been registered successfully.');
+    } catch (error: any) {
+      logger.error(`Error during command generation: ${error.message}`);
+    }
   }
 }

src/bot/index.ts

@@ -8,6 +8,7 @@ import * as express from 'express';
 import { BotReply } from '../utils/chat/BotReply';
 import logger from '../utils/logger';
 import { limit } from '@grammyjs/ratelimiter';
+import { ServiceProvider } from '../service/database/ServiceProvider';
 export class CopBot {
   private static instance: CopBot;
   private _bot: Bot<Context>;
@@ -52,16 +53,18 @@ export class CopBot {
         const app = express();
         app.use(express.json());
         app.post(webhookPath, async (req, res) => {
-          setImmediate(async () => {
-            try {
-              await webhookCallback(this._bot, 'express')(req, res);
-            } catch (error: any) {
-              logger.error(`Error processing update:${error}`);
-              return;
-            }
-          });
+          res.sendStatus(200);
+          try {
+            await webhookCallback(this._bot, 'express')(req, res);
+          } catch (error: any) {
+            logger.error(`Error processing update : ${error.message}`);
+            return;
+          }
+        });
+        app.get('/health', async (_, res) => {
+          const isHealthy = await ServiceProvider.getInstance().healthCheck();
+          res.status(isHealthy ? 200 : 500).send(isHealthy ? 'OK' : 'Database not reachable');
         });
-
         const port = process.env.PORT || 3000;
         app.listen(port, async () => {
           logger.info(`Webhook server running on port ${port}`);
@@ -74,7 +77,7 @@ export class CopBot {
             try {
               if (!webhookInfo.url) {
                 logger.warn('Webhook is not set. Trying to set the webhook...');
-                await this._bot.api.setWebhook(webhookURL, { max_connections: 100 });
+                await this._bot.api.setWebhook(webhookURL, { drop_pending_updates: true });
                 webhookInfo = await this._bot.api.getWebhookInfo();
                 logger.info(`Webhook set: ${webhookInfo.url}`);
               } else {
@@ -96,6 +99,7 @@ export class CopBot {
           };
 
           await trySetWebhook();
+          await startBot(mode);
         });
       } catch (err: any) {
         console.error('Error setting up webhook:', err);
@@ -112,6 +116,11 @@ export class CopBot {
   }
   async initial(): Promise<void> {
     new GenerateCommand(this._bot).generate();
+    this._bot.use(
+      limit({
+        onLimitExceeded: (ctx) => ctx.reply('Too many requests! Please slow down.'),
+      })
+    );
     this._bot.on('my_chat_member', (ctx) => this.handleJoinNewChat(ctx));
     this._bot.on('message', (ctx) => this.handleMessage(ctx));
     this._bot.catch(async (error: BotError<Context>) => {
@@ -120,11 +129,6 @@ export class CopBot {
       }
       logger.error(`Bot error occurred: ${error.error}`);
     });
-    this._bot.use(
-      limit({
-        onLimitExceeded: (ctx) => ctx.reply('Too many requests! Please slow down.'),
-      })
-    );
     await this.start();
     logger.info('Bot is running');
   }

src/database/ConnectionPool.ts

@@ -7,10 +7,7 @@ export class ConnectionPool {
   constructor() {
     const connectionString = this.getConnectionString();
     this._isProduction = Config.environment;
-    this._pool = new Pool({
-      connectionString,
-      ssl: this._isProduction === 'production' ? { rejectUnauthorized: false } : false,
-    });
+    this._pool = this.initializePool(connectionString);
   }
   @Catch({
     message: 'Failed to connect to the database. Please check your credentials or network connection.',
@@ -20,20 +17,19 @@ export class ConnectionPool {
   async connect(): Promise<void> {
     try {
       const client = await this._pool.connect();
-      client.release(); // Verify and release immediately
+      client.release(); // Connection successful
     } 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._pool.end(); // End the current pool connection
         const newConnectionString = this.getConnectionString();
-        this._pool = new Pool({
-          connectionString: newConnectionString,
-          ssl: this._isProduction === 'production' ? { rejectUnauthorized: false } : false,
-        });
+        this._pool = this.initializePool(newConnectionString);
         console.log('Retrying connection after creating the database...');
         await this._pool.connect();
+      } else {
+        console.error('Unexpected error connecting to the database:', error);
       }
     }
   }
@@ -54,6 +50,9 @@ export class ConnectionPool {
     try {
       await client.query(`CREATE DATABASE "${databaseName}"`);
       console.log(`Database "${databaseName}" created successfully.`);
+    } catch (error: any) {
+      console.error('Failed to create database:', error.message);
+      throw error; // Re-throw the error for better logging and troubleshooting
     } finally {
       await client.end();
     }
@@ -69,4 +68,10 @@ export class ConnectionPool {
   async close(): Promise<void> {
     await this._pool.end();
   }
+  private initializePool(connectionString: string): Pool {
+    return new Pool({
+      connectionString,
+      ssl: this._isProduction === 'production' ? { rejectUnauthorized: false } : false,
+    });
+  }
 }

src/service/database/ServiceProvider.ts

@@ -47,12 +47,23 @@ export class ServiceProvider {
     const client = await this.getPoolClint();
     return new UserService(client);
   }
-  async getRulesService(){
-    const client = await this.getPoolClint()
-    return new GroupRuleService(client)
+  async getRulesService() {
+    const client = await this.getPoolClint();
+    return new GroupRuleService(client);
+  }
+  async getWarnsService() {
+    const clint = await this.getPoolClint();
+    return new WarningDatabaseService(clint);
   }
-  async getWarnsService(){
-    const clint = await this.getPoolClint()
-    return new WarningDatabaseService(clint)
+  async healthCheck(): Promise<boolean> {
+    try {
+      const client = await this.getPoolClint();
+      client.release();
+      console.log('Database is healthy.');
+      return true;
+    } catch (err: any) {
+      console.error('Database health check failed:', err.message);
+      return false;
+    }
   }
 }