@2byte/tgbot-framework 1.0.8 → 1.0.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@2byte/tgbot-framework",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "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();
 
@@ -702,7 +702,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);
         });
       }
@@ -731,19 +731,23 @@ export class App {
       throw new Error(`Section ${sectionId} not found at path ${pathSectionModule}.ts`);
     }
 
-    if (freshVersion) {
-      pathSectionModule += "?update=" + Date.now();
-    }
-
-    // For bypassing cache in Node.js/Bun, we use file:// protocol with a query parameter
-    let importPath = pathSectionModule;
-    if (freshVersion) {
-      // We convert the path to a file:// URL with a query parameter
-      const fileUrl = new URL(`file:///${pathSectionModule.replace(/\\/g, "/")}`);
-      fileUrl.searchParams.set("t", Date.now().toString());
-      importPath = fileUrl.href;
+    // For bypassing cache in Bun, we need to clear the module cache
+    if (freshVersion && typeof Bun !== 'undefined') {
+      // Clear Bun's module cache for this specific module
+      const modulePath = pathSectionModule + ".ts";
+      this.debugLog('Clearing cache for fresh version of section:', modulePath);
+      
+      // In Bun, we can use dynamic import with a unique query to bypass cache
+      // But we need to resolve the absolute path first
+      const absolutePath = path.resolve(modulePath);
+      
+      // Try to delete from require cache if it exists
+      if (require.cache && require.cache[absolutePath]) {
+        delete require.cache[absolutePath];
+      }
     }
-    const sectionClass = (await import(importPath)).default as typeof Section;
+    
+    const sectionClass = (await import(pathSectionModule)).default as typeof Section;
     this.debugLog("Loaded section", sectionId);
 
     return sectionClass;
@@ -787,56 +791,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);
+
+          if (sectionRoute.runIsCallbackQuery) {
+            runnedSection.route.runAsCallbackQuery();
+          }
+
+        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]) {
@@ -858,14 +880,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/Artisan.ts

@@ -46,9 +46,9 @@ export class Artisan {
    * Возвращает шаблон для новой секции
    */
   private getSectionTemplate(name: string): string {
-    return `import { Section } from "../../src/illumination/Section";
-import { SectionOptions } from "../../src/types";
-import { InlineKeyboard } from "../../src/illumination/InlineKeyboard";
+    return `import { Section } from "@2byte/tgbot-framework";
+import { SectionOptions } from "@2byte/tgbot-framework";
+import { InlineKeyboard } from "@2byte/tgbot-framework";
 
 export default class ${name}Section extends Section {
   static command = "${name.toLowerCase()}";

package/src/illumination/Message2Byte.ts

@@ -213,13 +213,13 @@ export default class Message2byte {
           const editedText = this.editMessageText(this.messageValue, this.messageExtra);
 
           if (editedText && 'message_id' in editedText) {
-            this.messageId = editedText.message_id as number;
+            // 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);
 
@@ -237,7 +237,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

@@ -47,6 +47,16 @@ export class RunSectionRoute {
     return this;
   }
 
+  runAsCommand(): this {
+    this.runParams.runAsCallcackQuery = false;
+    return this;
+  }
+
+  runAsCallbackQuery(): this {
+    this.runParams.runAsCallcackQuery = true;
+    return this;
+  }
+
   getMethod(): string | null {
     return this.runParams.method;
   }

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/templates/bot/models/Model.ts

@@ -1,7 +1,8 @@
 import type { Database } from "bun:sqlite";
 import { MakeManualPaginateButtonsParams, ModelPaginateParams, PaginateResult } from "@2byte/tgbot-framework";
 import { Section } from "@2byte/tgbot-framework";
+import { Model as BaseModel } from "@2byte/tgbot-framework";
 
-export abstract class Model {
+export abstract class Model extends BaseModel {
   
 }

package/templates/bot/package.json

@@ -1,6 +1,6 @@
 {
   "name": "{{kebabName}}",
-  "version": "1.0.8",
+  "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.10"
   },
   "devDependencies": {
     "@types/node": "^20.19.8",