@2byte/tgbot-framework 1.0.0

package/src/cli/GenerateCommand.ts

@@ -0,0 +1,112 @@
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import chalk from 'chalk';
+
+export class GenerateCommand {
+  async generateSection(name: string): Promise<void> {
+    console.log(chalk.blue(`🎯 Generating section: ${name}`));
+
+    const currentDir = process.cwd();
+    const sectionsDir = path.join(currentDir, 'sections');
+    const sectionName = this.formatSectionName(name);
+    const sectionPath = path.join(sectionsDir, `${sectionName}Section.ts`);
+
+    // Ensure sections directory exists
+    await fs.ensureDir(sectionsDir);
+
+    // Check if section already exists
+    if (await fs.pathExists(sectionPath)) {
+      console.log(chalk.red(`❌ Section ${sectionName} already exists at ${sectionPath}`));
+      return;
+    }
+
+    // Generate section content
+    const template = this.getSectionTemplate(sectionName);
+    await fs.writeFile(sectionPath, template);
+
+    console.log(chalk.green(`✅ Created section ${sectionName} at ${sectionPath}`));
+  }
+
+  async generateMigration(name: string): Promise<void> {
+    console.log(chalk.blue(`🗃️  Generating migration: ${name}`));
+
+    const currentDir = process.cwd();
+    const migrationsDir = path.join(currentDir, 'database', 'migrations');
+
+    // Ensure migrations directory exists
+    await fs.ensureDir(migrationsDir);
+
+    // Get next migration ID
+    const files = await fs.readdir(migrationsDir);
+    const migrationFiles = files
+      .filter(file => file.endsWith('.sql'))
+      .map(file => parseInt(file.split('_')[0]))
+      .filter(id => !isNaN(id));
+
+    const nextId = (Math.max(0, ...migrationFiles) + 1).toString().padStart(3, '0');
+    const fileName = `${nextId}_${name}.sql`;
+    const filePath = path.join(migrationsDir, fileName);
+
+    const template = this.getMigrationTemplate(name);
+    await fs.writeFile(filePath, template);
+
+    console.log(chalk.green(`✅ Created migration: ${fileName}`));
+  }
+
+  private formatSectionName(name: string): string {
+    return name.charAt(0).toUpperCase() + name.slice(1).toLowerCase();
+  }
+
+  private getSectionTemplate(name: string): string {
+    return `import { Section } from "2bytetgbot";
+import { SectionOptions } from "2bytetgbot";
+import { InlineKeyboard } from "2bytetgbot";
+
+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();
+  }
+}
+`;
+  }
+
+  private getMigrationTemplate(name: string): string {
+    return `-- UP
+CREATE TABLE IF NOT EXISTS ${name} (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+-- DOWN
+DROP TABLE IF EXISTS ${name};
+`;
+  }
+}

package/src/cli/InitCommand.ts

