@2byte/tgbot-framework 1.0.0

package/src/illumination/Message2ByteLiveProgressive.ts

@@ -0,0 +1,278 @@
+import Message2byte from "./Message2Byte";
+import Message2bytePool from "./Message2bytePool";
+
+interface ProgressiveItem {
+  id: number;
+  text: string;
+  status?: 'pending' | 'active' | 'completed' | 'error';
+  caption?: string;
+  progressBar?: {
+    active: boolean;
+    duration?: number;
+    infinite?: boolean;
+  };
+}
+
+export default class Message2ByteLiveProgressive {
+  private message2byte: Message2byte;
+  private message2bytePool: Message2bytePool;
+  private items: Map<number, ProgressiveItem> = new Map();
+  private baseMessage: string = '';
+  private progressBarTimer?: NodeJS.Timeout;
+  private progressBarIcons = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+  private progressBarIndex = 0;
+  private activeProgressItem?: number;
+
+  static init(message2byte: Message2byte, message2bytePool: Message2bytePool) {
+    return new Message2ByteLiveProgressive(message2byte, message2bytePool);
+  }
+
+  constructor(message2byte: Message2byte, message2bytePool: Message2bytePool) {
+    this.message2byte = message2byte;
+    this.message2bytePool = message2bytePool;
+  }
+
+  /**
+   * Устанавливает базовое сообщение
+   */
+  setBaseMessage(message: string): this {
+    this.baseMessage = message;
+    return this;
+  }
+
+  /**
+   * Добавляет новый пункт
+   */
+  appendItem(id: number, text: string, status: 'pending' | 'active' | 'completed' | 'error' = 'pending'): this {
+    this.items.set(id, {
+      id,
+      text,
+      status
+    });
+    return this;
+  }
+
+  /**
+   * Изменяет существующий пункт
+   */
+  changeItem(id: number, text: string, status?: 'pending' | 'active' | 'completed' | 'error'): this {
+    const existingItem = this.items.get(id);
+    if (existingItem) {
+      this.items.set(id, {
+        ...existingItem,
+        text,
+        status: status || existingItem.status
+      });
+    }
+    return this;
+  }
+
+  setItemCaption(id: number, caption: string): this {
+    const item = this.items.get(id);
+    if (item) {
+      item.caption = caption;
+    }
+    return this;
+  }
+
+  changeItemCaption(id: number, caption: string): this {
+    const item = this.items.get(id);
+    if (item) {
+      item.caption = caption;
+    }
+    return this;
+  }
+
+  /**
+   * Удаляет пункт по ID
+   */
+  removeItem(id: number): this {
+    this.items.delete(id);
+    return this;
+  }
+
+  /**
+   * Изменяет статус пункта
+   */
+  setItemStatus(id: number, status: 'pending' | 'active' | 'completed' | 'error'): this {
+    const item = this.items.get(id);
+    if (item) {
+      item.status = status;
+    }
+    return this;
+  }
+
+  setItemStatusError(id: number, errorText?: string): this {
+    const item = this.items.get(id);
+    if (item) {
+      item.status = 'error';
+      if (errorText) {
+        item.text += ` - ${errorText}`;
+      }
+    }
+    return this;
+  }
+
+  setItemStatusCompleted(id: number): this {
+    const item = this.items.get(id);
+    if (item) {
+      item.status = 'completed';
+    }
+    return this;
+  }
+
+  /**
+   * Запускает прогрессбар для конкретного пункта
+   */
+  sleepProgressBar(duration?: number, itemId?: number): this {
+    if (!itemId) {
+      itemId = this.items.size > 0 ? Array.from(this.items.keys())[this.items.size - 1] : undefined;
+    }
+    if (itemId) {
+      this.activeProgressItem = itemId;
+      const item = this.items.get(itemId);
+      if (item) {
+        item.progressBar = {
+          active: true,
+          duration,
+          infinite: !duration
+        };
+        item.status = 'active';
+      }
+    }
+
+    this.startProgressBar(duration);
+    return this;
+  }
+
+  /**
+   * Останавливает прогрессбар
+   */
+  stopSleepProgress(): this {
+    if (this.progressBarTimer) {
+      clearInterval(this.progressBarTimer);
+      this.progressBarTimer = undefined;
+    }
+
+    if (this.activeProgressItem) {
+      const item = this.items.get(this.activeProgressItem);
+      if (item && item.progressBar) {
+        item.progressBar.active = false;
+        item.status = 'completed';
+      }
+      this.activeProgressItem = undefined;
+      this.updateMessage();
+      this.message2bytePool.send();
+    }
+
+    return this;
+  }
+
+  /**
+   * Запускает анимацию прогрессбара
+   */
+  private startProgressBar(duration?: number): void {
+    if (this.progressBarTimer) {
+      clearInterval(this.progressBarTimer);
+    }
+
+    this.progressBarTimer = setInterval(() => {
+      this.progressBarIndex = (this.progressBarIndex + 1) % this.progressBarIcons.length;
+      this.updateMessage();
+      this.message2bytePool.send();
+    }, 200);
+
+    if (duration) {
+      setTimeout(() => {
+        this.stopSleepProgress();
+      }, duration);
+    }
+  }
+
+  /**
+   * Обновляет сообщение с текущими пунктами
+   */
+  private updateMessage(): void {
+    let message = this.baseMessage;
+    
+    if (this.items.size > 0) {
+      message += '\n\n';
+      
+      // Сортируем пункты по ID
+      const sortedItems = Array.from(this.items.values()).sort((a, b) => a.id - b.id);
+      
+      sortedItems.forEach(item => {
+        const statusIcon = this.getStatusIcon(item);
+        const progressIcon = this.getProgressIcon(item);
+        
+        message += `${statusIcon} ${item.text}${progressIcon}\n`;
+
+        if (item.caption) {
+          if (this.message2byte.messageExtra && this.message2byte.messageExtra.parse_mode === 'html') {
+            message += `   <i>${item.caption}</i>\n`;
+          } else if (this.message2byte.messageExtra && this.message2byte.messageExtra.parse_mode === 'markdown') {
+            message += `   _${item.caption}_\n`;
+          } else {
+            message += `   ${item.caption}\n`;
+          }
+        }
+      });
+    }
+
+    this.message2bytePool.update(message.trim());
+  }
+
+  /**
+   * Получает иконку статуса для пункта
+   */
+  private getStatusIcon(item: ProgressiveItem): string {
+    switch (item.status) {
+      case 'pending': return '⏳';
+      case 'active': return '🔄';
+      case 'completed': return '✅';
+      case 'error': return '❌';
+      default: return '⏳';
+    }
+  }
+
+  /**
+   * Получает иконку прогресса для пункта
+   */
+  private getProgressIcon(item: ProgressiveItem): string {
+    if (item.progressBar?.active && item.id === this.activeProgressItem) {
+      return ` ${this.progressBarIcons[this.progressBarIndex]}`;
+    }
+    return '';
+  }
+
+  /**
+   * Очищает все пункты
+   */
+  clear(): this {
+    this.items.clear();
+    return this;
+  }
+
+  /**
+   * Получает все пункты
+   */
+  getItems(): ProgressiveItem[] {
+    return Array.from(this.items.values()).sort((a, b) => a.id - b.id);
+  }
+
+  /**
+   * Получает пункт по ID
+   */
+  getItem(id: number): ProgressiveItem | undefined {
+    return this.items.get(id);
+  }
+
+  /**
+   * Отправляет сообщение
+   */
+  async send() {
+    this.updateMessage();
+    const entity = await this.message2bytePool.send();
+    return entity;
+  }
+}

