@2byte/tgbot-framework 1.0.13 → 1.0.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@2byte/tgbot-framework",
-  "version": "1.0.13",
+  "version": "1.0.15",
   "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/ApiService.ts

@@ -1,10 +1,13 @@
 import { App } from "./App";
 
-export abstract class ApiService {
+export class ApiService<T = any> {
+
+    public name: string = "ApiService";
+
+    protected app!: App;
 
     constructor(
-        protected app: App,
-        public name: string
+        public params: T = {} as T
     ) {}
 
     async setup(): Promise<void> {
@@ -18,4 +21,9 @@ export abstract class ApiService {
     async run(): Promise<void> {
         // Implement your API logic here
     }
+
+    public setApp(app: App): this {
+        this.app = app;
+        return this;
+    }
 }

package/src/core/ApiServiceManager.ts

@@ -51,13 +51,29 @@ export class ApiServiceManager {
     }
   }
 
+  public async runAllServices(): Promise<void> {
+    for (const [name, service] of this.services) {
+      this.app.debugLog(`Running API service: ${name}`);
+      await service.run();
+      this.app.debugLog(`API service run completed: ${name}`);
+    }
+  }
+
   public getAll(): Map<string, ApiService> {
     return this.services;
   }
 
+  public async setupAllServices(): Promise<void> {
+    for (const [name, service] of this.services) {
+      this.app.debugLog(`Setting up API service: ${name}`);
+      await this.setupService(name);
+      this.app.debugLog(`API service setup completed: ${name}`);
+    }
+  }
+
   public async unsetupAllServices(): Promise<void> {
     for (const [name, service] of this.services) {
-      await service.unsetup();
+      await this.unsetupService(name);
     }
   }
 }

package/src/core/App.ts

@@ -21,6 +21,7 @@ import {
 import { nameToCapitalize } from "./utils";
 import { ApiServiceManager } from "./ApiServiceManager";
 import { message } from "telegraf/filters";
+import { ApiService } from "./ApiService";
 
 export class App {
   private config: AppConfig = {
@@ -43,6 +44,7 @@ export class App {
     terminateSigTerm: true,
     keepSectionInstances: false,
     botCwd: process.cwd(),
+    services: [],
   };
 
   public bot!: Telegraf<Telegraf2byteContext>;
@@ -72,7 +74,7 @@ export class App {
     }
   > = new Map();
 
-  private messageHandlers: any[] = [];
+  private messageHandlers: RunSectionRoute[] | CallableFunction<this>[] = [];
 
   constructor() {
     this.middlewares.push(this.mainMiddleware.bind(this));
@@ -160,13 +162,12 @@ export class App {
       return this;
     }
 
-    messageHandlers(handlers: any[]): this {
+    messageHandlers(handlers: RunSectionRoute[] | CallableFunction<this>[]): this {
       this.app.messageHandlers = handlers;
       return this;
     }
 
     /**
-     *
      * @param keep Whether to keep section instances in memory after they are run.
      * If true, sections will not be reloaded on each request, improving performance for frequently accessed sections.
      * If false, sections will be reloaded each time they are accessed, ensuring the latest version is used.
@@ -188,6 +189,11 @@ export class App {
       return this;
     }
 
+    services(services: ApiService[]): this {
+      this.app.config.services = services;
+      return this;
+    }
+
     build(): App {
       return this.app;
     }
@@ -274,7 +280,7 @@ export class App {
       }
 
       // Check access by username and register user if not exists
-      if (!this.config.userStorage.exists(tgUsername)) {
+      if (!this.config.userStorage.exists(tgUsername) && !this.rememberUser(tgUsername)) {
         const isAuthByUsername = !this.config.accessPublic && !accessKey;
 
         // check access by username for private bots
@@ -288,6 +294,7 @@ export class App {
             checkAccess &&
             checkAccess.every((name) => name.toLowerCase() !== requestUsername.toLowerCase())
           ) {
+            this.debugLog("Username access denied:", requestUsername);
             return ctx.reply("Access denied. Your username is not in the access list.");
           }
           this.debugLog("Username access granted.");
@@ -425,20 +432,53 @@ export class App {
         !ctx.userSession.stateAfterValidatedUserResponse
       ) {
         this.messageHandlers.forEach(async (handler: any) => {
+          if (ctx.caught) {
+            this.debugLog("Message already caught by another handler, skipping remaining handlers.");
+            return;
+          }
+
+          const isHandlerRunSectionRoute = handler instanceof RunSectionRoute;
+
+          if (isHandlerRunSectionRoute) {
+            this.debugLog("Checking message handler section route:", handler);
+            await this.runSection(ctx, handler, {
+              cbBeforeRunMethod: async (sectionInstance: Section) => {
+                sectionInstance.runForMessageHandler = true;
+              },
+            });
+            if (ctx.caught) {
+              this.debugLog("Message handler route caught the message, skipping remaining handlers.");
+              return;
+            }
+          }
+
           const handlerIsClass =
             typeof handler === "function" && /^\s*class\s+/.test(handler.toString());
           const nameHandler = handlerIsClass
             ? handler.name
             : handler.constructor?.name || "unknown";
 
-          this.debugLog("Handling message with handler class:", nameHandler);
-
-          if (handlerIsClass) {
+          if (handlerIsClass && !ctx.caught) {
+            this.debugLog(`Running message handler class ${nameHandler} for user ${ctx.user.username}`);
             await new handler(this).handle(ctx);
+            if (ctx.caught) {
+              this.debugLog("Message handler class caught the message, skipping remaining handlers.");
+              return;
+            }
+          } else if (!handlerIsClass && typeof handler === "function" && !ctx.caught) {
+            this.debugLog(`Running message handler function ${nameHandler} for user ${ctx.user.username}`);
+            await handler(ctx);
+            if (ctx.caught) {
+              this.debugLog("Message handler function caught the message, skipping remaining handlers.");
+              return;
+            }
           }
         });
       } else {
-        this.debugLog("Message input already handled by awaitingInput or awaitingInputPromise. stateAfterValidatedUserResponse:", ctx.userSession.stateAfterValidatedUserResponse);
+        this.debugLog(
+          "Message input already handled by awaitingInput or awaitingInputPromise. stateAfterValidatedUserResponse:",
+          ctx.userSession.stateAfterValidatedUserResponse
+        );
       }
 
       delete ctx.userSession.stateAfterValidatedUserResponse; // Clear the state after handling the message
@@ -462,7 +502,7 @@ export class App {
       // Get the largest photo (the last one in the array is usually the largest)
       const largestPhoto = photo[photo.length - 1];
       await this.handleUserInput(ctx, largestPhoto, "photo");
-      
+
       delete ctx.userSession.stateAfterValidatedUserResponse; // Clear the state after handling the message
     });
   }
@@ -470,39 +510,38 @@ export class App {
   private async registerServices() {
     this.apiServiceManager = ApiServiceManager.init(this);
 
-    const registerServices = async (pathDirectory: string) => {
-      try {
-        await this.apiServiceManager.loadServicesFromDirectory(pathDirectory);
-      } catch (error) {
-        this.debugLog("Error loading services:", error);
-        throw error;
-      }
+    // Register services from config
+    this.debugLog(
+      "Registering services from config:",
+      this.config.services.map((service) => service.constructor.name)
+    );
 
-      this.debugLog(
-        "Registered API services:%s in dir: %s",
-        Array.from(this.apiServiceManager.getAll().keys()),
-        pathDirectory
-      );
+    this.config.services.forEach((service) => {
+      this.debugLog(`Registering service: ${service.constructor.name}`);
+      this.apiServiceManager.registerService(service.name, service.setApp(this));
+      this.debugLog(`Service ${service.constructor.name} registered`);
+    });
 
-      for (const [name, service] of this.apiServiceManager.getAll()) {
-        await service.setup();
-        this.debugLog(`Service ${name} setup completed`);
-        await service.run();
-        this.debugLog(`Service ${name} run completed`);
-      }
-    };
+    try {
+      await this.apiServiceManager.setupAllServices();
+    } catch (error) {
+      this.debugLog("Error setting up services:", error);
+      throw error;
+    }
 
-    // Register services from bot directory
-    await registerServices(this.config.botCwd + "/workflow/services");
-    // Register services from framework directory
-    await registerServices(path.resolve(__dirname, "../workflow/services"));
+    try {
+      await this.apiServiceManager.runAllServices();
+    } catch (error) {
+      this.debugLog("Error running services:", error);
+      throw error;
+    }
   }
 
   private async unregisterServices() {
     this.apiServiceManager = ApiServiceManager.init(this);
 
     try {
-      this.apiServiceManager.unsetupAllServices();
+      await this.apiServiceManager.unsetupAllServices();
     } catch (error) {
       this.debugLog("Error unsetting up services:", error);
       throw error;
@@ -923,7 +962,7 @@ export class App {
     if (sectionRoute.hasTriggers()) {
       this.debugLog("Section route has triggers, executing them before running method:", sectionId);
       sectionRoute.getTriggers().forEach((trigger) => {
-        if (trigger.name === 'cbBeforeRunMethod') {
+        if (trigger.name === "cbBeforeRunMethod") {
           this.debugLog(`Executing cbBeforeRunMethod trigger for section ${sectionId}`);
           this.debugLog("Trigger details:", trigger);
 
@@ -1019,6 +1058,32 @@ export class App {
     }
   }
 
+  /**
+   * Remembers a user in storage by their Telegram username. If the user does not exist in storage, it attempts to fetch the user from the database and add them to storage. This is useful for ensuring that the storage has the latest user data from the database, especially in cases where user information might have been updated.
+   * @param tgUsername Telegram username of the user to remember. This method checks if the user exists in storage, and if not, tries to fetch it from the database and add to storage. This is useful for cases when user data might be updated in the database and we want to refresh the storage with the latest data.
+   * @returns A boolean indicating whether the user was successfully remembered (true) or not (false).
+   */
+  async rememberUser(tgUsername: string): Promise<boolean> {
+    if (this.config.userStorage && !this.config.userStorage.exists(tgUsername)) {
+      this.debugLog("Warning: Username not found in storage:", tgUsername);
+      this.debugLog("Trying getting to database:", tgUsername);
+      
+      // Try to get user from database and add to storage
+      UserModel.resolveDb();
+      const userFromDb = UserModel.findByUsername(tgUsername);
+      
+      if (userFromDb) {
+        this.config.userStorage.add(tgUsername, userFromDb);
+        this.debugLog("Success: User found in database and added to storage:", tgUsername);
+        this.debugLog('Success: Remembered user "' + tgUsername + '"');
+        return true;
+      } else {
+        this.debugLog("Warning: User not found in database:", tgUsername);
+      }
+    }
+    return false;
+  }
+
   /**
    * Runs a task with bidirectional communication support
    * @param ctx Telegram context
@@ -1227,9 +1292,71 @@ export class App {
   }
 
   debugLog(...args: any[]): void {
-    if (this.config.debug) {
-      console.log(...args);
-    }
+    if (!this.config.debug) return;
+
+    // Color palette
+    const colors = {
+      reset: "\x1b[0m",
+      bright: "\x1b[1m",
+      dim: "\x1b[2m",
+      underscore: "\x1b[4m",
+      fg: {
+        red: "\x1b[31m",
+        green: "\x1b[32m",
+        yellow: "\x1b[33m",
+        blue: "\x1b[34m",
+        magenta: "\x1b[35m",
+        cyan: "\x1b[36m",
+        white: "\x1b[37m",
+      },
+      bg: {
+        red: "\x1b[41m",
+        green: "\x1b[42m",
+        yellow: "\x1b[43m",
+        blue: "\x1b[44m",
+        magenta: "\x1b[45m",
+        cyan: "\x1b[46m",
+        white: "\x1b[47m",
+      },
+    };
+
+    // Timestamp
+    const now = new Date();
+    const timestamp = `${colors.dim}${colors.fg.cyan}[${now.toLocaleTimeString()}]${colors.reset}`;
+
+    // Source (App debug)
+    const source = `${colors.bright}${colors.fg.magenta}AppDebug${colors.reset}`;
+
+    // Format args: highlight objects, errors, etc.
+    const formattedArgs = args.map(arg => {
+      if (arg instanceof Error) {
+        return `${colors.fg.red}${arg.stack || arg.message}${colors.reset}`;
+      }
+      if (typeof arg === "object" && arg !== null) {
+        try {
+          return `${colors.fg.yellow}${JSON.stringify(arg, null, 2)}${colors.reset}`;
+        } catch {
+          return `${colors.fg.yellow}[Object]${colors.reset}`;
+        }
+      }
+      if (typeof arg === "string") {
+        // Highlight keywords
+        if (/error|fail|exception/i.test(arg)) {
+          return `${colors.fg.red}${arg}${colors.reset}`;
+        }
+        if (/success|done|complete/i.test(arg)) {
+          return `${colors.fg.green}${arg}${colors.reset}`;
+        }
+        if (/warn|warning/i.test(arg)) {
+          return `${colors.fg.yellow}${arg}${colors.reset}`;
+        }
+        return `${colors.fg.white}${arg}${colors.reset}`;
+      }
+      return String(arg);
+    });
+
+    // Compose and print
+    console.log(`${timestamp} ${source}:`, ...formattedArgs);
   }
 
   get sections(): SectionList {

package/src/core/Model.ts

@@ -14,7 +14,7 @@ export abstract class Model {
     this.db = database;
   }
 
-  protected static resolveDb(): Database {
+  public static resolveDb(): Database {
     if (globalThis.db) {
       this.db = globalThis.db;
     } else {

package/src/illumination/RunSectionRoute.ts

@@ -63,6 +63,10 @@ export class RunSectionRoute {
     return this;
   }
 
+  static for(sectionId: string, methodName: string = 'index'): RunSectionRoute {
+    return new RunSectionRoute().section(sectionId).method(methodName);
+  }
+
   hasTriggers(): boolean {
     return this.runParams.triggers.length > 0;
   }

package/src/illumination/Section.ts

@@ -15,6 +15,7 @@ export class Section {
   static actionRoutes: { [key: string]: string };
   public sectionId: string = "BaseSection";
   public route: RunSectionRoute;
+  public runForMessageHandler: boolean = false;
   protected ctx: Telegraf2byteContext;
   protected bot: Telegraf<Telegraf2byteContext>;
   protected app: App;

package/src/illumination/Telegraf2byteContext.ts

@@ -11,6 +11,7 @@ export interface Telegraf2byteContext extends Context, ITelegraf2byteContextExtr
   user: UserModel;
   userStorage: UserStore;
   userSession: UserSession;
+  caught: boolean;
   // msgId?: number;
 }
 

package/src/index.ts

@@ -2,6 +2,7 @@
 export { App } from './core/App';
 export { ApiService } from './core/ApiService';
 export { ApiServiceManager } from './core/ApiServiceManager';
+export { MassSendApiService } from './workflow/services/MassSendApiService';
 export { BotArtisan } from './core/BotArtisan';
 export { BotMigration } from './core/BotMigration';
 export { BotSeeder } from './core/BotSeeder';

package/src/types.ts

@@ -3,6 +3,7 @@ import { Section } from './illumination/Section';
 import { UserStore } from './user/UserStore';
 import { Telegraf2byteContext } from './illumination/Telegraf2byteContext';
 import { RunSectionRoute } from './illumination/RunSectionRoute';
+import { ApiService } from './core/ApiService';
 
 export interface AppConfig {
   accessPublic: boolean;
@@ -24,6 +25,7 @@ export interface AppConfig {
   terminateSigTerm: boolean;
   keepSectionInstances: boolean;
   botCwd: string;
+  services: ApiService[];
 }
 
 export interface SectionOptions {

package/src/workflow/services/MassSendApiService.ts

@@ -1,83 +1,94 @@
-import { ExtraReplyMessage } from 'telegraf/typings/telegram-types';
-import { ApiService} from '../../core/ApiService';
-import { App } from '../../core/App';
-import { UserModel } from '../../user/UserModel';
-
-export default class MassSendApiService extends ApiService {
-
-    private bunServerInstance: any;
-
-    constructor(
-        protected app: App,
-        public name: string = "MassSendApiService"
-    ) {
-        super(app, name);
-    }
-
-    public async setup(): Promise<void> {
-        return Promise.resolve();
-    }
-
-    public async unsetup(): Promise<void> {
-        return Promise.resolve();
-    }
-
-    public async run(): Promise<void> {
-        this.bunServerInstance = Bun.serve({
-            port: this.app.configApp.envConfig.BOT_APP_API_PORT || 3033,
-            routes: {
-                '/': async (req) => {
-                    const receivedData = (await req.json()) as { userIds?: number[]; message?: string, extra?: ExtraReplyMessage };
-                    this.app.debugLog("Received data for mass message:", receivedData);
-
-                    let userIds: number[] = [];
-                    let message: string = "Hello from MassSendApiService";
-
-                    if (receivedData && typeof receivedData == 'object') {
-                        userIds = receivedData?.userIds || [];
-                        message = receivedData?.message || "Hello from MassSendApiService";
-                    }
-
-                    this.sendMassMessage(userIds, message, receivedData.extra);
-
-                    return Response.json({ status: 200, body: 'Mass message sending initiated.' });
-                }
-            }
-        });
-
-        this.app.debugLog(`MassSendApiService Bun server running at http://localhost:${this.bunServerInstance.port}/`);
-
-        return Promise.resolve();
-    }
-
-    private async sendMassMessage(userIds: number[] = [], message: string, extra?: ExtraReplyMessage): Promise<void> {
-        if (userIds.length === 0) {
-
-            if (!db) {
-                throw new Error("Database connection is not established.");
-            }
-
-            UserModel.setDatabase(db);
-
-            this.app.debugLog("Fetching all users for mass message...");
-            const users = UserModel.getAll(); 
-
-            this.app.debugLog("Fetched users for mass message:", users);
-
-            if (users && users.length > 0) {
-                for (const user of users) {
-                    this.app.debugLog(`Sending message to user ID: ${user.tgId} username: ${user.username}`);
-
-                    try {
-                        const extraOptions = extra || {};
-                        await this.app.bot.telegram.sendMessage(user.tgId, message, extraOptions);
-                        this.app.debugLog(`Message sent to user ID: ${user.tgId} username: ${user.username}`);
-                    } catch (error) {
-                        this.app.debugLog(`Sending message ${message} to user ID: ${user.tgId} username: ${user.username} failed`, error);
-                        this.app.debugLog(`Failed to send message to user ID: ${user.tgId} username: ${user.username}`, error);
-                    }
-                }
-            }
+import { ExtraReplyMessage } from "telegraf/typings/telegram-types";
+import { ApiService } from "../../core/ApiService";
+import { UserModel } from "../../user/UserModel";
+
+export type MassSendApiParams = {
+    port?: number;
+};
+
+export class MassSendApiService extends ApiService<MassSendApiParams> {
+  public override name = "MassSendApiService";
+  private bunServerInstance: any;
+
+  public async setup(): Promise<void> {
+    return Promise.resolve();
+  }
+
+  public async unsetup(): Promise<void> {
+    return Promise.resolve();
+  }
+
+  public async run(): Promise<void> {
+    this.bunServerInstance = Bun.serve({
+      port: this.params.port || this.app.configApp.envConfig.BOT_APP_API_PORT || 3033,
+      routes: {
+        "/": async (req) => {
+          const receivedData = (await req.json()) as {
+            userIds?: number[];
+            message?: string;
+            extra?: ExtraReplyMessage;
+          };
+          this.app.debugLog("Received data for mass message:", receivedData);
+
+          let userIds: number[] = [];
+          let message: string = "Hello from MassSendApiService";
+
+          if (receivedData && typeof receivedData == "object") {
+            userIds = receivedData?.userIds || [];
+            message = receivedData?.message || "Hello from MassSendApiService";
+          
+            this.sendMassMessage(userIds, message, receivedData.extra);
+          }
+
+          return Response.json({ status: 200, body: "Mass message sending initiated." });
+        },
+      },
+    });
+
+    this.app.debugLog(
+      `MassSendApiService Bun server running at http://localhost:${this.bunServerInstance.port}/`
+    );
+
+    return Promise.resolve();
+  }
+
+  private async sendMassMessage(
+    userIds: number[] = [],
+    message: string,
+    extra?: ExtraReplyMessage
+  ): Promise<void> {
+    if (userIds.length === 0) {
+      if (!db) {
+        throw new Error("Database connection is not established.");
+      }
+
+      UserModel.setDatabase(db);
+
+      this.app.debugLog("Fetching all users for mass message...");
+      const users = UserModel.getAll();
+
+      this.app.debugLog("Fetched users for mass message:", users);
+
+      if (users && users.length > 0) {
+        for (const user of users) {
+          this.app.debugLog(`Sending message to user ID: ${user.tgId} username: ${user.username}`);
+
+          try {
+            const extraOptions = extra || {};
+            await this.app.bot.telegram.sendMessage(user.tgId, message, extraOptions);
+            this.app.debugLog(`Message sent to user ID: ${user.tgId} username: ${user.username}`);
+          } catch (error) {
+            this.app.debugLog(
+              `Sending message ${message} to user ID: ${user.tgId} username: ${user.username} failed`,
+              error
+            );
+            this.app.debugLog(
+              `Failed to send message to user ID: ${user.tgId} username: ${user.username}`,
+              error
+            );
+          }
         }
+      }
     }
+  }
 }

package/templates/bot/package.json

@@ -21,7 +21,7 @@
   "author": "{{author}}",
   "license": "MIT",
   "dependencies": {
-    "@2byte/tgbot-framework": "^1.0.13"
+    "@2byte/tgbot-framework": "^1.0.15"
   },
   "devDependencies": {
     "@types/node": "^20.19.8",