@2byte/tgbot-framework 1.0.0

package/src/user/UserModel.ts

@@ -0,0 +1,132 @@
+import { UserAttributes, UserServiceAttributes } from '../types';
+import { UserStore } from './UserStore';
+
+export class UserModel {
+  attributes: UserAttributes;
+  serviceAttributes: UserServiceAttributes = {
+    lastActive: new Date(),
+    lastMessageIds: [],
+  };
+
+  private userSession: UserStore | null = null;
+  
+  constructor(attributes: UserAttributes) {
+    this.attributes = attributes;
+  }
+
+  setSessionStorage(storage: UserStore): this {
+    this.userSession = storage;
+    return this;
+  }
+
+  upActive(): void {
+    this.serviceAttributes.lastActive = new Date();
+  }
+
+  storeMessageId(messageId: number, limit: number): this {
+    if (this.serviceAttributes.lastMessageIds.indexOf(messageId) === -1) {
+      this.serviceAttributes.lastMessageIds.push(messageId);
+    }
+
+    if (this.serviceAttributes.lastMessageIds.length > limit) {
+      this.serviceAttributes.lastMessageIds.shift();
+    }
+
+    return this;
+  }
+
+  getAttributes(): UserAttributes {
+    return this.attributes;
+  }
+
+  get id(): number | undefined {
+    return this.attributes.id;
+  }
+
+  get lastMessageIds(): number[] {
+    return this.serviceAttributes.lastMessageIds;
+  }
+
+  get lastMessageId(): number | undefined {
+    const ids = this.serviceAttributes.lastMessageIds;
+    return ids.length ? ids[ids.length - 1] : undefined;
+  }
+
+  removeMessageId(messageId: number): this {
+    const index = this.serviceAttributes.lastMessageIds.indexOf(messageId);
+    if (index !== -1) {
+      this.serviceAttributes.lastMessageIds.splice(index, 1);
+    }
+    return this;
+  }
+
+  static async existsOnServer(tgUsername: string, tgId: number): Promise<boolean> {
+    // Здесь должен быть запрос к API, но мы оставим это для будущей реализации
+    // const user = await api.fetch("user/get/" + tgUsername + "/" + tgId);
+    // return !user.error;
+    return false;
+  }
+
+  static async register(params: { tgUsername: string; tgId: number; tgName: string; userRefid?: number }): Promise<UserModel> {
+    // Здесь должен быть запрос к API, но мы оставим это для будущей реализации
+    // let resApi = await api.fetch("user/register", "post", {
+    //   tg_username: params.tgUsername,
+    //   tg_id: params.tgId,
+    //   name: params.tgName,
+    //   user_refid: params.userRefid,
+    // });
+    
+    // return UserModel.make(resApi.data);
+    
+    return UserModel.make({
+      tg_id: params.tgId,
+      tg_username: params.tgUsername,
+      tg_name: params.tgName
+    });
+  }
+
+  static async findOnServer(tgUsername: string): Promise<UserModel> {
+    // Здесь должен быть запрос к API, но мы оставим это для будущей реализации
+    // const user = await api.fetch("user/get/" + tgUsername);
+    // return UserModel.make(user.data);
+    
+    return UserModel.make({
+      tg_id: 0,
+      tg_username: tgUsername,
+      tg_name: tgUsername
+    });
+  }
+
+  async refresh(): Promise<boolean> {
+    if (this.userSession) {
+      return this.userSession.add(
+        this.attributes.tg_username,
+        await UserModel.findOnServer(this.attributes.tg_username)
+      );
+    }
+    return false;
+  }
+
+  async refreshAttributes(): Promise<this> {
+    this.attributes = (await UserModel.findOnServer(this.attributes.tg_username)).attributes;
+    return this;
+  }
+
+  static make(attributes: UserAttributes): UserModel {
+    return new UserModel(attributes);
+  }
+
+  static errorHandler(error: any, metaInfo?: any): void {
+    if (error instanceof Error) {
+      if (metaInfo) {
+        console.error("Error addons:", metaInfo);
+      }
+
+      throw error;
+    }
+  }
+
+  get username(): string {
+    return this.attributes.tg_username;
+  }
+}