package/src/illumination/Message2bytePool.ts

@@ -0,0 +1,108 @@
+import type { Section, Telegraf2byteContext } from "@2byte/tgbot-framework";
+import Message2byte from "./Message2Byte";
+import Message2ByteLiveProgressive from "./Message2ByteLiveProgressive";
+
+export default class Message2bytePool {
+    private message2byte: Message2byte;
+    private ctx: Telegraf2byteContext;
+    private messageValue: string = "";
+    private section: Section;
+
+    static init(message2byte: Message2byte, ctx: Telegraf2byteContext, section: Section) {
+        return new Message2bytePool(message2byte, ctx, section);
+    }
+
+    constructor(message2byte: Message2byte, ctx: Telegraf2byteContext, section: Section) {
+        this.message2byte = message2byte;
+        this.message2byte.setNotAnswerCbQuery();
+        this.ctx = ctx;
+        this.section = section;
+    }
+
+    markdown(): this {
+        this.message2byte.markdown();
+        return this;
+    }
+
+    html(): this {
+        this.message2byte.html();
+        return this;
+    }
+    
+    message(message: string): this {
+        this.messageValue = message;
+        if (this.section.route.runIsCallbackQuery) {
+            this.message2byte.updateMessage(message);
+        } else {
+            this.message2byte.message(message);
+        }
+        return this;
+    }
+
+    update(message: string): this {
+        this.messageValue = message;
+        this.message2byte.updateMessage(message);
+        return this;
+    }
+
+    append(message: string): this {
+        this.messageValue += message;
+        this.message2byte.updateMessage(this.messageValue);
+        return this;
+    }
+
+    prepend(message: string): this {
+        this.messageValue = message + this.messageValue;
+        this.message2byte.updateMessage(this.messageValue);
+        return this;
+    }
+
+    liveProgressive(): Message2ByteLiveProgressive {
+        return Message2ByteLiveProgressive.init(this.message2byte, this);
+    }
+
+    async send() {
+
+        const entity = await this.message2byte.send();
+
+        // if (typeof entity === "object" && entity.message_id) {
+        //     this.messageId = entity.message_id;
+        //     console.log("Pool message sent with ID:", this.messageId);
+        // }
+
+        return entity;
+    }
+
+    async sendReturnThis(): Promise<this> {
+        await this.send();
+        return this;
+    }
+
+    async sleepProgressBar(messageWait: string, ms: number): Promise<void> {
+      return new Promise<void>((resolve, reject) => {
+        const pgIcons = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+  
+        let pgIndex = 0;
+        let currentMessage = this.messageValue + `[pg]${pgIcons[pgIndex]} ${messageWait}`;
+  
+        const pgIntervalTimer = setInterval(() => {
+          // Update progress message here
+          currentMessage = this.messageValue + `[pg]${pgIcons[pgIndex]} ${messageWait}`;
+          pgIndex = (pgIndex + 1) % pgIcons.length;
+  
+          this.message(currentMessage)
+            .send()
+            .catch((err) => {
+              clearInterval(pgIntervalTimer);
+              reject(err);
+            });
+        }, 1000);
+        
+        setTimeout(() => {
+          clearInterval(pgIntervalTimer);
+          this.message(this.messageValue);
+          resolve();
+        }, ms);
+      });
+    }
+}

