@2byte/tgbot-framework 1.0.0

package/src/core/BotArtisan.ts

@@ -0,0 +1,80 @@
+import * as path from 'path';
+import chalk from 'chalk';
+import { Artisan } from '../illumination/Artisan';
+
+export interface BotArtisanOptions {
+  botName: string;
+  sectionsPath?: string;
+}
+
+export class BotArtisan {
+  private artisan: Artisan;
+  private options: BotArtisanOptions;
+
+  constructor(botPath: string, options: BotArtisanOptions) {
+    this.options = options;
+    this.artisan = new Artisan(botPath);
+  }
+
+  async run(): Promise<void> {
+    const command = process.argv[2];
+    const args = process.argv.slice(3);
+
+    if (!command) {
+      this.showHelp();
+      return;
+    }
+
+    try {
+      switch (command) {
+        case 'make:section':
+          if (args.length === 0) {
+            console.error(chalk.red('❌ Error: Section name is required'));
+            console.log('Usage: artisan make:section SectionName');
+            return;
+          }
+          await this.artisan.createSection(args[0]);
+          break;
+
+        case 'add:method':
+          if (args.length < 2) {
+            console.error(chalk.red('❌ Error: Section name and method name are required'));
+            console.log('Usage: artisan add:method SectionName methodName');
+            return;
+          }
+          await this.artisan.addMethod(args[0], args[1]);
+          break;
+
+        case 'list:sections':
+          await this.artisan.listSections();
+          break;
+
+        default:
+          console.error(chalk.red(`❌ Unknown command: ${command}`));
+          this.showHelp();
+      }
+    } catch (error) {
+      if (error instanceof Error) {
+        console.error(chalk.red(`❌ Error: ${error.message}`));
+      } else {
+        console.error(chalk.red('❌ An unknown error occurred'));
+      }
+    }
+  }
+
+  private showHelp(): void {
+    console.log(`
+🔧 ${this.options.botName} Artisan CLI
+
+Available commands:
+  make:section <name>           Create a new section
+  add:method <section> <name>   Add a new method to existing section
+  list:sections                 List all sections
+
+Examples:
+  artisan make:section Auth     Create new AuthSection
+  artisan add:method Auth login Add login method to AuthSection
+  artisan list:sections        Show all available sections
+`);
+  }
+}

package/src/core/BotMigration.ts

@@ -0,0 +1,31 @@
+import * as path from 'path';
+import chalk from 'chalk';
+import { setupMigrations } from '../console/migrate';
+
+export interface BotMigrationOptions {
+  botPath: string;
+  migrationsPath: string;
+  databasePath: string;
+}
+
+export class BotMigration {
+  private options: BotMigrationOptions;
+
+  constructor(options: BotMigrationOptions) {
+    this.options = options;
+  }
+
+  async run(): Promise<void> {
+    console.log(chalk.blue(`🗃️ Running migrations for bot...`));
+
+    try {
+      await setupMigrations({
+        pathMigrations: this.options.migrationsPath,
+        pathDatabase: this.options.databasePath
+      });
+    } catch (error) {
+      console.error(chalk.red('❌ Migration failed:'), error);
+      throw error;
+    }
+  }
+}

package/src/core/BotSeeder.ts

