refactor(bot): The bot/index file and handleMessage method bug were fixed.

In this commit, all the codes related to handling user messages were transferred to the decorator, and various error handlings were made in different codes, such as createDecorator, and no code was placed in the handleMessage method, and all data processing is in the decorators. (I hope it works :))

Author: m-mdy-m

src/app.ts

@@ -18,12 +18,12 @@ async function main() {
 
   // Graceful shutdown
   process.on('SIGTERM', async () => {
-    logger.info('SIGTERM signal received. Shutting down...');
+    logger.warn('SIGTERM signal received. Shutting down...');
     await shutdown(botInstance);
   });
 
   process.on('SIGINT', async () => {
-    logger.info('SIGINT signal received. Shutting down...');
+    logger.warn('SIGINT signal received. Shutting down...');
     await shutdown(botInstance);
   });
 

src/bot/index.ts

@@ -2,14 +2,11 @@ import { Bot, webhookCallback } from 'grammy';
 import type { Context } from 'grammy';
 import Config from '../config';
 import { GenerateCommand } from './handlers/GenerateCommands';
-import { GeneralCommands } from './commands/genearl/GeneralCommands';
-import { UserCommands } from './commands/user/UserCommands';
-import { AdminCommands } from './commands/admin/AdminCommands';
 import { SaveUserData } from '../decorators/Database';
 import { MessageValidator } from '../decorators/Context';
+import * as express from 'express';
 import { BotReply } from '../utils/chat/BotReply';
 import logger from '../utils/logger';
-import * as express from 'express';
 export class CopBot {
   private static instance: CopBot;
   private _bot: Bot<Context>;
@@ -53,25 +50,13 @@ export class CopBot {
         app.use(express.json());
         app.post(webhookPath, async (req, res) => {
           res.sendStatus(200);
-          const MAX_RETRIES = 3;
-          let retryCount = 0;
-
-          const processWebhook = async () => {
+          setImmediate(async () => {
             try {
-              // Process the webhook
               await webhookCallback(this._bot, 'express')(req, res);
-            } catch (err) {
-              if (retryCount < MAX_RETRIES) {
-                retryCount++;
-                const delay = Math.min(1000 * 2 ** retryCount, 30000);
-                await new Promise((resolve) => setTimeout(resolve, delay));
-                await processWebhook();
-              } else {
-                console.error('Max retries reached. Webhook processing failed.');
-              }
+            } catch (error: any) {
+              logger.error(`Error processing update:${error}`);
             }
-          };
-          await processWebhook();
+          });
         });
 
         const port = process.env.PORT || 3000;
@@ -85,7 +70,7 @@ export class CopBot {
           const trySetWebhook = async () => {
             try {
               if (!webhookInfo.url) {
-                logger.info('Webhook is not set. Trying to set the webhook...');
+                logger.warn('Webhook is not set. Trying to set the webhook...');
                 await this._bot.api.setWebhook(webhookURL);
                 webhookInfo = await this._bot.api.getWebhookInfo();
                 logger.info(`Webhook set: ${webhookInfo.url}`);
@@ -97,7 +82,7 @@ export class CopBot {
               logger.error(`Error setting webhook (Attempt ${retries}): ${error.message}`);
               if (retries < MAX_RETRIES) {
                 const delay = Math.min(1000 * 2 ** retries, 30000); // Exponential backoff
-                logger.info(`Retrying in ${delay / 1000} seconds...`);
+                logger.warn(`Retrying in ${delay / 1000} seconds...`);
                 await new Promise((resolve) => setTimeout(resolve, delay));
                 await trySetWebhook();
               } else {
@@ -130,48 +115,11 @@ export class CopBot {
     this._bot.catch((err) => {
       console.error('Middleware error:', err);
     });
-
     await this.start();
     logger.info('Bot is running');
   }
-  @SaveUserData()
   @MessageValidator()
-  async handleMessage(ctx: Context) {
-    try {
-      if (!ctx.message?.text) {
-        logger.warn('Message text is undefined');
-        return;
-      }
-      const messageText = ctx.message?.text?.toLowerCase().trim();
-      const reply = new BotReply(ctx);
-      const user = ctx.message?.reply_to_message?.from;
-
-      if (messageText === 'ask' && user) {
-        const name = user.username ? `@${user.username}` : user.first_name;
-        const responseMessage = `Dear ${name}, ask your question correctly.\nIf you want to know how to do this, read the article below:\ndontasktoask.ir`;
-        await reply.textReply(responseMessage);
-      }
-
-      if (ctx.message?.entities) {
-        const commandEntity = ctx.message.entities.find((entity) => entity.type === 'bot_command');
-        if (commandEntity) {
-          let command = messageText?.split(' ')[0]?.replace('/', '')!;
-          logger.debug(`Processing command: ${command} `);
-          command = command.includes('@') ? command.split('@')[0] : command;
-          const handler = (GeneralCommands as any)[command] || (UserCommands as any)[command] || (AdminCommands as any)[command];
-          if (typeof handler === 'function') {
-            await handler(ctx);
-            return;
-          }
-        }
-      }
-    } catch (err: any) {
-      logger.error('Error in handleMessage:', err.message);
-      const reply = new BotReply(ctx);
-      await reply.textReply('An unexpected error occurred.');
-    }
-  }
-
+  async handleMessage(ctx: Context) {}
   @SaveUserData()
   async handleJoinNewChat(ctx: Context) {
     if (!ctx.message?.text) {

src/decorators/Bot.ts

@@ -22,6 +22,7 @@ export function ReplyToBot() {
       const randomMessage = jokeMessage();
       await reply.textReply(randomMessage);
       close();
+      return;
     }
     return next();
   });

src/decorators/Catch.ts

@@ -1,23 +1,31 @@
-import { GrammyError } from 'grammy';
 import { ErrorResponse } from '../types/ResponseTypes';
 import logger from '../utils/logger';
 import { createDecorator } from './index';
+import { isGrammyError } from '../errors/decoratorErrorHandler';
 export function Catch(customResponse?: ErrorResponse) {
   return createDecorator(async (ctx, next) => {
     try {
       await next();
     } catch (error: any) {
-      if (error instanceof GrammyError && error.error_code === 400 && error.description === 'Bad Request: message to be replied not found') {
-        console.warn(`Message not found to reply to. Skipping...`);
-        return;
+      if (isGrammyError(error)) {
+        if (error.error_code === 400 && error.description === 'Bad Request: message to be replied not found') {
+          console.warn(`Message not found to reply to. Skipping...`);
+          return;
+        }
+        if (error.error_code === 403 && error.description.includes('bot was kicked')) {
+          logger.warn(`Bot was kicked from a group (chat_id: ${error.payload?.chat_id || 'unknown'}). Skipping.`);
+          return;
+        }
       }
-      if (error.error_code === 403 && error.description.includes('bot was kicked')) {
-        logger.warn(`[Warning] Bot was kicked from a group (chat_id: ${error.payload.chat_id}). Skipping.`);
-        return;
+      if (!isGrammyError(error)) {
+        logger.error(`Unhandled error: ${error.message || 'No error message provided'}`);
+        if (error.stack) {
+          logger.debug(`Stack trace: ${error.stack}`);
+        }
       }
       // Custom response or default error message
       const errorResponse: ErrorResponse = customResponse || {
-        message: error.message,
+        message: error.message || 'An unknown error occurred.',
         statusCode: error.statusCode || 500,
         category: 'General',
       };

src/decorators/Context.ts

@@ -1,8 +1,8 @@
 import { BotReply } from '../utils/chat/BotReply';
 import { MessagesService } from '../service/messages';
-import { createDecorator } from '.';
 import { RateLimitConfig } from '../types/CommandTypes';
 import { RateLimiter } from '../utils/RateLimiter';
+import { createDecorator } from './index';
 /**
  * A decorator to restrict commands to group chats.
  * Provides user feedback for invalid chat types.
@@ -36,8 +36,15 @@ export function RestrictToGroupChats() {
 export function MessageValidator() {
   return createDecorator(async (ctx, next) => {
     const messageService = new MessagesService(ctx);
-    await Promise.all([messageService.isNewUser(), messageService.isCode(), messageService.checkAndHandleBlacklistedWords(), messageService.userIsLeftGroup()]);
-    next();
+    await Promise.all([
+      messageService.isNewUser(),
+      messageService.isCode(),
+      messageService.checkAndHandleBlacklistedWords(),
+      messageService.userIsLeftGroup(),
+      messageService.askCommand(),
+      messageService.executeCommand(),
+    ]);
+    await next();
   });
 }
 /**

src/decorators/index.ts

@@ -3,25 +3,26 @@ import { handleDecoratorError } from '../errors/decoratorErrorHandler';
 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;
         };
-        await middleware(
+        return await middleware(
           ctx,
           async () => {
             if (shouldContinue) {
-              return await originalMethod.apply(this, [...args]);
+              try {
+                return await originalMethod.apply(this, [...args]);
+              } catch (error: any) {
+                handleDecoratorError(error);
+              }
             }
           },
           close
         );
-
-        return;
       } catch (error: any) {
         handleDecoratorError(error);
       }

src/errors/decoratorErrorHandler.ts

@@ -1,6 +1,8 @@
 import { GrammyError } from 'grammy';
 import logger from '../utils/logger';
-
+export function isGrammyError(error: any): error is GrammyError {
+  return error && error.error_code !== undefined && error.description !== undefined;
+}
 export function handleDecoratorError(error: any) {
   if (error instanceof GrammyError) {
     handleGrammyError(error);

src/service/messages/index.ts

@@ -2,14 +2,25 @@ import { Context } from 'grammy';
 import { ServiceProvider } from '../database/ServiceProvider';
 import { BotReply } from '../../utils/chat/BotReply';
 import { ChatInfo } from '../../utils/chat/ChatInfo';
+import logger from '../../utils/logger';
+import { MessageEntity } from 'grammy/types';
 export class MessagesService {
   private _reply: BotReply;
   private _chatInfo: ChatInfo;
   constructor(private _ctx: Context) {
     this._reply = new BotReply(_ctx);
     this._chatInfo = new ChatInfo(_ctx);
   }
+  private isText(): boolean {
+    if (!this._ctx.message?.text) {
+      logger.warn('Message text is undefined');
+      return false;
+    }
+    return true;
+  }
+
   async isCode() {
+    if (!this.isText()) return;
     const entities = this._ctx.message!.entities;
     entities?.forEach((e) => {
       if (e.type === 'pre' && e.language) {
@@ -18,6 +29,7 @@ export class MessagesService {
     });
   }
   async isNewUser() {
+    if (!this.isText()) return;
     if (this._ctx.message?.new_chat_members?.length! > 0) {
       const users = this._ctx.message!.new_chat_members!;
       const chat = this._ctx.chat;
@@ -39,8 +51,8 @@ export class MessagesService {
       }
     }
   }
-  Spam() {}
   async userIsLeftGroup() {
+    if (!this.isText()) return;
     if (this._ctx.message?.left_chat_member) {
       const user = this._ctx.message.left_chat_member!;
 
@@ -53,6 +65,7 @@ export class MessagesService {
   }
 
   async checkAndHandleBlacklistedWords() {
+    if (!this.isText()) return;
     const groupId = this._ctx.chat?.id;
     if (!groupId) {
       return;
@@ -154,4 +167,69 @@ We appreciate your understanding and cooperation in keeping the community welcom
     }
     return warningMessage;
   }
+  async askCommand() {
+    if (!this.isText()) return;
+    const messageText = this._ctx.message?.text?.toLowerCase().trim();
+    if (messageText !== 'ask' || !this._ctx.message?.reply_to_message?.from) {
+      return;
+    }
+    const user = this._ctx.message?.reply_to_message?.from!;
+    const name = user.username ? `@${user.username}` : user.first_name;
+    const responseMessage = `Dear ${name}, ask your question correctly.\nIf you want to know how to do this, read the article below:\ndontasktoask.ir`;
+    logger.debug(`Sending ask command response to ${name}`);
+    await this._reply.textReply(responseMessage);
+  }
+  async executeCommand() {
+    if (!this.isText()) return;
+    const isCommand = this.checkIfCommand();
+    if (!isCommand) {
+      logger.debug('Non-command message received. Ignoring.');
+      return;
+    }
+    const messageText = this._ctx.message?.text?.toLowerCase().trim()!;
+    const command = this.parseCommand(messageText, this._ctx.message?.entities)!;
+    logger.debug(`Attempting to execute the command: ${command}`);
+    const [GeneralCommands, UserCommands, AdminCommands] = await Promise.all([
+      import('../../bot/commands/genearl/GeneralCommands').then((module) => module.GeneralCommands),
+      import('../../bot/commands/user/UserCommands').then((module) => module.UserCommands),
+      import('../../bot/commands/admin/AdminCommands').then((module) => module.AdminCommands),
+    ]);
+    const handler = (GeneralCommands as any)[command] || (UserCommands as any)[command] || (AdminCommands as any)[command];
+
+    if (typeof handler === 'function') {
+      try {
+        await handler(this._ctx);
+      } catch (err: any) {
+        logger.error(`Handler for command "${command}" threw an error: ${err.message}`);
+        await this._reply.textReply('An error occurred while processing your command.');
+      }
+    } else {
+      logger.warn(`No handler found for command: ${command}`);
+      await this._reply.textReply(`Unknown command: ${command}`);
+    }
+  }
+  private checkIfCommand(): boolean {
+    const isCommand = this._ctx.message?.entities?.some((entity) => entity.type === 'bot_command');
+    if (!isCommand) {
+      logger.debug('Message does not contain a command entity.');
+      return false;
+    }
+    return true;
+  }
+  private parseCommand(messageText: string, entities?: MessageEntity[]): string | null {
+    if (entities) {
+      const commandEntity = entities.find((entity) => entity.type === 'bot_command');
+
+      if (commandEntity) {
+        let command = messageText.split(' ')[0].replace('/', '');
+        command = command.includes('@') ? command.split('@')[0] : command;
+
+        logger.debug(`Parsed command: ${command}`);
+        return command;
+      }
+    }
+
+    logger.warn('No command entity found in the message.');
+    return null;
+  }
 }

src/utils/chat/BotInfo.ts

@@ -1,5 +1,4 @@
 import { Context } from 'grammy';
-
 export class BotInfo {
   constructor(private _ctx: Context) {
     this._ctx = _ctx;
@@ -17,3 +16,4 @@ export class BotInfo {
     return ['administrator', 'creator'].includes(chatMember.status);
   }
 }
+