package/src/user/UserStore.ts

@@ -0,0 +1,119 @@
+import { UserModel } from './UserModel';
+import { UserSession } from '../types';
+import { EnvVars } from '../types';
+
+interface ApiConfig {
+  apiUrl: string;
+}
+
+interface Api {
+  fetch(endpoint: string, method?: string, data?: any): Promise<any>;
+}
+
+export class UserStore {
+  private usersMap: Map<string, UserModel> = new Map();
+  private usersSession: Map<UserModel, UserSession> = new Map();
+  private api: Api | null = null;
+
+  constructor(envConfig?: EnvVars) {
+    if (envConfig) {
+      let url = envConfig.BOT_API_URL || '';
+      
+      // Здесь должна быть инициализация API, но мы оставим это для будущей реализации
+      // this.api = new Api({
+      //   apiUrl: url.endsWith('/') ? url : url + '/',
+      // });
+    }
+  }
+
+  async checkOrRegister(params: { tgUsername: string, tgId: number, tgName: string }): Promise<any> {
+    if (!this.usersMap.has(params.tgUsername) && this.api) {
+      let userData = null;
+
+      try {
+        let resApi = await this.api.fetch('user/get/' + params.tgUsername);
+        userData = resApi.data;
+      } catch (err) {
+        let resApi = await this.api.fetch('user/register', 'post', {
+          tg_username: params.tgUsername,
+          tg_id: params.tgId,
+          name: params.tgName,
+        });
+
+        userData = resApi.data;
+      }
+
+      if (userData !== null) {
+        this.add(params.tgUsername, userData);
+      }
+
+      return userData;
+    }
+    return null;
+  }
+
+  find(tgUsername: string): UserModel {
+    return this.usersMap.get(tgUsername) as UserModel;
+  }
+
+  findSession(userModel: UserModel): UserSession {
+    return this.usersSession.get(userModel) || {};
+  }
+
+  exists(tgUsername: string): boolean {
+    return this.usersMap.has(tgUsername);
+  }
+
+  add(tgUsername: string, data: UserModel | any): boolean {
+    if (data instanceof UserModel) {
+      this.usersMap.set(tgUsername, data);
+    } else {
+      this.usersMap.set(tgUsername, new UserModel(data));
+    }
+    
+    this.usersSession.set(this.usersMap.get(tgUsername) as UserModel, {});
+
+    return true;
+  }
+
+  upActive(tgUsername: string): this {
+    const user = this.usersMap.get(tgUsername);
+    if (user) {
+      user.upActive();
+    }
+    return this;
+  }
+
+  storeMessageId(tgUsername: string, messageId: number, limit: number): this {
+    const user = this.usersMap.get(tgUsername);
+    if (user) {
+      user.storeMessageId(messageId, limit);
+    }
+    return this;
+  }
+
+  getLastMessageId(tgUsername: string): number | undefined {
+    const user = this.usersMap.get(tgUsername);
+    if (user) {
+      const ids = user.lastMessageIds;
+      return ids.length ? ids[ids.length - 1] : undefined;
+    }
+    return undefined;
+  }
+
+  autocleanup(minutes: number = 1): void {
+    const getNotActiveUsers = (): [string, UserModel][] => {
+      return Array.from(this.usersMap).filter(([tgUsername, data]) => {
+        return (
+          data.serviceAttributes.lastActive.getTime() <= Date.now() - minutes * 60 * 1000
+        );
+      });
+    };
+
+    setInterval(() => {
+      getNotActiveUsers().forEach(([tgUsername]) => {
+        this.usersMap.delete(tgUsername);
+      });
+    }, 60 * 1000);
+  }
+}

package/templates/bot/.env.example

@@ -0,0 +1,18 @@
+# Переменные окружения для {{className}} Bot
+
+# Токен бота от @BotFather
+BOT_TOKEN=your_bot_token_here
+
+# Путь к базе данных
+DATABASE_PATH=./database/database.sqlite
+
+# Настройки логирования
+LOG_LEVEL=info
+
+BOT_API_URL=https://localhost:3000
+APP_ENV=local
+BOT_DEV_HOT_RELOAD_SECTIONS=true
+BOT_ACCESS=public
+ACCESS_USERNAMES=stork0
+BOT_HOOK_DOMAIN=example.com
+BOT_HOOK_PORT=3000