@@ -0,0 +1,67 @@
+import * as path from 'path';
+import chalk from 'chalk';
+import { Database } from 'bun:sqlite';
+
+export interface BotSeederOptions {
+  botPath: string;
+  databasePath: string;
+  seeders: Array<(db: Database) => Promise<void> | void>;
+}
+
+export class BotSeeder {
+  private options: BotSeederOptions;
+
+  constructor(options: BotSeederOptions) {
+    this.options = options;
+  }
+
+  async run(): Promise<void> {
+    const args = process.argv.slice(2);
+    const isCleanOnly = args.includes('--clean-only');
+    const isClear = args.includes('--clear');
+
+    console.log(chalk.blue(`🌱 Running seeders for bot...`));
+
+    const db = new Database(this.options.databasePath);
+
+    try {
+      if (isCleanOnly) {
+        console.log(chalk.yellow('🧹 Cleaning database...'));
+        await this.cleanDatabase(db);
+        console.log(chalk.green('✅ Database cleaned successfully!'));
+        return;
+      }
+
+      if (isClear) {
+        console.log(chalk.yellow('🧹 Clearing and reseeding database...'));
+        await this.cleanDatabase(db);
+      }
+
+      console.log(chalk.blue('🌱 Seeding database...'));
+      for (const seeder of this.options.seeders) {
+        await seeder(db);
+      }
+
+      console.log(chalk.green('✅ Database seeded successfully!'));
+    } catch (error) {
+      console.error(chalk.red('❌ Seeding failed:'), error);
+      throw error;
+    } finally {
+      db.close();
+    }
+  }
+
+  private async cleanDatabase(db: Database): Promise<void> {
+    // Get all tables
+    const tables = db.query(`
+      SELECT name FROM sqlite_master 
+      WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name != 'migrations'
+    `).all() as Array<{ name: string }>;
+
+    // Clear all tables except migrations
+    for (const table of tables) {
+      db.query(`DELETE FROM ${table.name}`).run();
+      console.log(chalk.yellow(`🧹 Cleared table: ${table.name}`));
+    }
+  }
+}

package/src/core/utils.ts

@@ -0,0 +1,3 @@
+export function nameToCapitalize(name: string): string {
+    return name.charAt(0).toUpperCase() + name.slice(1);
+}

package/src/illumination/Artisan.ts

