feat(chat): Add utility classes for handling bot info, replies, and chat info

- Implement `BotInfo` class for checking if the bot is an admin in a chat.
- Add `BotReply` class for sending various types of replies (plain text, markdown, HTML, and inline keyboard).
- Introduce `ChatInfo` class to manage chat-related functionality such as determining chat type, checking if a user is in the group, and handling topic messages.
- Extend `BotReply` with methods to handle replies to messages and specific formatting options (text, markdown, HTML).
- Update `ChatInfo` with new methods to check if a message is related to a topic and fetch topic details.

Author: m-mdy-m

src/utils/chat/BotInfo.ts

@@ -0,0 +1,19 @@
+import { Context } from 'grammy';
+
+export class BotInfo {
+  constructor(private _ctx: Context) {
+    this._ctx = _ctx;
+  }
+  async isAdmin(): Promise<boolean> {
+    const botInfo = this._ctx.me;
+    if (!botInfo) {
+      return false;
+    }
+
+    const chatMember = await this._ctx.getChatMember(botInfo.id);
+    if (!chatMember) {
+      return false;
+    }
+    return ['administrator', 'creator'].includes(chatMember.status);
+  }
+}

src/utils/chat/BotReply.ts

@@ -0,0 +1,85 @@
+import { Context, InlineKeyboard } from 'grammy';
+import { RepliedMessage } from '../../types/CommandTypes';
+
+export class BotReply {
+  private ctx: Context;
+
+  constructor(ctx: Context) {
+    this.ctx = ctx;
+  }
+  /**
+   * Sends a generic reply without any special formatting.
+   * @param message - The message to send.
+   */
+  async send(message: string): Promise<void> {
+    await this.ctx.reply(message);
+  }
+  /**
+   * Sends a plain text reply.
+   * @param message - The plain text message to send.
+   * @param replyToMessage - Optionally, reply to a specific message.
+   */
+  async textReply(message: string): Promise<void> {
+    await this.ctx.reply(message, {
+      reply_parameters: {
+        message_id: this.ctx.message?.message_id!,
+      },
+    });
+  }
+  /**
+   * Sends a plain text reply to a specific message.
+   * @param message - The message to send.
+   */
+  async replyToMessage(message: string): Promise<void> {
+    await this.ctx.reply(message, {
+      parse_mode: 'HTML',
+      reply_parameters: {
+        message_id: this.ctx.message?.reply_to_message?.message_id!,
+      },
+    });
+  }
+  /**
+   * Sends a reply with Markdown formatting.
+   * @param message - Markdown message to send.
+   * @param replyToMessage - Whether to reply to the user's message.
+   */
+  async markdownReply(message: string): Promise<void> {
+    await this.ctx.reply(message, {
+      parse_mode: 'Markdown',
+      reply_parameters: {
+        message_id: this.ctx.message?.message_id!,
+      },
+    });
+  }
+
+  /**
+   * Sends a reply with HTML formatting.
+   * @param message - HTML formatted message to send.
+   * @param replyToMessage - Whether to reply to the user's message.
+   */
+  async htmlReply(message: string): Promise<void> {
+    await this.ctx.reply(message, {
+      parse_mode: 'HTML',
+      reply_parameters: {
+        message_id: this.ctx.message?.message_id!,
+      },
+    });
+  }
+
+  /**
+   * Sends a reply with inline keyboard options.
+   * @param message - Message to send.
+   * @param keyboard - Inline keyboard options.
+   */
+  async inlineKeyboardReply(message: string, keyboard: InlineKeyboard): Promise<void> {
+    await this.ctx.reply(message, { reply_markup: keyboard });
+  }
+
+  async getReplyMessage(): Promise<RepliedMessage | undefined> {
+    const repliedMessage = this.ctx.message?.reply_to_message;
+    if (repliedMessage && repliedMessage.from) {
+      return repliedMessage as RepliedMessage;
+    }
+    return undefined;
+  }
+}

src/utils/chat/ChatInfo.ts

@@ -0,0 +1,52 @@
+import { Context } from 'grammy';
+import { BotReply } from './BotReply';
+export class ChatInfo {
+  constructor(private _ctx: Context) {}
+
+  getChatType(): 'private' | 'group' | 'supergroup' | 'channel' | 'unknown' {
+    return this._ctx.chat?.type ?? 'unknown';
+  }
+  message() {
+    return this._ctx.message;
+  }
+  entities(): { offset: number; length: number; type: string } | null {
+    const entity = this._ctx.message?.entities?.[0];
+    if (entity) {
+      return {
+        offset: entity.offset,
+        length: entity.length,
+        type: entity.type,
+      };
+    }
+    return null;
+  }
+  async userInGroup(message: string = 'The user is no longer a member of this group.'): Promise<boolean | undefined> {
+    const reply = new BotReply(this._ctx);
+    const replied = await reply.getReplyMessage();
+    const userId = replied?.from?.id;
+    if (!userId) {
+      await this._ctx.reply('Unable to determine the user ID. Please ensure you are replying to a valid user.', {
+        reply_to_message_id: this._ctx.message?.message_id,
+      });
+      return;
+    }
+
+    const chatMember = await this._ctx.getChatMember(userId);
+
+    if (chatMember.status === 'left' || chatMember.status === 'kicked') {
+      await reply.textReply(message);
+      return true;
+    }
+    return false;
+  }
+  chatIsTopic(): boolean {
+    return Boolean(this._ctx.message?.is_topic_message);
+  }
+  topicName(): string | undefined {
+    const message = this._ctx.message;
+    if (this.chatIsTopic()) {
+      return message?.reply_to_message?.forum_topic_created?.name;
+    }
+    return undefined;
+  }
+}