package/src/illumination/Migration.ts

@@ -0,0 +1,186 @@
+import { Database } from 'bun:sqlite';
+import fs from 'fs';
+import path from 'path';
+
+export interface MigrationFile {
+  id: number;
+  name: string;
+  path: string;
+}
+
+export class Migration {
+  private db: Database;
+  private migrationsPath: string;
+
+  constructor(db: Database, migrationsPath: string) {
+    this.db = db;
+    this.migrationsPath = migrationsPath;
+    this.initMigrationsTable();
+  }
+
+  /**
+   * Инициализация таблицы миграций
+   */
+  private initMigrationsTable(): void {
+    this.db.query(`
+      CREATE TABLE IF NOT EXISTS migrations (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL,
+        batch INTEGER NOT NULL,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `).run();
+  }
+
+  /**
+   * Получение списка файлов миграций
+   */
+  private getMigrationFiles(): MigrationFile[] {
+    const files = fs.readdirSync(this.migrationsPath)
+      .filter(file => file.endsWith('.sql'))
+      .map(file => {
+        const [id, ...nameParts] = file.replace('.sql', '').split('_');
+        return {
+          id: parseInt(id),
+          name: nameParts.join('_'),
+          path: path.join(this.migrationsPath, file)
+        };
+      })
+      .sort((a, b) => a.id - b.id);
+
+    return files;
+  }
+
+  /**
+   * Получение списка выполненных миграций
+   */
+  private getExecutedMigrations(): string[] {
+    const result = this.db.query('SELECT name FROM migrations').all() as { name: string }[];
+    return result.map(row => row.name);
+  }
+
+  /**
+   * Выполнение миграции
+   */
+  async up(): Promise<void> {
+    const executed = this.getExecutedMigrations();
+    const files = this.getMigrationFiles();
+    const batch = this.getLastBatch() + 1;
+
+    for (const file of files) {
+      if (!executed.includes(file.name)) {
+        try {
+          const sql = fs.readFileSync(file.path, 'utf-8');
+          this.db.transaction(() => {
+            this.db.query(sql).run();
+            this.db.query('INSERT INTO migrations (name, batch) VALUES (?, ?)')
+              .run(file.name, batch);
+          })();
+          console.log(`✅ Миграция ${file.name} выполнена успешно`);
+        } catch (error) {
+          console.error(`❌ Ошибка при выполнении миграции ${file.name}:`, error);
+          throw error;
+        }
+      }
+    }
+  }
+
+  /**
+   * Откат миграций
+   */
+  async down(steps: number = 1): Promise<void> {
+    const batch = this.getLastBatch();
+    if (batch === 0) {
+      console.log('Нет миграций для отката');
+      return;
+    }
+
+    const migrations = this.db.query(`
+      SELECT * FROM migrations 
+      WHERE batch >= ? 
+      ORDER BY batch DESC, id DESC 
+      LIMIT ?
+    `).all(batch - steps + 1, steps) as { name: string }[];
+
+    for (const migration of migrations) {
+      const file = this.getMigrationFiles().find(f => f.name === migration.name);
+      if (file) {
+        try {
+          const sql = fs.readFileSync(file.path, 'utf-8');
+          const downSql = this.extractDownSQL(sql);
+          
+          if (downSql) {
+            this.db.transaction(() => {
+              this.db.query(downSql).run();
+              this.db.query('DELETE FROM migrations WHERE name = ?').run(migration.name);
+            })();
+            console.log(`✅ Откат миграции ${migration.name} выполнен успешно`);
+          } else {
+            console.warn(`⚠️ Секция DOWN не найдена в миграции ${migration.name}`);
+          }
+        } catch (error) {
+          console.error(`❌ Ошибка при откате миграции ${migration.name}:`, error);
+          throw error;
+        }
+      }
+    }
+  }
+
+  /**
+   * Получение последнего номера batch
+   */
+  private getLastBatch(): number {
+    const result = this.db.query('SELECT MAX(batch) as max_batch FROM migrations').get() as { max_batch: number };
+    return result.max_batch || 0;
+  }
+
+  /**
+   * Извлечение SQL для отката из файла миграции
+   */
+  private extractDownSQL(sql: string): string | null {
+    const downMatch = sql.match(/-- DOWN\s+([\s\S]+?)(?=-- UP|$)/i);
+    return downMatch ? downMatch[1].trim() : null;
+  }
+
+  /**
+   * Создание новой миграции
+   */
+  static async create(name: string, migrationsPath: string): Promise<void> {
+    const files = fs.readdirSync(migrationsPath)
+      .filter(file => file.endsWith('.sql'))
+      .map(file => parseInt(file.split('_')[0]));
+
+    const nextId = (Math.max(0, ...files) + 1).toString().padStart(3, '0');
+    const fileName = `${nextId}_${name}.sql`;
+    const filePath = path.join(migrationsPath, fileName);
+
+    const template = `-- UP
+CREATE TABLE IF NOT EXISTS ${name} (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+-- DOWN
+DROP TABLE IF EXISTS ${name};
+`;
+
+    fs.writeFileSync(filePath, template);
+    console.log(`✅ Создана новая миграция: ${fileName}`);
+  }
+
+  /**
+   * Статус миграций
+   */
+  status(): void {
+    const executed = this.getExecutedMigrations();
+    const files = this.getMigrationFiles();
+
+    console.log('\n📊 Статус миграций:\n');
+    
+    for (const file of files) {
+      const status = executed.includes(file.name) ? '✅' : '⏳';
+      console.log(`${status} ${file.id}_${file.name}`);
+    }
+    console.log();
+  }
+}