@@ -0,0 +1,149 @@
+import fs from 'fs';
+import path from 'path';
+
+export class Artisan {
+  private basePath: string;
+
+  constructor(basePath: string) {
+    this.basePath = basePath;
+  }
+
+  /**
+   * Создает новую секцию
+   * @param name Имя секции (например: Home, Auth, Settings)
+   */
+  async createSection(name: string): Promise<void> {
+    const sectionName = this.formatSectionName(name);
+    const sectionsDir = path.join(this.basePath, 'sections');
+    
+    // Создаем директорию sections если её нет
+    if (!fs.existsSync(sectionsDir)) {
+      fs.mkdirSync(sectionsDir, { recursive: true });
+    }
+
+    const sectionPath = path.join(sectionsDir, `${sectionName}Section.ts`);
+    
+    // Проверяем, не существует ли уже такая секция
+    if (fs.existsSync(sectionPath)) {
+      throw new Error(`Section ${sectionName} already exists at ${sectionPath}`);
+    }
+
+    const template = this.getSectionTemplate(sectionName);
+    
+    // Создаем файл секции
+    fs.writeFileSync(sectionPath, template);
+    console.log(`✅ Created section ${sectionName} at ${sectionPath}`);
+  }
+
+  /**
+   * Форматирует имя секции (первая буква заглавная, остальные строчные)
+   */
+  private formatSectionName(name: string): string {
+    return name.charAt(0).toUpperCase() + name.slice(1).toLowerCase();
+  }
+
+  /**
+   * Возвращает шаблон для новой секции
+   */
+  private getSectionTemplate(name: string): string {
+    return `import { Section } from "../../src/illumination/Section";
+import { SectionOptions } from "../../src/types";
+import { InlineKeyboard } from "../../src/illumination/InlineKeyboard";
+
+export default class ${name}Section extends Section {
+  static command = "${name.toLowerCase()}";
+  static description = "${name} section";
+  static actionRoutes = {
+    "${name.toLowerCase()}.index": "index",
+  };
+  
+  public sectionId = "${name.toLowerCase()}";
+  private mainInlineKeyboard: InlineKeyboard;
+
+  constructor(options: SectionOptions) {
+    super(options);
+
+    this.mainInlineKeyboard = this.makeInlineKeyboard([
+      [this.makeInlineButton("🏠 На главную", "home.index")],
+    ]);
+  }
+
+  public async up(): Promise<void> {}
+  public async down(): Promise<void> {}
+  public async setup(): Promise<void> {}
+  public async unsetup(): Promise<void> {}
+
+  async index() {
+    const message = \`
+      👋 Welcome to ${name} Section
+    \`;
+
+    await this.message(message)
+      .inlineKeyboard(this.mainInlineKeyboard)
+      .send();
+  }
+}
+`;
+  }
+
+  /**
+   * Добавляет новый метод в существующую секцию
+   */
+  async addMethod(sectionName: string, methodName: string): Promise<void> {
+    const formattedSectionName = this.formatSectionName(sectionName);
+    const sectionPath = path.join(this.basePath, 'sections', `${formattedSectionName}Section.ts`);
+
+    if (!fs.existsSync(sectionPath)) {
+      throw new Error(`Section ${formattedSectionName} does not exist at ${sectionPath}`);
+    }
+
+    let content = fs.readFileSync(sectionPath, 'utf-8');
+
+    // Добавляем новый route в actionRoutes
+    const routeEntry = `"${sectionName.toLowerCase()}.${methodName}": "${methodName}",`;
+    content = content.replace(
+      /static actionRoutes = {([^}]*)}/,
+      (match, routes) => `static actionRoutes = {${routes}    ${routeEntry}\n  }`
+    );
+
+    // Добавляем новый метод
+    const methodTemplate = `
+  async ${methodName}() {
+    const message = \`
+      // Добавьте ваше сообщение здесь
+    \`;
+
+    await this.message(message)
+      .inlineKeyboard(this.mainInlineKeyboard)
+      .send();
+  }
+`;
+
+    // Вставляем метод перед последней закрывающей скобкой
+    content = content.replace(/}$/, `${methodTemplate}}`);
+
+    fs.writeFileSync(sectionPath, content);
+    console.log(`✅ Added method ${methodName} to section ${formattedSectionName}`);
+  }
+
+  /**
+   * Выводит список всех секций
+   */
+  async listSections(): Promise<void> {
+    const sectionsDir = path.join(this.basePath, 'sections');
+    
+    if (!fs.existsSync(sectionsDir)) {
+      console.log('No sections found');
+      return;
+    }
+
+    const sections = fs.readdirSync(sectionsDir)
+      .filter(file => file.endsWith('Section.ts'))
+      .map(file => file.replace('Section.ts', ''));
+
+    console.log('\n📁 Available sections:');
+    sections.forEach(section => {
+      console.log(`  - ${section}`);
+    });
+  }
+}

package/src/illumination/InlineKeyboard.ts

@@ -0,0 +1,44 @@
+import { Telegraf2byteContext } from "./Telegraf2byteContext";
+
+export class InlineKeyboard {
+
+    private keyboard: any[][] = [];
+
+    static init(ctx: Telegraf2byteContext) {
+        return new InlineKeyboard(ctx);
+    }
+
+    constructor(private ctx: Telegraf2byteContext) {
+
+    }
+
+    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;
+    }
+
+    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[][] {
+        return this.keyboard;
+    }
+
+    [Symbol.toPrimitive]() {
+        return this.valueOf();
+    }
+}

package/src/illumination/Message2Byte.ts

