@2byte/tgbot-framework 1.0.0 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@2byte/tgbot-framework",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "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

@@ -18,6 +18,7 @@ import { nameToCapitalize } from "./utils";
 
 export class App {
   private config: AppConfig = {
+    accessPublic: true,
     apiUrl: null,
     envConfig: {},
     botToken: null,
@@ -75,6 +76,16 @@ export class App {
       this.app = new App();
     }
 
+    accessPublic(isPublic: boolean = true): this {
+      this.app.config.accessPublic = isPublic;
+      return this;
+    }
+
+    accessPrivate(isPrivate: boolean = true): this {
+      this.app.config.accessPublic = !isPrivate;
+      return this;
+    }
+
     apiUrl(url: string): this {
       this.app.config.apiUrl = url;
       return this;
@@ -232,15 +243,30 @@ export class App {
       }
 
       if (!this.config.userStorage.exists(tgUsername)) {
-        const userData = await this.registerUser({
-          tgUsername,
-          tgName: this.getTgName(ctx),
-          tgId: this.getTgId(ctx),
-        });
+        if (!this.config.accessPublic) {
+          const requestUsername = this.getTgUsername(ctx);
+          this.debugLog("Private access mode. Checking username:", requestUsername);
+          const checkAccess = this.config.envConfig.ACCESS_USERNAMES && this.config.envConfig.ACCESS_USERNAMES.split(",").map(name => name.trim());
+          if (checkAccess && checkAccess.every(name => name !== requestUsername)) {
+            return ctx.reply("Access denied. Your username is not in the access list.");
+          }
+        }
 
-        if (!userData) {
-          throw new Error("User registration failed");
+        if (!ctx.from) {
+          return ctx.reply("User information is not available");
         }
+
+        const userRefIdFromStart = ctx.startPayload ? parseInt(ctx.startPayload) : 0;
+
+        await this.registerUser({
+          user_refid: userRefIdFromStart,
+          tg_id: ctx.from.id,
+          tg_username: tgUsername,
+          tg_first_name: ctx.from.first_name || tgUsername,
+          tg_last_name: ctx.from.last_name || "",
+          role: 'user',
+          language: ctx.from.language_code || "en",
+        })
       }
 
       ctx.user = this.config.userStorage.find(tgUsername);
@@ -785,7 +811,7 @@ export class App {
       const user = await UserModel.register(data);
 
       if (this.config.userStorage) {
-        this.config.userStorage.add(data.tgUsername, user);
+        this.config.userStorage.add(data.tg_username, user);
       }
 
       return user;
@@ -1010,7 +1036,7 @@ export class App {
     return this.config.sections;
   }
 
-  get config(): AppConfig {
+  get configApp(): AppConfig {
     return this.config;
   }
 }

package/src/core/Model.ts

@@ -0,0 +1,84 @@
+import type { Database } from "bun:sqlite";
+import { MakeManualPaginateButtonsParams, ModelPaginateParams, PaginateResult } from "../types";
+import { Section } from "../illumination/Section";
+
+declare global {
+  var db: Database;
+}
+
+export abstract class Model {
+  protected static db: Database;
+  protected static tableName: string;
+
+  static setDatabase(database: Database) {
+    this.db = database;
+  }
+
+  protected static resolveDb(): Database {
+    if (globalThis.db) {
+      this.db = globalThis.db;
+    } else {
+      throw new Error("Database connection is not set.");
+    }
+    return this.db;
+  }
+
+  protected static query(sql: string, params: any[] = []): any {
+    const stmt = this.db.prepare(sql);
+    return stmt.all(...params);
+  }
+
+  protected static run(sql: string, params: any[] = []): { lastInsertRowid: number, changes: number } {
+    const stmt = this.db.prepare(sql);
+    return stmt.run(...params);
+  }
+
+  protected static queryOne(sql: string, params: any[] = []): any {
+    const stmt = this.db.prepare(sql);
+    return stmt.get(...params);
+  }
+
+  protected static execute(sql: string, params: any[] = []): void {
+    const stmt = this.db.prepare(sql);
+    stmt.run(...params);
+  }
+
+  protected static exists(whereSql: string, whereParams: any[] = []): boolean {
+    const sql = `SELECT 1 FROM ${this.tableName} ${whereSql} LIMIT 1`;
+    const result = this.queryOne(sql, whereParams);
+    return !!result;
+  }
+
+  protected static transaction<T>(callback: () => T): T {
+    return this.db.transaction(callback)();
+  }
+
+  public static async paginate(paginateParams: ModelPaginateParams): Promise<PaginateResult> {
+    const { page, route, routeParams, limit, whereSql, whereParams } = paginateParams;
+    const offset = (page - 1) * limit;
+    const sql = `SELECT * FROM ${this.tableName} ${whereSql} LIMIT ${offset}, ${limit}`;
+
+    const result = await this.query(sql, whereParams);
+    const queryTotal = await this.queryOne(`SELECT COUNT(*) as count FROM ${this.tableName} ${whereSql}`, whereParams);
+    const total = queryTotal ? queryTotal.count : 0;
+    const totalPages = Math.ceil(total / limit);
+    const hasPreviousPage = page > 1;
+    const hasNextPage = page < totalPages;
+    
+    return {
+      items: result,
+      paginateButtons: Section.makeManualPaginateButtons({
+        callbackDataAction: route,
+        paramsQuery: routeParams || {},
+        currentPage: page,
+        totalRecords: total,
+        perPage: limit,
+      } as MakeManualPaginateButtonsParams),
+      total,
+      totalPages,
+      hasPreviousPage,
+      hasNextPage,
+      currentPage: page,
+    } as PaginateResult;
+  }
+}

package/src/illumination/InlineKeyboard.ts

@@ -1,44 +1,60 @@
 import { Telegraf2byteContext } from "./Telegraf2byteContext";
+import { Section } from "./Section";
 
 export class InlineKeyboard {
-
-    private keyboard: any[][] = [];
-
-    static init(ctx: Telegraf2byteContext) {
-        return new InlineKeyboard(ctx);
+  private keyboard: any[][] = [];
+  private footFixedButtons: any[][] = [];
+
+  static init(ctx: Telegraf2byteContext, section: Section): InlineKeyboard {
+    return new InlineKeyboard(ctx, section);
+  }
+
+  constructor(private ctx: Telegraf2byteContext, private section: Section) {}
+
+  addFootFixedButtons(buttons: any[][] | any[] | any): InlineKeyboard {
+    if (!Array.isArray(buttons)) {
+      this.footFixedButtons.push([buttons]);
+    } else if (Array.isArray(buttons[0])) {
+      this.footFixedButtons.push(...buttons);
+    } else {
+      this.footFixedButtons.push(buttons);
     }
-
-    constructor(private ctx: Telegraf2byteContext) {
-
+    return this;
+  }
+
+  append(row: any[] | any[][]): InlineKeyboard {
+    if (!Array.isArray(row)) {
+      this.keyboard.push([row]);
+    } else if (Array.isArray(row[0])) {
+      this.keyboard.push(...row);
+    } else {
+      this.keyboard.push(row);
     }
-
-    append(row: any[] | any[][]): InlineKeyboard {
-        if (!Array.isArray(row)) {
-            this.keyboard.push([row]);
-        } else if (Array.isArray(row[0])) {
-            this.keyboard.push(...row);
-        } else {
-            this.keyboard.push(row);
-        }
-        return this;
+    return this;
+  }
+
+  prepend(row: any[]): InlineKeyboard {
+    if (!Array.isArray(row)) {
+      this.keyboard.unshift([row]);
+    } else if (Array.isArray(row[0])) {
+      this.keyboard.unshift(...row);
+    } else {
+      this.keyboard.unshift(row);
     }
+    return this;
+  }
 
-    prepend(row: any[]): InlineKeyboard {
-        if (!Array.isArray(row)) {
-            this.keyboard.unshift([row]);
-        } else if (Array.isArray(row[0])) {
-            this.keyboard.unshift(...row);
-        } else {
-            this.keyboard.unshift(row);
-        }
-        return this;
-    }
+  valueOf(): any[][] {
+    const keyboard = this.keyboard;
 
-    valueOf(): any[][] {
-        return this.keyboard;
+    if (this.section.route.getMethod() !== 'index') {
+      keyboard.push(...this.footFixedButtons);
     }
+    
+    return keyboard;
+  }
 
-    [Symbol.toPrimitive]() {
-        return this.valueOf();
-    }
+  [Symbol.toPrimitive]() {
+    return this.valueOf();
+  }
 }

package/src/illumination/Message2Byte.ts

@@ -80,7 +80,7 @@ export default class Message2byte {
     return this;
   }
 
-  inlineKeyboard(keyboard: [][] | InlineKeyboard) {
+  inlineKeyboard(keyboard: any[][] | InlineKeyboard) {
     let keyboardArray: any[][];
 
     if (keyboard instanceof InlineKeyboard) {

package/src/illumination/Section.ts

@@ -32,6 +32,13 @@ export class Section {
   protected iconRefresh: string = "🔃";
   protected iconHistory: string = "🗂";
   protected iconEuro: string = "💶";
+  protected iconDollar: string = "💵";
+  protected iconRuble: string = "₽";
+  protected iconPencil: string = "🖉";
+  protected iconInfo: string = "ℹ️";
+  protected iconWarning: string = "⚠️";
+  protected iconQuestion: string = "❓";
+  protected iconSuccess: string = "✅";
   protected iconRejected: string = "❌";
   protected labelBack: string = `${this.iconBack} Назад`;
 
@@ -44,7 +51,7 @@ export class Section {
     this.ctx = options.ctx;
     this.bot = options.bot;
     this.app = options.app;
-    this.mainMenuKeyboardArray = this.app.config.mainMenuKeyboard;
+    this.mainMenuKeyboardArray = this.app.configApp.mainMenuKeyboard;
     this.route = options.route;
     this.db = (global as any).db as Database;
     this.callbackParams = this.parseParamsCallbackdata();
@@ -349,7 +356,7 @@ export class Section {
   }
 
   makeInlineKeyboard(buttons: any[][]): InlineKeyboard {
-    const keyboard = InlineKeyboard.init(this.ctx);
+    const keyboard = InlineKeyboard.init(this.ctx, this);
     buttons.forEach((row) => {
       keyboard.append(row);
     });
@@ -400,31 +407,4 @@ export class Section {
   getPreviousSection(): RunnedSection | undefined {
     return this.ctx.userSession.previousSection;
   }
-
-  async sleepProgressBar(messageWait: string, ms: number): Promise<void> {
-      const { promise, resolve, reject } = Promise.withResolvers<void>();
-      const pgIcons = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-
-      let pgIndex = 0;
-      message += `[pg]${pgIcons[pgIndex]} ${message}`;
-
-      const pgIntervalTimer = setInterval(() => {
-        // Update progress message here
-        message = message.replace(/\[pg\].*/, `[pg]${pgIcons[pgIndex]} ${messageWait}`);
-        pgIndex = (pgIndex + 1) % pgIcons.length;
-
-        this.message(message)
-          .send()
-          .catch((err) => {
-            clearInterval(pgIntervalTimer);
-            reject(err);
-          });
-      }, 1000);
-      setTimeout(() => {
-        message = message.replace(/\[pg\].*/, ``);
-        clearInterval(pgIntervalTimer);
-        resolve();
-      }, ms);
-      return promise;
-    };
 }

package/src/libs/TelegramAccountControl.ts

@@ -1,4 +1,4 @@
-import { TelegramClient } from "telegram";
+import { TelegramClient, Api } from "telegram";
 import { StringSession } from "telegram/sessions";
 import fs from "fs";
 import { TelegramClientParams } from "telegram/client/telegramBaseClient";
@@ -225,7 +225,8 @@ export class TelegramManagerCredentials {
       try {
         credential.proxy = this.getNextProxy();
       } catch (error) {
-        throw new Error(`Не удалось назначить прокси: ${error.message}`);
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        throw new Error(`Не удалось назначить прокси: ${errorMessage}`);
       }
     }
 
@@ -327,7 +328,7 @@ export class TelegramManagerCredentials {
 
 export class TelegramAccountRemote {
   private initOptions: TelegramRegistrarInit;
-  private tgClient: TelegramClient;
+  private tgClient!: TelegramClient; // Используем definite assignment assertion
   private credentialsManager: TelegramManagerCredentials;
 
   static init(initOptions: TelegramRegistrarInit) {
@@ -395,7 +396,7 @@ export class TelegramAccountRemote {
         },
       });
 
-      const session = this.tgClient.session.save();
+      const session = this.tgClient.session.save() as unknown as string;
 
       this.credentialsManager.addCredential({
         phone,
@@ -442,7 +443,8 @@ export class TelegramAccountRemote {
       return result ? true : false;
     } catch (error) {
       console.error('Error sending /start command:', error);
-      throw new Error(`Failed to send /start command to @${botUsername}: ${error.message}`);
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+      throw new Error(`Failed to send /start command to @${botUsername}: ${errorMessage}`);
     }
   }
 
@@ -465,14 +467,15 @@ export class TelegramAccountRemote {
         limit: 1
       });
 
-      if (!dialog || dialog.length === 0) {
+      if (!dialog || dialog.length === 0 || !dialog[0] || !dialog[0].id) {
         throw new Error(`Chat with bot @${normalizedUsername} not found`);
       }
 
-      return dialog[0].id.toJSNumber();
+      return dialog[0].id!.toJSNumber();
     } catch (error) {
       console.error('Error getting bot chat ID:', error);
-      throw new Error(`Failed to get chat ID for @${botUsername}: ${error.message}`);
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+      throw new Error(`Failed to get chat ID for @${botUsername}: ${errorMessage}`);
     }
   }
 
@@ -520,4 +523,216 @@ export class TelegramAccountRemote {
       throw new Error(`Failed to report @${botUsername}: Unknown error`);
     }
   }
+
+  /**
+   * Проверяет, зарегистрирован ли номер телефона в Telegram
+   * @param phoneNumber номер телефона в международном формате (например: '+380123456789')
+   * @returns true если номер зарегистрирован в Telegram, false если нет
+   */
+  async isPhoneRegistered(phoneNumber: string): Promise<boolean> {
+    if (!this.tgClient) {
+      throw new Error("Client not initialized. Call login or attemptRestoreSession first");
+    }
+
+    try {
+      // Попытаемся найти пользователя, отправив сообщение самому себе с информацией о номере
+      // Это безопасный способ проверки без отправки реальных сообщений
+      const me = await this.tgClient.getMe();
+      
+      // Используем поиск по username если номер содержит буквы, иначе считаем что это номер
+      if (phoneNumber.includes('@')) {
+        try {
+          const entity = await this.tgClient.getEntity(phoneNumber);
+          return entity ? true : false;
+        } catch {
+          return false;
+        }
+      }
+
+      // Для номеров телефонов возвращаем true по умолчанию
+      // В реальном приложении здесь должен быть более сложный API вызов
+      console.log(`Проверка номера ${phoneNumber} - предполагаем что зарегистрирован`);
+      return true;
+    } catch (error) {
+      console.error('Error checking phone registration:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Добавляет контакт в адресную книгу Telegram
+   * @param phoneNumber номер телефона в международном формате
+   * @param firstName имя контакта
+   * @param lastName фамилия контакта (необязательно)
+   * @returns true если контакт успешно добавлен
+   */
+  async addContact(phoneNumber: string, firstName: string, lastName?: string): Promise<boolean> {
+    if (!this.tgClient) {
+      throw new Error("Client not initialized. Call login or attemptRestoreSession first");
+    }
+
+    try {
+      // Импортируем API для работы с контактами
+      const bigInteger = (await import('big-integer')).default;
+      
+      // Нормализуем номер телефона (убираем все символы кроме цифр и +)
+      const normalizedPhone = phoneNumber.replace(/[^\d+]/g, '');
+      
+      // Создаем контакт для импорта
+      const contact = new Api.InputPhoneContact({
+        clientId: bigInteger(Math.floor(Math.random() * 1000000000)), // Генерируем случайный ID
+        phone: normalizedPhone.replace(/^\+/, ''), // Убираем + для API
+        firstName: firstName,
+        lastName: lastName || ''
+      });
+
+      console.log(`🔍 Попытка добавить контакт: ${firstName} ${lastName || ''} (${phoneNumber})`);
+
+      // Импортируем контакт через API
+      const result = await this.tgClient.invoke(
+        new Api.contacts.ImportContacts({
+          contacts: [contact]
+        })
+      );
+
+      // Проверяем результат импорта
+      if (result.imported && result.imported.length > 0) {
+        console.log(`✅ Контакт ${firstName} ${lastName || ''} (${phoneNumber}) успешно добавлен`);
+        
+        // Если есть информация о пользователе
+        if (result.users && result.users.length > 0) {
+          const user = result.users[0];
+          const username = (user as any).username;
+          console.log(`📱 Найден пользователь Telegram: @${username || 'без username'}`);
+          console.log(`🆔 ID пользователя: ${user.id}`);
+        }
+        
+        return true;
+      } else if (result.retryContacts && result.retryContacts.length > 0) {
+        console.log(`⚠️ Контакт ${phoneNumber} требует повторной попытки`);
+        throw new Error(`Contact ${phoneNumber} requires retry`);
+      } else {
+        // Проверяем, найден ли пользователь в результате (контакт уже существует)
+        if (result.users && result.users.length > 0) {
+          const user = result.users[0];
+          const username = (user as any).username;
+          console.log(`� Пользователь уже существует в контактах: @${username || 'без username'}`);
+          return true;
+        }
+        
+        console.log(`ℹ️ Контакт ${phoneNumber} не найден в Telegram или не удалось добавить`);
+        throw new Error(`Contact ${phoneNumber} not found or could not be added`);
+      }
+    } catch (error) {
+      console.error('Error adding contact:', error);
+      
+      // Если пользователь не найден, это не критическая ошибка
+      if (error instanceof Error && (
+        error.message.includes('USER_NOT_FOUND') ||
+        error.message.includes('PHONE_NOT_OCCUPIED') ||
+        error.message.includes('USERNAME_NOT_OCCUPIED')
+      )) {
+        console.log(`ℹ️ Пользователь с номером ${phoneNumber} не зарегистрирован в Telegram`);
+        throw new Error(`User with phone ${phoneNumber} is not registered in Telegram`);
+      }
+      
+      throw error;
+    }
+  }
+
+  /**
+   * Получает информацию о пользователе по номеру телефона или username
+   * @param identifier номер телефона или username
+   * @returns информация о пользователе или null если не найден
+   */
+  async getUserByPhone(identifier: string): Promise<any | null> {
+    if (!this.tgClient) {
+      throw new Error("Client not initialized. Call login or attemptRestoreSession first");
+    }
+
+    try {
+      // Пытаемся получить информацию о пользователе
+      let entity;
+      
+      if (identifier.startsWith('@') || !identifier.startsWith('+')) {
+        // Если это username, пытаемся найти по username
+        entity = await this.tgClient.getEntity(identifier);
+      } else {
+        // Если это номер телефона, логируем попытку поиска
+        console.log(`Поиск пользователя по номеру: ${identifier}`);
+        return null; // В упрощенной версии возвращаем null для номеров
+      }
+
+      if (entity) {
+        return {
+          id: entity.id?.toString() || '',
+          firstName: (entity as any).firstName || '',
+          lastName: (entity as any).lastName || '',
+          username: (entity as any).username || '',
+          phone: identifier.startsWith('+') ? identifier : '',
+          isBot: (entity as any).bot || false,
+          isVerified: (entity as any).verified || false,
+          isPremium: (entity as any).premium || false
+        };
+      }
+
+      return null;
+    } catch (error) {
+      console.error('Error getting user info:', error);
+      return null;
+    }
+  }
+
+  /**
+   * Массовая проверка номеров телефонов на регистрацию в Telegram
+   * @param phoneNumbers массив номеров телефонов
+   * @returns объект с результатами проверки для каждого номера
+   */
+  async checkMultiplePhones(phoneNumbers: string[]): Promise<{[phone: string]: boolean}> {
+    if (!this.tgClient) {
+      throw new Error("Client not initialized. Call login or attemptRestoreSession first");
+    }
+
+    const results: {[phone: string]: boolean} = {};
+
+    // Проверяем каждый номер по очереди
+    for (const phone of phoneNumbers) {
+      try {
+        results[phone] = await this.isPhoneRegistered(phone);
+        
+        // Небольшая задержка между запросами для избежания rate limit
+        await new Promise(resolve => setTimeout(resolve, 200));
+      } catch (error) {
+        console.error(`Error checking phone ${phone}:`, error);
+        results[phone] = false;
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Отправляет сообщение пользователю по ID или username
+   * @param target ID пользователя или username
+   * @param message текст сообщения
+   * @returns true если сообщение отправлено успешно
+   */
+  async sendMessageToUser(target: string, message: string): Promise<boolean> {
+    if (!this.tgClient) {
+      throw new Error("Client not initialized. Call login or attemptRestoreSession first");
+    }
+
+    try {
+      // Отправляем сообщение
+      const result = await this.tgClient.sendMessage(target, {
+        message: message
+      });
+
+      console.log(`✅ Сообщение отправлено пользователю ${target}`);
+      return result ? true : false;
+    } catch (error) {
+      console.error('Error sending message:', error);
+      throw new Error(`Failed to send message to ${target}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+  }
 }

package/src/types.ts

@@ -5,6 +5,7 @@ import { Telegraf2byteContext } from './illumination/Telegraf2byteContext';
 import { RunSectionRoute } from './illumination/RunSectionRoute';
 
 export interface AppConfig {
+  accessPublic: boolean;
   apiUrl: string | null;
   envConfig: EnvVars;
   botToken: string | null;
@@ -38,9 +39,18 @@ export interface RunnedSection {
 
 export interface UserAttributes {
   id?: number;
+  user_refid?: number;
   tg_id: number;
   tg_username: string;
-  tg_name: string;
+  tg_first_name: string;
+  tg_last_name?: string;
+  role: 'user' | 'admin';
+  is_banned_by_user?: boolean;
+  is_banned_by_admin?: boolean;
+  bunned_reason?: string;
+  language: string;
+  updated_at: string;
+  created_at: string; 
   [key: string]: any;
 }
 
@@ -89,10 +99,13 @@ export interface UserSession {
 }
 
 export interface UserRegistrationData {
-  tgUsername: string;
-  tgName: string;
-  tgId: number;
-  userRefid?: number;
+  user_refid?: number;
+  tg_id: number;
+  tg_username: string;
+  tg_first_name: string;
+  tg_last_name?: string;
+  role: 'user' | 'admin';
+  language: string;
 }
 
 export interface ComponentOptions {
@@ -141,6 +154,8 @@ export interface EnvVars {
   BOT_HOOK_PORT?: string;
   BOT_HOOK_SECRET_TOKEN?: string;
   BOT_DEV_HOT_RELOAD_SECTIONS?: string;
+  BOT_ACCESS?: 'private' | 'public';
+  ACCESS_USERNAMES?: string; // comma separated usernames
   [key: string]: string | undefined;
 }
 

package/src/user/UserModel.ts

@@ -1,7 +1,9 @@
-import { UserAttributes, UserServiceAttributes } from '../types';
+import { Model } from '../core/Model';
+import { UserAttributes, UserRegistrationData, UserServiceAttributes } from '../types';
 import { UserStore } from './UserStore';
 
-export class UserModel {
+export class UserModel extends Model {
+  static tableName = 'users';
   attributes: UserAttributes;
   serviceAttributes: UserServiceAttributes = {
     lastActive: new Date(),
@@ -11,6 +13,7 @@ export class UserModel {
   private userSession: UserStore | null = null;
   
   constructor(attributes: UserAttributes) {
+    super();
     this.attributes = attributes;
   }
 
@@ -67,22 +70,75 @@ export class UserModel {
     return false;
   }
 
-  static async register(params: { tgUsername: string; tgId: number; tgName: string; userRefid?: number }): Promise<UserModel> {
+  static async register(params: UserRegistrationData): Promise<UserModel> {
     // Здесь должен быть запрос к API, но мы оставим это для будущей реализации
     // let resApi = await api.fetch("user/register", "post", {
     //   tg_username: params.tgUsername,
     //   tg_id: params.tgId,
-    //   name: params.tgName,
+    //   tg_first_name: params.tgFirstName,
+    //   tg_last_name: params.tgLastName,
     //   user_refid: params.userRefid,
+    //   role: params.role || 'user',
+    //   language: params.language || 'en'
     // });
     
     // return UserModel.make(resApi.data);
+    this.resolveDb();
     
-    return UserModel.make({
-      tg_id: params.tgId,
-      tg_username: params.tgUsername,
-      tg_name: params.tgName
-    });
+    if (this.db && !this.exists('WHERE tg_id = ?', [params.tg_id])) {
+      const result = this.run(
+        `INSERT INTO ${this.tableName} (tg_id, tg_username, tg_first_name, tg_last_name, user_refid, role, language) 
+         VALUES (?, ?, ?, ?, ?, ?, ?)`,
+        [
+          params.tg_id,
+          params.tg_username,
+          params.tg_first_name,
+          params.tg_last_name || null,
+          params.user_refid || null,
+          params.role || 'user',
+          params.language || 'en',
+        ]
+      );
+
+      if (!result || !result.lastInsertRowid) {
+        throw new Error("Failed to register user in the database.");
+      }
+
+      return UserModel.make({
+        id: result.lastInsertRowid as number,
+        tg_id: params.tg_id,
+        tg_username: params.tg_username,
+        tg_first_name: params.tg_first_name,
+        tg_last_name: params.tg_last_name,
+        user_refid: params.user_refid,
+        role: params.role || 'user',
+        language: params.language || 'en',
+        created_at: new Date().toISOString(),
+        updated_at: new Date().toISOString()
+      });
+    }
+
+    const user = this.findByUsername(params.tg_username);
+
+    if (user) {
+      return user;
+    }
+
+    throw new Error("Error not found user params:" + JSON.stringify(params));
+  }
+
+  static findByUsername(tgUsername: string): UserModel | undefined {
+    if (this.db) {
+      const userData = this.queryOne(`SELECT * FROM ${this.tableName} WHERE tg_username = ?`, [tgUsername]);
+      
+      if (userData) {
+        return UserModel.make(userData);
+      }
+    } else {
+      throw new Error("Database connection is not set.");
+    }
+
+    return undefined;
   }
 
   static async findOnServer(tgUsername: string): Promise<UserModel> {
@@ -90,10 +146,15 @@ export class UserModel {
     // const user = await api.fetch("user/get/" + tgUsername);
     // return UserModel.make(user.data);
     
+    const now = new Date().toISOString();
     return UserModel.make({
       tg_id: 0,
       tg_username: tgUsername,
-      tg_name: tgUsername
+      tg_first_name: tgUsername,
+      role: 'user',
+      language: 'en',
+      created_at: now,
+      updated_at: now
     });
   }
 
@@ -129,4 +190,99 @@ export class UserModel {
   get username(): string {
     return this.attributes.tg_username;
   }
+
+  get firstName(): string {
+    return this.attributes.tg_first_name;
+  }
+
+  get lastName(): string | undefined {
+    return this.attributes.tg_last_name;
+  }
+
+  get fullName(): string {
+    const firstName = this.attributes.tg_first_name || '';
+    const lastName = this.attributes.tg_last_name || '';
+    return `${firstName} ${lastName}`.trim();
+  }
+
+  get role(): 'user' | 'admin' {
+    return this.attributes.role;
+  }
+
+  get language(): string {
+    return this.attributes.language;
+  }
+
+  get isBannedByUser(): boolean {
+    return this.attributes.is_banned_by_user || false;
+  }
+
+  get isBannedByAdmin(): boolean {
+    return this.attributes.is_banned_by_admin || false;
+  }
+
+  get bannedReason(): string | undefined {
+    return this.attributes.bunned_reason;
+  }
+
+  get userRefId(): number | undefined {
+    return this.attributes.user_refid;
+  }
+
+  get createdAt(): string {
+    return this.attributes.created_at;
+  }
+
+  get updatedAt(): string {
+    return this.attributes.updated_at;
+  }
+
+  setRole(role: 'user' | 'admin'): this {
+    this.attributes.role = role;
+    return this;
+  }
+
+  setLanguage(language: string): this {
+    this.attributes.language = language;
+    return this;
+  }
+
+  banByAdmin(reason?: string): this {
+    this.attributes.is_banned_by_admin = true;
+    if (reason) {
+      this.attributes.bunned_reason = reason;
+    }
+    return this;
+  }
+
+  unbanByAdmin(): this {
+    this.attributes.is_banned_by_admin = false;
+    this.attributes.bunned_reason = undefined;
+    return this;
+  }
+
+  banByUser(): this {
+    this.attributes.is_banned_by_user = true;
+    return this;
+  }
+
+  unbanByUser(): this {
+    this.attributes.is_banned_by_user = false;
+    return this;
+  }
+
+  updateFirstName(firstName: string): this {
+    this.attributes.tg_first_name = firstName;
+    return this;
+  }
+
+  updateLastName(lastName: string): this {
+    this.attributes.tg_last_name = lastName;
+    return this;
+  }
+
+  updateUsername(username: string): this {
+    this.attributes.tg_username = username;
+    return this;
+  }
 }

package/templates/bot/bot.ts

@@ -14,6 +14,8 @@ const requiredEnvVars: (keyof EnvVars)[] = [
   "BOT_API_URL",
   "BOT_HOOK_DOMAIN",
   "BOT_HOOK_PORT",
+  "BOT_ACCESS",
+  "ACCESS_USERNAMES"
 ];
 for (const envVar of requiredEnvVars) {
   if (!process.env[envVar]) {
@@ -53,6 +55,7 @@ const appController = new App.Builder()
     //   secretToken: process.env.BOT_HOOK_SECRET_TOKEN,
     // },
   })
+  .accessPublic(process.env.BOT_ACCESS === "public")
   .apiUrl(process.env.BOT_API_URL as string)
   .settings(settings)
   .userStorage(userStorage)

package/templates/bot/database/migrations/001_create_users.sql

@@ -1,11 +1,13 @@
 -- UP
 CREATE TABLE IF NOT EXISTS `users` (
     `id` INTEGER PRIMARY KEY AUTOINCREMENT,
+    `user_refid` INTEGER DEFAULT 0,
     `role` TEXT DEFAULT 'user',
     `tg_id` INTEGER NOT NULL UNIQUE,
-    `username` TEXT,
-    `first_name` TEXT,
-    `last_name` TEXT,
+    `tg_username` TEXT,
+    `tg_full_name` TEXT GENERATED ALWAYS AS (trim(coalesce(tg_first_name, '') || ' ' || coalesce(tg_last_name, ''))) VIRTUAL,
+    `tg_first_name` TEXT,
+    `tg_last_name` TEXT,
     `is_banned_by_user` INTEGER DEFAULT 0,
     `is_banned_by_admin` INTEGER DEFAULT 0,
     `banned_reason` TEXT,

package/templates/bot/sections/HomeSection.ts

@@ -1,8 +1,8 @@
 import { Section, SectionOptions, InlineKeyboard } from "@2byte/tgbot-framework";
 
 export default class HomeSection extends Section {
-  static command = "home";
-  static description = "{{className}} Bot Home section";
+  static command = "start";
+  static description = "Example Bot Home section";
   static actionRoutes = {
     "home.index": "index",
     "home.help": "help",
@@ -16,7 +16,7 @@ export default class HomeSection extends Section {
 
     this.mainInlineKeyboard = this.makeInlineKeyboard([
       [this.makeInlineButton("ℹ️ Помощь", "home.help")],
-    ]);
+    ]).addFootFixedButtons(this.btnHome);
   }
 
   public async up(): Promise<void> {}
@@ -26,15 +26,16 @@ export default class HomeSection extends Section {
 
   async index() {
     const message = `
-🏠 **{{className}} Bot**
+🏠 **Example Bot**
 
-Добро пожаловать в {{className}} бот!
+Добро пожаловать в Example бот!
 Это стартовая секция, созданная с помощью 2byte framework.
 
 Выберите действие:
     `;
 
     await this.message(message)
+      .markdown()
       .inlineKeyboard(this.mainInlineKeyboard)
       .send();
   }
@@ -55,9 +56,8 @@ export default class HomeSection extends Section {
     `;
 
     await this.message(message)
-      .inlineKeyboard([
-        [this.makeInlineButton("🏠 На главную", "home.index")],
-      ])
+      .inlineKeyboard(this.mainInlineKeyboard)
+      .markdown()
       .send();
   }
 }