package/templates/bot/artisan.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { BotArtisan } from '@2byte/tgbot-framework';
+
+const artisan = new BotArtisan(__dirname, {
+  botName: '{{botName}}',
+  sectionsPath: './sections'
+});
+
+artisan.run();

package/templates/bot/bot.ts

@@ -0,0 +1,74 @@
+import { App } from '@2byte/tgbot-framework';
+import { UserStore } from "@2byte/tgbot-framework";
+import { sectionList } from "./sectionList";
+import { Database } from 'bun:sqlite';
+import { EnvVars } from "@2byte/tgbot-framework";
+
+if (import.meta.dirname === undefined) {
+  throw new Error("import.meta.dirname is not defined. Ensure you are using a module environment.");
+}
+
+// check if the environment is set up correctly
+const requiredEnvVars: (keyof EnvVars)[] = [
+  "BOT_TOKEN",
+  "BOT_API_URL",
+  "BOT_HOOK_DOMAIN",
+  "BOT_HOOK_PORT",
+];
+for (const envVar of requiredEnvVars) {
+  if (!process.env[envVar]) {
+    throw new Error(`${envVar} is not set in the environment variables.`);
+  }
+}
+
+declare global {
+  var userStorage: UserStore;
+  var db: Database;
+  var settings: Record<string, any>;
+}
+
+// Initialize global variables
+global.userStorage = new UserStore(process.env as EnvVars);
+global.db = new Database(import.meta.dirname +'/database/database.sqlite');
+global.settings = {
+  paging: {
+    taskListPerPage: 3, // Number items per page
+  }
+};
+
+// Autoclean storage user by timeout
+userStorage.autocleanup(10);
+
+const appController = new App.Builder()
+  .envConfig(process.env as EnvVars)
+  .botToken(process.env.BOT_TOKEN as string)
+  .telegrafConfigLaunch({
+    // webhook: {
+    //   // Public domain for webhook; e.g.: example.com
+    //   domain: process.env.BOT_HOOK_DOMAIN,
+    //   // Port to listen on; e.g.: 8080
+    //   port: +process.env.BOT_HOOK_PORT,
+    //   // Path to listen on nginx
+    //   path: "/super-mega-tgbot",
+    //   secretToken: process.env.BOT_HOOK_SECRET_TOKEN,
+    // },
+  })
+  .apiUrl(process.env.BOT_API_URL as string)
+  .settings(settings)
+  .userStorage(userStorage)
+  .sections(sectionList)
+  .keepSectionInstances(true)
+  .debug()
+  //.telegrafLog()
+  .devHotReloadSections(process.env.BOT_DEV_HOT_RELOAD_SECTIONS === "true")
+  .mainMenuKeyboard([
+    ["🏠 Лобби"],
+  ])
+  .hears({
+    "🏠 Лобби": "home",
+  })      
+  .terminateSigInt()
+  .terminateSigTerm()
+  .build();
+
+(await appController.init()).launch();

package/templates/bot/database/dbConnector.ts

@@ -0,0 +1,5 @@
+import { Database } from 'bun:sqlite';
+
+export default () => {
+    return new Database(import.meta.dirname + '/database.sqlite');
+}

package/templates/bot/database/migrate.ts

@@ -0,0 +1,10 @@
+import { BotMigration } from '@2byte/tgbot-framework';
+import path from 'path';
+
+const migration = new BotMigration({
+  botPath: __dirname,
+  migrationsPath: path.join(__dirname, 'migrations'),
+  databasePath: path.join(__dirname, 'database.sqlite')
+});
+
+migration.run();

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