@@ -0,0 +1,254 @@
+import { Telegraf2byteContext } from "./Telegraf2byteContext";
+import { Input, Markup } from "telegraf";
+import type { ReplyKeyboardMarkup } from 'telegraf/core/types/telegram';
+import { InlineKeyboard } from "./InlineKeyboard";
+import { RequestInputOptions } from "../types";
+import { Message } from "telegraf/types";
+import Message2bytePool from "./Message2bytePool";
+import { Section } from "./Section";
+
+export default class Message2byte {
+  public messageValue: string = "";
+  public messageExtra: any = {};
+  public isUpdate: boolean = false;
+  private ctx: Telegraf2byteContext;
+  private imagePath: string | null = null;
+  private imageCaption: string | null = null;
+  private messageId: number | null = null;
+  private doAnswerCbQuery: boolean = true;
+  private section: Section;
+
+  constructor(ctx: Telegraf2byteContext, section: Section) {
+    this.ctx = ctx;
+    this.section = section;
+  }
+
+  static init(ctx: Telegraf2byteContext, section: Section) {
+    return new Message2byte(ctx, section);
+  }
+
+  setNotAnswerCbQuery(): this {
+    this.doAnswerCbQuery = false;
+    return this;
+  }
+
+  message(message: string): this {
+    this.messageValue = message;
+    return this;
+  }
+
+  createPoolMessage(message: string): Message2bytePool {
+    this.doAnswerCbQuery = false;
+    this.messageValue = message;
+    return Message2bytePool.init(this, this.ctx, this.section);
+  }
+
+  createUpdatePoolMessage(message: string): Message2bytePool {
+    this.isUpdate = true;
+    this.messageValue = message;
+    return Message2bytePool.init(this, this.ctx, this.section);
+  }
+
+  updateMessage(message: string): this {
+    this.messageValue = message;
+    this.isUpdate = true;
+    this.messageExtra.message_id &&= this.messageId;
+    return this;
+  }
+
+  markdown(): this {
+    this.messageExtra.parse_mode = "markdown";
+    return this;
+  }
+
+  html(): this {
+    this.messageExtra.parse_mode = "html";
+    return this;
+  }
+
+  extra(extra: Object): this {
+    this.messageExtra = extra;
+    return this;
+  }
+
+  keyboard(keyboard: ReplyKeyboardMarkup): this {
+    this.messageExtra.reply_markup = {
+      keyboard: keyboard.keyboard,
+      resize_keyboard: keyboard.resize_keyboard,
+      one_time_keyboard: keyboard.one_time_keyboard,
+    };
+    return this;
+  }
+
+  inlineKeyboard(keyboard: [][] | InlineKeyboard) {
+    let keyboardArray: any[][];
+
+    if (keyboard instanceof InlineKeyboard) {
+      keyboardArray = keyboard.valueOf();
+    } else {
+      keyboardArray = keyboard;
+    }
+
+    Object.assign(this.messageExtra, {
+      ...Markup.inlineKeyboard(keyboardArray),
+    });
+
+    return this;
+  }
+
+  requestInput(inputKey: string, options: RequestInputOptions = {}): this {
+    // Устанавливаем значения по умолчанию
+    const allowCancel = options.allowCancel !== false; // по умолчанию true
+    const cancelButtonText = options.cancelButtonText || "Отмена";
+    const cancelAction = options.cancelAction || "home.index[cancel_wait=1]";
+
+    // Если разрешена отмена, добавляем кнопку отмены к клавиатуре
+    if (allowCancel && this.messageExtra && "reply_markup" in this.messageExtra) {
+      const replyMarkup = (this.messageExtra as any).reply_markup;
+      if (replyMarkup && replyMarkup.inline_keyboard) {
+        // Добавляем кнопку отмены в начало клавиатуры
+        replyMarkup.inline_keyboard.unshift([
+          {
+            text: `❌ ${cancelButtonText}`,
+            callback_data: cancelAction,
+          },
+        ]);
+      }
+    }
+
+    // Сохраняем информацию о запрашиваемом вводе в сессии пользователя
+    this.ctx.userSession.awaitingInput = {
+      key: inputKey,
+      validator: options.validator,
+      errorMessage: options.errorMessage || "Неверный формат ввода",
+      allowCancel,
+      cancelButtonText: `❌ ${cancelButtonText}`,
+      cancelAction,
+      fileValidation: options.fileValidation,
+      runSection: options.runSection,
+      retryCount: 0,
+    };
+
+    return this;
+  }
+
+  async requestInputWithAwait(
+    inputKey: string,
+    options: RequestInputOptions = {}
+  ): Promise<string | any> {
+    // Устанавливаем значения по умолчанию
+    const allowCancel = options.allowCancel !== false; // по умолчанию true
+    const cancelButtonText = options.cancelButtonText || "Отмена";
+    const cancelAction = options.cancelAction || "home.index[cancel_wait=1]";
+
+    // Если разрешена отмена, добавляем кнопку отмены к клавиатуре
+    if (allowCancel && this.messageExtra && "reply_markup" in this.messageExtra) {
+      const replyMarkup = (this.messageExtra as any).reply_markup;
+      if (replyMarkup && replyMarkup.inline_keyboard) {
+        // Добавляем кнопку отмены в начало клавиатуры
+        replyMarkup.inline_keyboard.unshift([
+          {
+            text: `❌ ${cancelButtonText}`,
+            callback_data: cancelAction,
+          },
+        ]);
+      }
+    }
+
+    // Отправляем сообщение
+    await this.send();
+
+    // Возвращаем Promise, который будет разрешен когда пользователь введет данные
+    return new Promise((resolve, reject) => {
+      this.ctx.userSession.awaitingInputPromise = {
+        key: inputKey,
+        validator: options.validator,
+        errorMessage: options.errorMessage || "Неверный формат ввода",
+        allowCancel,
+        cancelButtonText: `❌ ${cancelButtonText}`,
+        cancelAction,
+        fileValidation: options.fileValidation,
+        retryCount: 0,
+        resolve,
+        reject,
+      };
+    });
+  }
+
+  image(pathImage: string): this {
+    this.imagePath = pathImage;
+    this.imageCaption = this.messageValue;
+    this.messageExtra.caption = this.imageCaption;
+    return this;
+  }
+
+  editMessageCaption(message: string, extra: any = {}) {
+    return this.ctx.editMessageCaption(message, extra);
+  }
+
+  editMessageText(message: string, extra: any = {}) {
+    return this.ctx.editMessageText(message, extra);
+  }
+
+  async send() {
+    if (this.isUpdate) {
+      if (this.section.route.runIsCallbackQuery && this.doAnswerCbQuery) {
+        await this.ctx.answerCbQuery();
+      }
+
+      const message = this.ctx.callbackQuery?.message as Message;
+      
+      if (message) {
+        if ('media_group_id' in message || 'caption' in message) {
+          const editMessageCaption = this.editMessageCaption(this.messageValue, this.messageExtra);
+
+          if (editMessageCaption && 'message_id' in editMessageCaption) {
+            this.messageId = editMessageCaption.message_id as number;
+          }
+
+          return editMessageCaption;
+        } else {
+
+          const editedText = this.editMessageText(this.messageValue, this.messageExtra);
+
+          if (editedText && 'message_id' in editedText) {
+            this.messageId = editedText.message_id as number;
+          }
+
+          return editedText;
+        }
+      } else {
+        this.messageExtra.message_id = this.messageId;
+
+        const messageEntity = await this.editMessageText(this.messageValue, this.messageExtra);
+
+        if (typeof messageEntity === "object" && 'message_id' in messageEntity) {
+          this.messageId = messageEntity.message_id as number;
+        }
+
+        return messageEntity;
+      }
+    }
+
+    if (this.imagePath) {
+      return this.ctx.replyWithPhoto(Input.fromLocalFile(this.imagePath), this.messageExtra);
+    }
+
+    const replyEntity = this.ctx.reply(this.messageValue, this.messageExtra);
+
+    this.messageId = (await replyEntity).message_id;
+
+    return replyEntity;
+  }
+
+  sendReturnThis(): this {
+    this.send();
+    return this;
+  }
+
+  setMessageId(messageId: number): this {
+    this.messageId = messageId;
+    this.messageExtra.message_id = messageId;
+    return this;
+  }
+}