@2byte/tgbot-framework 1.0.0 → 1.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@2byte/tgbot-framework",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "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,80 @@
+import type { Database } from "bun:sqlite";
+import { MakeManualPaginateButtonsParams, ModelPaginateParams, PaginateResult } from "../types";
+import { Section } from "../illumination/Section";
+
+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/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/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,7 +1,7 @@
 import { Section, SectionOptions, InlineKeyboard } from "@2byte/tgbot-framework";
 
 export default class HomeSection extends Section {
-  static command = "home";
+  static command = "start";
   static description = "{{className}} Bot Home section";
   static actionRoutes = {
     "home.index": "index",
@@ -35,6 +35,7 @@ export default class HomeSection extends Section {
     `;
 
     await this.message(message)
+      .markdown()
       .inlineKeyboard(this.mainInlineKeyboard)
       .send();
   }
@@ -55,6 +56,7 @@ export default class HomeSection extends Section {
     `;
 
     await this.message(message)
+      .markdown()
       .inlineKeyboard([
         [this.makeInlineButton("🏠 На главную", "home.index")],
       ])