package/src/illumination/RunSectionRoute.ts

@@ -0,0 +1,85 @@
+import { RunSectionRouteParams } from '../types';
+
+export class RunSectionRoute {
+  private runParams: RunSectionRouteParams = {
+    section: null,
+    method: null,
+    methodArgs: null,
+    callbackParams: new URLSearchParams(),
+    runAsCallcackQuery: false,
+    actionPath: null,
+    hearsKey: null,
+  };
+
+  constructor() {}
+
+  section(sectionId: string): this {
+    this.runParams.section = sectionId;
+    return this;
+  }
+
+  method(name: string = 'index', isRunCallbackQuery: boolean = false): this {
+    this.runParams.method = name;
+    this.runParams.runAsCallcackQuery = isRunCallbackQuery;
+    return this;
+  }
+
+  methodArgs(args: any[] | null): this {
+    this.runParams.methodArgs = args;
+    return this;
+  }
+
+  callbackParams(actionPath: string, params: string | Record<string, string>): this {
+    this.runParams.callbackParams = new URLSearchParams(params);
+    this.actionPath(actionPath);
+    this.runParams.runAsCallcackQuery = true;
+    return this;
+  }
+
+  actionPath(path: string): this {
+    this.runParams.actionPath = path;
+    this.runParams.runAsCallcackQuery = true;
+    return this;
+  }
+
+  hearsKey(key: string): this {
+    this.runParams.hearsKey = key;
+    return this;
+  }
+
+  getMethod(): string | null {
+    return this.runParams.method;
+  }
+
+  getSection(): string | null {
+    return this.runParams.section;
+  }
+
+  getSectionId(): string | null {
+    return this.runParams.section;
+  }
+
+  getCommand(): string | null {
+    return this.runParams.method;
+  }
+
+  getSubCommand(): string | null {
+    return this.runParams.method;
+  }
+
+  getActionPath(): string | null {
+    return this.runParams.actionPath;
+  }
+
+  getCallbackParams(): URLSearchParams {
+    return this.runParams.callbackParams;
+  }
+
+  getHearsKey(): string | null {
+    return this.runParams.hearsKey;
+  }
+
+  get runIsCallbackQuery(): boolean {
+    return this.runParams.runAsCallcackQuery;
+  }
+}