@2byte/tgbot-framework 1.0.9 → 1.0.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@2byte/tgbot-framework",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "description": "A TypeScript framework for creating Telegram bots with sections-based architecture (Bun optimized)",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/core/App.ts

@@ -46,7 +46,7 @@ export class App {
 
   public bot!: Telegraf<Telegraf2byteContext>;
   private sectionClasses: Map<string, typeof Section> = new Map();
-  private runnedSections: WeakMap<UserModel, RunnedSection | Map<string, RunnedSection>> =
+  private runnedSections: WeakMap<UserModel, RunnedSection[]> =
     new WeakMap();
   private middlewares: CallableFunction[] = [];
   private apiServiceManager!: ApiServiceManager;
@@ -205,9 +205,9 @@ export class App {
       middleware();
     });
 
+    this.registerCommands();
     this.registerActionForCallbackQuery();
     this.registerHears();
-    this.registerCommands();
     this.registerMessageHandlers();
     await this.registerServices();
 
@@ -377,7 +377,7 @@ export class App {
         const sectionRoute = new RunSectionRoute()
           .section(sectionId)
           .method(method)
-          .actionPath(actionPath);
+          .callbackParams(actionPath, actionParams.toString());
 
         this.runSection(ctx, sectionRoute).catch((err) => {
           this.debugLog("Error running section:", err);
@@ -575,6 +575,7 @@ export class App {
 
           // Если указан runSection, выполняем его
           if (runSection) {
+            runSection.runAsCommand();
             await this.runSection(ctx, runSection);
           }
         } else {
@@ -702,7 +703,7 @@ export class App {
       this.debugLog(`Register command ${command} for section ${sectionId}`);
       if (command) {
         this.bot.command(command, async (ctx: Telegraf2byteContext) => {
-          const sectionRoute = new RunSectionRoute().section(sectionId).method("index");
+          const sectionRoute = new RunSectionRoute().section(sectionId).method("index").runAsCommand();
           await this.runSection(ctx, sectionRoute);
         });
       }
@@ -791,56 +792,74 @@ export class App {
     }
     this.debugLog("Using section class:", sectionClass);
 
-    const sectionInstance: Section = new sectionClass({
-      ctx,
-      bot: this.bot,
-      app: this,
-      route: sectionRoute,
-    } as SectionOptions);
+    let sectionInstance: Section | undefined;
+
+    const createSectionInstance = (sectionClass: typeof Section) => {
+      return new sectionClass({
+        ctx,
+        bot: this.bot,
+        app: this,
+        route: sectionRoute,
+      } as SectionOptions);
+    };
+
+    const createRunnedSection = (instance: Section, route: RunSectionRoute): RunnedSection => {
+      return {
+        instance,
+        route,
+      };
+    };
+
+    const findRunnedSection = () => {
+      const userRunnedSections = this.runnedSections.get(ctx.user);
+      if (userRunnedSections && Array.isArray(userRunnedSections)) {
+        return userRunnedSections.find((section) => section.route.getSection() === sectionId);
+      }
+      return undefined;
+    };
 
-    let runnedSection;
-    let userRunnedSections: Map<string, RunnedSection> | RunnedSection | undefined;
-    let sectionInstalled = false;
+    let isRestoredSection = false;
+    let runnedSection : RunnedSection | undefined = undefined;
+    let createdNewSectionInstance = false;
 
     if (this.config.keepSectionInstances) {
-      userRunnedSections = this.runnedSections.get(ctx.user);
-      if (userRunnedSections instanceof Map) {
-        runnedSection &&= userRunnedSections.get(sectionId);
+      runnedSection = findRunnedSection();
+      if (runnedSection) {
+        runnedSection.instance
+          .updateCtx(ctx)
+          .updateRoute(sectionRoute)
+          .setCallbackParams(sectionRoute.getCallbackParams());
+
+          runnedSection.route.runAsCallbackQuery(sectionRoute.runIsCallbackQuery);
+
+        isRestoredSection = true;
+      } else {
+        createdNewSectionInstance = true;
       }
     } else {
-      runnedSection &&= this.runnedSections.get(ctx.user);
+      createdNewSectionInstance = true;
     }
-    if (runnedSection) {
-      this.debugLog(`Restored a runned section for user ${ctx.user.username}:`, runnedSection);
+
+    if (isRestoredSection) {
+      this.debugLog(`Restored a runned section for user ${ctx.user.username}:`, runnedSection?.instance.sectionId);
     }
 
-    if (!runnedSection && this.config.keepSectionInstances) {
-      if (userRunnedSections instanceof Map) {
-        userRunnedSections.set(sectionId, {
-          instance: sectionInstance,
-          route: sectionRoute,
-        });
-        sectionInstalled = true;
-      } else if (userRunnedSections === undefined) {
-        userRunnedSections = new Map<string, RunnedSection>([
-          [
-            sectionId,
-            {
-              instance: sectionInstance,
-              route: sectionRoute,
-            },
-          ],
-        ]);
-        sectionInstalled = true;
+    if (createdNewSectionInstance) {
+      this.debugLog(`Creating new section instance for user ${ctx.user.username}`);
+      runnedSection = createRunnedSection(createSectionInstance(sectionClass), sectionRoute);
+
+      if (this.config.keepSectionInstances) {
+        if (!this.runnedSections.has(ctx.user)) {
+          this.runnedSections.set(ctx.user, []);
+        }
+        (this.runnedSections.get(ctx.user) as RunnedSection[]).push(runnedSection);
       }
     }
 
-    if (!runnedSection && !this.config.keepSectionInstances) {
-      this.runnedSections.set(ctx.user, {
-        instance: sectionInstance,
-        route: sectionRoute,
-      });
-      sectionInstalled = true;
+    if (runnedSection) {
+      sectionInstance = runnedSection.instance;
+    } else {
+      throw new Error(`Failed to create or retrieve runned section for ${sectionId}`);
     }
 
     if (!(sectionInstance as any)[method]) {
@@ -862,14 +881,12 @@ export class App {
     const unsetupMethod = sectionInstance.unsetup;
 
     // Run setup if section is installed
-    if (sectionInstalled && setupMethod && typeof setupMethod === "function") {
-      if (sectionInstalled) {
+    if (createdNewSectionInstance && setupMethod && typeof setupMethod === "function") {
         this.debugLog(`[Setup] Section ${sectionId} install for user ${ctx.user.username}`);
         await sectionInstance.setup();
         this.debugLog(
           `[Setup finish] Section ${sectionId} installed for user ${ctx.user.username}`
         );
-      }
     }
 
     // Run up method

package/src/illumination/Message2Byte.ts

@@ -1,6 +1,6 @@
 import { Telegraf2byteContext } from "./Telegraf2byteContext";
 import { Input, Markup } from "telegraf";
-import type { ReplyKeyboardMarkup } from 'telegraf/core/types/telegram';
+import type { ReplyKeyboardMarkup } from "telegraf/core/types/telegram";
 import { InlineKeyboard } from "./InlineKeyboard";
 import { RequestInputOptions } from "../types";
 import { Message } from "telegraf/types";
@@ -198,36 +198,37 @@ export default class Message2byte {
       }
 
       const message = this.ctx.callbackQuery?.message as Message;
-      
+
       if (message) {
-        if ('media_group_id' in message || 'caption' in message) {
+        if ("media_group_id" in message || "caption" in message) {
           const editMessageCaption = this.editMessageCaption(this.messageValue, this.messageExtra);
 
-          if (editMessageCaption && 'message_id' in editMessageCaption) {
+          if (editMessageCaption && "message_id" in editMessageCaption) {
             this.messageId = editMessageCaption.message_id as number;
           }
 
           return editMessageCaption;
         } else {
-
           const editedText = this.editMessageText(this.messageValue, this.messageExtra);
 
-          if (editedText && 'message_id' in editedText) {
-            this.messageId = editedText.message_id as number;
+          if (editedText && "message_id" in editedText) {
+            // this.messageId = editedText.message_id as number;
           }
 
           return editedText;
         }
       } else {
-        this.messageExtra.message_id = this.messageId;
+        // this.messageExtra.message_id = this.messageId;
 
-        const messageEntity = await this.editMessageText(this.messageValue, this.messageExtra);
+        try {
+          const messageEntity = await this.editMessageText(this.messageValue, this.messageExtra);
 
-        if (typeof messageEntity === "object" && 'message_id' in messageEntity) {
-          this.messageId = messageEntity.message_id as number;
-        }
-        
-        return messageEntity;
+          if (typeof messageEntity === "object" && "message_id" in messageEntity) {
+            this.messageId = messageEntity.message_id as number;
+          }
+
+          return messageEntity;
+        } catch (e) {}
       }
     }
 
@@ -237,7 +238,7 @@ export default class Message2byte {
 
     const replyEntity = this.ctx.reply(this.messageValue, this.messageExtra);
 
-    this.messageId = (await replyEntity).message_id;
+    // this.messageId = (await replyEntity).message_id;
 
     return replyEntity;
   }

package/src/illumination/Message2bytePool.ts

@@ -1,6 +1,7 @@
 import type { Section, Telegraf2byteContext } from "@2byte/tgbot-framework";
 import Message2byte from "./Message2Byte";
 import Message2ByteLiveProgressive from "./Message2ByteLiveProgressive";
+import { InlineKeyboard } from "./InlineKeyboard";
 
 export default class Message2bytePool {
     private message2byte: Message2byte;
@@ -61,6 +62,11 @@ export default class Message2bytePool {
         return Message2ByteLiveProgressive.init(this.message2byte, this);
     }
 
+    inlineKeyboard(keyboard: InlineKeyboard): this {
+        this.message2byte.inlineKeyboard(keyboard);
+        return this;
+    }
+
     async send() {
 
         const entity = await this.message2byte.send();

package/src/illumination/RunSectionRoute.ts

@@ -6,7 +6,7 @@ export class RunSectionRoute {
     method: null,
     methodArgs: null,
     callbackParams: new URLSearchParams(),
-    runAsCallcackQuery: false,
+    runAsCallbackQuery: false,
     actionPath: null,
     hearsKey: null,
   };
@@ -20,7 +20,7 @@ export class RunSectionRoute {
 
   method(name: string = 'index', isRunCallbackQuery: boolean = false): this {
     this.runParams.method = name;
-    this.runParams.runAsCallcackQuery = isRunCallbackQuery;
+    this.runParams.runAsCallbackQuery = isRunCallbackQuery;
     return this;
   }
 
@@ -32,13 +32,13 @@ export class RunSectionRoute {
   callbackParams(actionPath: string, params: string | Record<string, string>): this {
     this.runParams.callbackParams = new URLSearchParams(params);
     this.actionPath(actionPath);
-    this.runParams.runAsCallcackQuery = true;
+    this.runParams.runAsCallbackQuery = true;
     return this;
   }
 
   actionPath(path: string): this {
     this.runParams.actionPath = path;
-    this.runParams.runAsCallcackQuery = true;
+    this.runParams.runAsCallbackQuery = true;
     return this;
   }
 
@@ -47,6 +47,16 @@ export class RunSectionRoute {
     return this;
   }
 
+  runAsCommand(flag: boolean = true): this {
+    this.runParams.runAsCallbackQuery = !flag;
+    return this;
+  }
+
+  runAsCallbackQuery(flag: boolean = true): this {
+    this.runParams.runAsCallbackQuery = flag;
+    return this;
+  }
+
   getMethod(): string | null {
     return this.runParams.method;
   }
@@ -80,6 +90,6 @@ export class RunSectionRoute {
   }
 
   get runIsCallbackQuery(): boolean {
-    return this.runParams.runAsCallcackQuery;
+    return this.runParams.runAsCallbackQuery;
   }
 }

package/src/illumination/Section.ts

@@ -310,7 +310,7 @@ export class Section {
     return false;
   }
 
-  backInlineButtion(data: string): any {
+  backInlineButton(data: string): any {
     return this.markup.button.callback(this.labelBack, data);
   }
 
@@ -396,6 +396,16 @@ export class Section {
       : this.createPoolNewMessage(message);
   }
 
+  updateCtx(newCtx: Telegraf2byteContext): this {
+    this.ctx = newCtx;
+    return this;
+  }
+
+  updateRoute(newRoute: RunSectionRoute): this {
+    this.route = newRoute;
+    return this;
+  }
+
   getCtx(): Telegraf2byteContext {
     return this.ctx;
   }

package/src/types.ts

@@ -133,7 +133,7 @@ export interface RunSectionRouteParams {
   method: string | null;
   methodArgs: any[] | null;
   callbackParams: URLSearchParams;
-  runAsCallcackQuery: boolean;
+  runAsCallbackQuery: boolean;
   actionPath: string | null;
   hearsKey: string | null;
 }

package/templates/bot/package.json

@@ -1,6 +1,6 @@
 {
   "name": "{{kebabName}}",
-  "version": "1.0.9",
+  "version": "1.0.0",
   "description": "{{description}}",
   "main": "bot.ts",
   "scripts": {
@@ -21,7 +21,7 @@
   "author": "{{author}}",
   "license": "MIT",
   "dependencies": {
-    "@2byte/tgbot-framework": "^1.0.6"
+    "@2byte/tgbot-framework": "^1.0.11"
   },
   "devDependencies": {
     "@types/node": "^20.19.8",