@@ -0,0 +1,17 @@
+-- UP
+CREATE TABLE IF NOT EXISTS `users` (
+    `id` INTEGER PRIMARY KEY AUTOINCREMENT,
+    `role` TEXT DEFAULT 'user',
+    `tg_id` INTEGER NOT NULL UNIQUE,
+    `username` TEXT,
+    `first_name` TEXT,
+    `last_name` TEXT,
+    `is_banned_by_user` INTEGER DEFAULT 0,
+    `is_banned_by_admin` INTEGER DEFAULT 0,
+    `banned_reason` TEXT,
+    `language` TEXT DEFAULT 'en',
+    `updated_at` TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    `created_at` TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+    );
+-- DOWN
+DROP TABLE IF EXISTS `users`;

package/templates/bot/database/seed.ts

@@ -0,0 +1,15 @@
+import { BotSeeder } from '@2byte/tgbot-framework';
+import path from 'path';
+
+// Импортируйте здесь ваши сидеры
+// import { seedUsers } from './seeds/users';
+
+const seeder = new BotSeeder({
+  botPath: __dirname,
+  databasePath: path.join(__dirname, 'database.sqlite'),
+  seeders: [
+    // seedUsers,
+  ]
+});
+
+seeder.run();

package/templates/bot/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "{{kebabName}}",
+  "version": "1.0.0",
+  "description": "{{description}}",
+  "main": "bot.ts",
+  "scripts": {
+    "dev": "bun --watch bot.ts",
+    "start": "bun bot.ts",
+    "build": "bun build bot.ts --outdir ./dist",
+    "migrate": "bun database/migrate.ts",
+    "artisan": "bun artisan.ts",
+    "seed": "bun database/seed.ts",
+    "seed:clear": "bun database/seed.ts --clear",
+    "seed:clean": "bun database/seed.ts --clean-only"
+  },
+  "keywords": [
+    "telegram",
+    "bot",
+    "2byte"
+  ],
+  "author": "{{author}}",
+  "license": "MIT",
+  "dependencies": {
+    "@2byte/tgbot-framework": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.19.8",
+    "bun-types": "^1.2.18",
+    "typescript": "^5.8.3"
+  }
+}

package/templates/bot/sectionList.ts

@@ -0,0 +1,7 @@
+import { SectionEnabledList, SectionList } from "2bytetgbot";
+
+export const sectionList: SectionList = {
+    home: {},   
+}
+
+export const enabledList: SectionEnabledList = Object.keys(sectionList);

package/templates/bot/sections/HomeSection.ts

@@ -0,0 +1,63 @@
+import { Section, SectionOptions, InlineKeyboard } from "@2byte/tgbot-framework";
+
+export default class HomeSection extends Section {
+  static command = "home";
+  static description = "{{className}} Bot Home section";
+  static actionRoutes = {
+    "home.index": "index",
+    "home.help": "help",
+  };
+  
+  public sectionId = "home";
+  private mainInlineKeyboard: InlineKeyboard;
+
+  constructor(options: SectionOptions) {
+    super(options);
+
+    this.mainInlineKeyboard = this.makeInlineKeyboard([
+      [this.makeInlineButton("ℹ️ Помощь", "home.help")],
+    ]);
+  }
+
+  public async up(): Promise<void> {}
+  public async down(): Promise<void> {}
+  public async setup(): Promise<void> {}
+  public async unsetup(): Promise<void> {}
+
+  async index() {
+    const message = `
+🏠 **{{className}} Bot**
+
+Добро пожаловать в {{className}} бот!
+Это стартовая секция, созданная с помощью 2byte framework.
+
+Выберите действие:
+    `;
+
+    await this.message(message)
+      .inlineKeyboard(this.mainInlineKeyboard)
+      .send();
+  }
+
+  async help() {
+    const message = `
+ℹ️ **Помощь**
+
+Это бот, созданный с помощью 2byte Telegram Bot Framework.
+
+Доступные команды:
+• /start - Главное меню
+
+Для разработчиков:
+• bun run artisan make:section <name> - Создать секцию
+• bun run migrate - Выполнить миграции
+• bun run seed - Заполнить данными
+    `;
+
+    await this.message(message)
+      .inlineKeyboard([
+        [this.makeInlineButton("🏠 На главную", "home.index")],
+      ])
+      .send();
+  }
+}