@@ -0,0 +1,108 @@
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import chalk from 'chalk';
+
+export class InitCommand {
+  async execute(options: any): Promise<void> {
+    const currentDir = process.cwd();
+    const packageJsonPath = path.join(currentDir, 'package.json');
+
+    console.log(chalk.blue('🔧 Initializing 2byte bot in current directory...'));
+
+    // Check if already a 2byte bot
+    if (await fs.pathExists(packageJsonPath)) {
+      const packageJson = await fs.readJson(packageJsonPath);
+      
+      if (packageJson.dependencies && packageJson.dependencies['2bytetgbot']) {
+        if (!options.force) {
+          console.log(chalk.yellow('⚠️  This directory already contains a 2byte bot.'));
+          console.log(chalk.yellow('   Use --force to override existing files.'));
+          return;
+        }
+      }
+    }
+
+    // Create basic bot structure
+    await this.createBotStructure(currentDir, options);
+
+    console.log(chalk.green('✅ 2byte bot initialized successfully!'));
+    console.log(chalk.blue('📋 Next steps:'));
+    console.log('   bun install           # Install dependencies');
+    console.log('   bun run migrate        # Run migrations');
+    console.log('   bun run seed           # Seed database');
+    console.log('   bun run dev            # Start bot');
+  }
+
+  private async createBotStructure(targetPath: string, options: any): Promise<void> {
+    const templatesPath = path.join(__dirname, '../../templates/bot');
+    
+    // Copy essential files
+    const essentialFiles = [
+      'package.json',
+      'artisan.ts',
+      'bot.ts',
+      'sections.ts',
+      '.env.example',
+      'database/migrate.ts',
+      'database/seed.ts',
+    ];
+
+    for (const file of essentialFiles) {
+      const sourcePath = path.join(templatesPath, file);
+      const targetFilePath = path.join(targetPath, file);
+
+      if (await fs.pathExists(sourcePath)) {
+        if (!options.force && await fs.pathExists(targetFilePath)) {
+          console.log(chalk.yellow(`⚠️  Skipping ${file} (already exists)`));
+          continue;
+        }
+
+        await fs.ensureDir(path.dirname(targetFilePath));
+        
+        // Read and process template
+        let content = await fs.readFile(sourcePath, 'utf-8');
+        
+        // For now, use current directory name as bot name
+        const botName = path.basename(targetPath);
+        const config = {
+          botName,
+          className: this.toPascalCase(botName),
+          kebabName: this.toKebabCase(botName),
+          description: `A telegram bot created with 2byte framework`,
+          author: '',
+          useDatabase: true,
+        };
+
+        // Simple template replacement
+        content = this.processTemplate(content, config);
+        
+        await fs.writeFile(targetFilePath, content);
+        console.log(chalk.green(`✅ Created ${file}`));
+      }
+    }
+  }
+
+  private processTemplate(content: string, config: any): string {
+    // Simple mustache-style replacement
+    return content
+      .replace(/\{\{botName\}\}/g, config.botName)
+      .replace(/\{\{className\}\}/g, config.className)
+      .replace(/\{\{kebabName\}\}/g, config.kebabName)
+      .replace(/\{\{description\}\}/g, config.description)
+      .replace(/\{\{author\}\}/g, config.author);
+  }
+
+  private toPascalCase(str: string): string {
+    return str
+      .split(/[-_\s]+/)
+      .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+      .join('');
+  }
+
+  private toKebabCase(str: string): string {
+    return str
+      .replace(/([a-z])([A-Z])/g, '$1-$2')
+      .replace(/[\s_]+/g, '-')
+      .toLowerCase();
+  }
+}

package/src/console/migrate.ts

@@ -0,0 +1,83 @@
+#!/usr/bin/env bun
+import { Database } from 'bun:sqlite';
+import { Migration } from '../illumination/Migration';
+import path from 'path';
+
+type setupParams = {
+  pathDatabase?: string;
+  pathMigrations?: string;
+};
+
+async function main(params: setupParams = {}) {
+
+const MIGRATIONS_PATH = params.pathMigrations || path.join(__dirname, 'migrations');
+
+  const command = process.argv[2];
+  const args = process.argv.slice(3);
+
+  if (!command) {
+    showHelp();
+    return;
+  }
+
+  const db = new Database(params.pathDatabase || __dirname + '/database/database.sqlite');
+
+  const migration = new Migration(db, MIGRATIONS_PATH);
+
+  try {
+    switch (command) {
+      case 'create':
+        if (args.length === 0) {
+          console.error('❌ Ошибка: Требуется имя миграции');
+          console.log('Использование: migrate create migration_name');
+          return;
+        }
+        await Migration.create(args[0], MIGRATIONS_PATH);
+        break;
+
+      case 'up':
+        await migration.up();
+        console.log('✅ Миграции выполнены');
+        break;
+
+      case 'down':
+        const steps = args[0] ? parseInt(args[0]) : 1;
+        await migration.down(steps);
+        console.log('✅ Откат миграций выполнен');
+        break;
+
+      case 'status':
+        migration.status();
+        break;
+
+      default:
+        console.error(`❌ Неизвестная команда: ${command}`);
+        showHelp();
+    }
+  } catch (error) {
+    console.error('❌ Ошибка:', error);
+  } finally {
+    db.close();
+  }
+}
+
+function showHelp() {
+  console.log(`
+🗃️ Migration CLI для SQLite
+
+Доступные команды:
+  create <name>    Создать новую миграцию
+  up              Выполнить все новые миграции
+  down [steps]    Откатить последние миграции (по умолчанию 1)
+  status          Показать статус миграций
+
+Примеры:
+  migrate create create_users_table
+  migrate up
+  migrate down 2
+  migrate status
+`);
+}
+export const setupMigrations = async (params: setupParams) => {
+  return main(params).catch(console.error);
+}