@2byte/tgbot-framework 1.0.3 → 1.0.5

package/src/core/BotArtisan.ts

@@ -1,80 +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
-`);
-  }
+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

@@ -1,31 +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;
-    }
-  }
+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

@@ -1,67 +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}`));
-    }
-  }
+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/Model.ts

@@ -1,84 +1,84 @@
-import type { Database } from "bun:sqlite";
-import { MakeManualPaginateButtonsParams, ModelPaginateParams, PaginateResult } from "../types";
-import { Section } from "../illumination/Section";
-
-declare global {
-  var db: Database;
-}
-
-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;
-  }
-}
+import type { Database } from "bun:sqlite";
+import { MakeManualPaginateButtonsParams, ModelPaginateParams, PaginateResult } from "../types";
+import { Section } from "../illumination/Section";
+
+declare global {
+  var db: Database;
+}
+
+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/core/utils.ts

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