fragment-ts 1.0.2 → 1.0.3

package/src/cli/commands/migrate.command.ts

@@ -1,118 +1,233 @@
-
-import { execSync } from 'child_process';
-import { CLILogger } from '../utils/logger';
-import inquirer from 'inquirer';
+import { Command } from 'commander';
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+import { TypeORMModule } from '../../typeorm/typeorm-module';
 
 export class MigrateCommand {
-  async execute(action?: string): Promise<void> {
-    if (!action) {
-      const answer = await inquirer.prompt([
-        {
-          type: 'list',
-          name: 'action',
-          message: 'Select migration action:',
-          choices: [
-            { name: 'Run pending migrations', value: 'run' },
-            { name: 'Generate new migration', value: 'generate' },
-            { name: 'Revert last migration', value: 'revert' },
-            { name: 'Show migration status', value: 'show' }
-          ]
-        }
-      ]);
-      action = answer.action;
-    }
+  static register(program: Command): void {
+    program
+      .command('migrate')
+      .description('Run all pending migrations')
+      .action(async () => {
+        await this.runMigrations();
+      });
 
-    switch (action) {
-      case 'run':
+    program
+      .command('migrate:create <name>')
+      .description('Create a new migration')
+      .action(async (name) => {
+        await this.createMigration(name);
+      });
+
+    program
+      .command('migrate:run')
+      .description('Run pending migrations')
+      .action(async () => {
         await this.runMigrations();
-        break;
-      case 'generate':
-        await this.generateMigration();
-        break;
-      case 'revert':
+      });
+
+    program
+      .command('migrate:revert')
+      .description('Revert the last migration')
+      .action(async () => {
         await this.revertMigration();
-        break;
-      case 'show':
-        await this.showMigrations();
-        break;
-      default:
-        CLILogger.error(`Unknown action: ${action}`);
-    }
+      });
+
+    program
+      .command('migrate:refresh')
+      .description('Rollback all migrations and re-run them')
+      .action(async () => {
+        await this.refreshMigrations();
+      });
+
+    program
+      .command('migrate:status')
+      .description('Show migration status')
+      .action(async () => {
+        await this.showStatus();
+      });
+
+    program
+      .command('schema:sync')
+      .description('Synchronize database schema')
+      .action(async () => {
+        await this.syncSchema();
+      });
+
+    program
+      .command('schema:drop')
+      .description('Drop database schema')
+      .action(async () => {
+        await this.dropSchema();
+      });
+
+    program
+      .command('seed')
+      .description('Run database seeds')
+      .action(async () => {
+        await this.runSeeds();
+      });
+
+    program
+      .command('seed:create <name>')
+      .description('Create a new seed file')
+      .action(async (name) => {
+        await this.createSeed(name);
+      });
   }
 
-  private async runMigrations(): Promise<void> {
-    CLILogger.title('📦 Running Migrations');
-    const spinner = CLILogger.spinner('Executing migrations...');
+  private static async createMigration(name: string): Promise<void> {
+    const spinner = ora('Creating migration...').start();
+    
+    try {
+      const timestamp = Date.now();
+      const fileName = `${timestamp}-${name}.ts`;
+      const filePath = path.join(process.cwd(), 'src', 'migrations', fileName);
 
+      const content = `import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class ${name}${timestamp} implements MigrationInterface {
+  async up(queryRunner: QueryRunner): Promise<void> {
+    // Add migration code here
+  }
+
+  async down(queryRunner: QueryRunner): Promise<void> {
+    // Add revert code here
+  }
+}
+`;
+
+      await fs.ensureDir(path.dirname(filePath));
+      await fs.writeFile(filePath, content);
+      
+      spinner.succeed(`Migration created: ${fileName}`);
+    } catch (error) {
+      spinner.fail('Failed to create migration');
+      console.error(chalk.red(error));
+    }
+  }
+
+  private static async runMigrations(): Promise<void> {
+    const spinner = ora('Running migrations...').start();
+    
     try {
-      execSync('npm run typeorm migration:run', { stdio: 'pipe' });
-      spinner.succeed('Migrations executed successfully');
-    } catch (error: any) {
+      await TypeORMModule.initialize();
+      await TypeORMModule.runMigrations();
+      spinner.succeed('Migrations completed successfully');
+    } catch (error) {
       spinner.fail('Migration failed');
-      CLILogger.error(error.message);
+      console.error(chalk.red(error));
     }
   }
 
-  private async generateMigration(): Promise<void> {
-    const answer = await inquirer.prompt([
-      {
-        type: 'input',
-        name: 'name',
-        message: 'Migration name:',
-        validate: (input: string) => {
-          if (!input) return 'Name is required';
-          return true;
-        }
-      }
-    ]);
-
-    CLILogger.title(`📝 Generating Migration: ${answer.name}`);
-    const spinner = CLILogger.spinner('Creating migration file...');
+  private static async revertMigration(): Promise<void> {
+    const spinner = ora('Reverting migration...').start();
+    
+    try {
+      await TypeORMModule.initialize();
+      await TypeORMModule.revertMigration();
+      spinner.succeed('Migration reverted successfully');
+    } catch (error) {
+      spinner.fail('Revert failed');
+      console.error(chalk.red(error));
+    }
+  }
 
+  private static async refreshMigrations(): Promise<void> {
+    const spinner = ora('Refreshing migrations...').start();
+    
     try {
-      execSync(`npm run typeorm migration:generate -- -n ${answer.name}`, { stdio: 'pipe' });
-      spinner.succeed('Migration generated successfully');
-    } catch (error: any) {
-      spinner.fail('Failed to generate migration');
-      CLILogger.error(error.message);
+      await TypeORMModule.initialize();
+      await TypeORMModule.dropSchema();
+      await TypeORMModule.runMigrations();
+      spinner.succeed('Migrations refreshed successfully');
+    } catch (error) {
+      spinner.fail('Refresh failed');
+      console.error(chalk.red(error));
     }
   }
 
-  private async revertMigration(): Promise<void> {
-    const confirm = await inquirer.prompt([
-      {
-        type: 'confirm',
-        name: 'confirmed',
-        message: 'Are you sure you want to revert the last migration?',
-        default: false
-      }
-    ]);
+  private static async showStatus(): Promise<void> {
+    console.log(chalk.blue('Migration Status:'));
+    console.log('  Implement status checking using TypeORM QueryRunner');
+  }
 
-    if (!confirm.confirmed) {
-      CLILogger.info('Migration revert cancelled');
-      return;
+  private static async syncSchema(): Promise<void> {
+    const spinner = ora('Synchronizing schema...').start();
+    
+    try {
+      await TypeORMModule.initialize();
+      await TypeORMModule.syncSchema();
+      spinner.succeed('Schema synchronized');
+    } catch (error) {
+      spinner.fail('Sync failed');
+      console.error(chalk.red(error));
     }
+  }
 
-    CLILogger.title('⏪ Reverting Migration');
-    const spinner = CLILogger.spinner('Reverting last migration...');
-
+  private static async dropSchema(): Promise<void> {
+    const spinner = ora('Dropping schema...').start();
+    
     try {
-      execSync('npm run typeorm migration:revert', { stdio: 'pipe' });
-      spinner.succeed('Migration reverted successfully');
-    } catch (error: any) {
-      spinner.fail('Failed to revert migration');
-      CLILogger.error(error.message);
+      await TypeORMModule.initialize();
+      await TypeORMModule.dropSchema();
+      spinner.succeed('Schema dropped');
+    } catch (error) {
+      spinner.fail('Drop failed');
+      console.error(chalk.red(error));
     }
   }
 
-  private async showMigrations(): Promise<void> {
-    CLILogger.title('📋 Migration Status');
+  private static async runSeeds(): Promise<void> {
+    const spinner = ora('Running seeds...').start();
     
     try {
-      const output = execSync('npm run typeorm migration:show', { encoding: 'utf-8' });
-      console.log(output);
-    } catch (error: any) {
-      CLILogger.error('Failed to show migrations');
+      const seedsDir = path.join(process.cwd(), 'dist', 'seeds');
+      
+      if (fs.existsSync(seedsDir)) {
+        const files = fs.readdirSync(seedsDir);
+        
+        for (const file of files) {
+          if (file.endsWith('.js')) {
+            const seedModule = require(path.join(seedsDir, file));
+            if (seedModule.default && typeof seedModule.default.run === 'function') {
+              await seedModule.default.run();
+            }
+          }
+        }
+      }
+      
+      spinner.succeed('Seeds completed successfully');
+    } catch (error) {
+      spinner.fail('Seed failed');
+      console.error(chalk.red(error));
     }
   }
+
+  private static async createSeed(name: string): Promise<void> {
+    const spinner = ora('Creating seed...').start();
+    
+    try {
+      const fileName = `${name}.seed.ts`;
+      const filePath = path.join(process.cwd(), 'src', 'seeds', fileName);
+
+      const content = `export default class ${name}Seed {
+  static async run() {
+    console.log('Running ${name} seed...');
+    // Add seed logic here
+  }
 }
+`;
+
+      await fs.ensureDir(path.dirname(filePath));
+      await fs.writeFile(filePath, content);
+      
+      spinner.succeed(`Seed created: ${fileName}`);
+    } catch (error) {
+      spinner.fail('Failed to create seed');
+      console.error(chalk.red(error));
+    }
+  }
+}

package/src/cli/commands/serve.command.ts

@@ -1,37 +1,189 @@
-
-import { spawn } from 'child_process';
-import { CLILogger } from '../utils/logger';
+import { Command } from "commander";
+import { spawn, ChildProcess, execSync } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+import chalk from "chalk";
 
 export class ServeCommand {
-  async execute(options: { port?: number; watch?: boolean }): Promise<void> {
-    CLILogger.title('🚀 Starting Fragment Application');
+  static register(program: Command): void {
+    program
+      .command("serve")
+      .description("Start the development server")
+      .option("-w, --watch", "Watch for changes", true)
+      .option("-p, --port <port>", "Port to run on", "3000")
+      .action(async (options) => {
+        await ServeCommand.execute(options);
+      });
+  }
+
+  static async execute(options: any): Promise<void> {
+    console.log(chalk.blue("🚀 Starting Fragment development server...\n"));
+
+    const mainFile = path.join(process.cwd(), "src", "main.ts");
 
-    const port = options.port || process.env.PORT || 3000;
-    const args = ['--respawn', '--transpile-only'];
+    if (!fs.existsSync(mainFile)) {
+      console.error(chalk.red("Main file not found at src/main.ts"));
+      process.exit(1);
+    }
 
-    if (options.watch !== false) {
-      args.push('--watch');
+    // Find ts-node
+    const tsNode = this.findTsNode();
+    if (!tsNode) {
+      console.error(chalk.red("ts-node not found. Install it:"));
+      console.log(chalk.cyan("  npm install --save-dev ts-node"));
+      process.exit(1);
     }
 
-    args.push('src/server.ts');
+    let appProcess: ChildProcess | null = null;
+    let isRestarting = false;
+
+    const startServer = () => {
+      if (isRestarting) return;
+
+      // Use ts-node directly instead of node with -r flag
+      appProcess = spawn(tsNode, [mainFile], {
+        stdio: "inherit",
+        env: { ...process.env, PORT: options.port },
+      });
+
+      appProcess.on("error", (error) => {
+        console.error(chalk.red(`Failed to start server: ${error.message}`));
+      });
 
-    const env = { ...process.env, PORT: port.toString() };
+      appProcess.on("exit", (code, signal) => {
+        if (!isRestarting && signal !== "SIGTERM" && signal !== "SIGINT") {
+          console.error(chalk.red(`Server exited with code ${code}`));
+        }
+      });
+    };
 
-    CLILogger.info(`Starting server on port ${port}...`);
+    const killServer = (): Promise<void> => {
+      return new Promise((resolve) => {
+        if (!appProcess || appProcess.killed) {
+          resolve();
+          return;
+        }
 
-    const child = spawn('ts-node-dev', args, {
-      env,
-      stdio: 'inherit'
-    });
+        const timeout = setTimeout(() => {
+          if (appProcess && !appProcess.killed) {
+            console.log(chalk.yellow("Force killing server..."));
+            appProcess.kill("SIGKILL");
+          }
+          resolve();
+        }, 3000);
 
-    child.on('error', (error) => {
-      CLILogger.error(`Failed to start server: ${error.message}`);
-    });
+        appProcess.once("exit", () => {
+          clearTimeout(timeout);
+          appProcess = null;
+          resolve();
+        });
 
-    child.on('close', (code) => {
-      if (code !== 0) {
-        CLILogger.error(`Server exited with code ${code}`);
+        appProcess.kill("SIGTERM");
+      });
+    };
+
+    const restartServer = async (filePath?: string) => {
+      if (isRestarting) return;
+      isRestarting = true;
+
+      if (filePath) {
+        console.log(
+          chalk.yellow(
+            `\n🔄 File changed: ${path.relative(process.cwd(), filePath)}`,
+          ),
+        );
       }
-    });
+      console.log(chalk.blue("Restarting server...\n"));
+
+      await killServer();
+
+      // Wait a bit for port to be released
+      await new Promise((resolve) => setTimeout(resolve, 500));
+
+      isRestarting = false;
+      startServer();
+    };
+
+    // Start initial server
+    startServer();
+
+    // Watch for changes
+    if (options.watch) {
+      try {
+        const chokidar = await import("chokidar");
+
+        const watcher = chokidar.watch("src/**/*.ts", {
+          ignored: /(^|[/\\])\../,
+          persistent: true,
+          ignoreInitial: true,
+        });
+
+        let debounceTimer: NodeJS.Timeout | null = null;
+
+        watcher.on("change", (filePath) => {
+          // Debounce rapid changes
+          if (debounceTimer) {
+            clearTimeout(debounceTimer);
+          }
+
+          debounceTimer = setTimeout(() => {
+            restartServer(filePath);
+          }, 300);
+        });
+
+        watcher.on("error", (error) => {
+          console.error(chalk.red(`Watcher error: ${error}`));
+        });
+
+        // Cleanup on exit
+        const cleanup = async () => {
+          console.log(chalk.yellow("\n\n🛑 Shutting down..."));
+          watcher.close();
+          await killServer();
+          process.exit(0);
+        };
+
+        process.on("SIGINT", cleanup);
+        process.on("SIGTERM", cleanup);
+      } catch (error) {
+        console.error(
+          chalk.red(
+            "Failed to start file watcher. Install chokidar: npm install chokidar",
+          ),
+        );
+        process.exit(1);
+      }
+    } else {
+      // No watch mode - just handle cleanup
+      const cleanup = async () => {
+        await killServer();
+        process.exit(0);
+      };
+
+      process.on("SIGINT", cleanup);
+      process.on("SIGTERM", cleanup);
+    }
+  }
+
+  private static findTsNode(): string | null {
+    // Try local ts-node
+    const localTsNode = path.join(
+      process.cwd(),
+      "node_modules",
+      ".bin",
+      process.platform === "win32" ? "ts-node.cmd" : "ts-node",
+    );
+
+    if (fs.existsSync(localTsNode)) {
+      return localTsNode;
+    }
+
+    // Try global ts-node
+    try {
+      execSync("ts-node --version", { stdio: "ignore" });
+      return "ts-node";
+    } catch {
+      return null;
+    }
   }
-}
+}

package/src/cli/index.ts

@@ -0,0 +1,23 @@
+import { Command } from 'commander';
+import { InitCommand } from './commands/init.command';
+import { GenerateCommand } from './commands/generate.command';
+import { ServeCommand } from './commands/serve.command';
+import { BuildCommand } from './commands/build.command';
+import { MigrateCommand } from './commands/migrate.command';
+import { DiagnosticsCommand } from './commands/diagnostics.command';
+
+const program = new Command();
+
+program
+  .name('fragment')
+  .description('Fragment Framework CLI')
+  .version('1.0.0');
+
+InitCommand.register(program);
+GenerateCommand.register(program);
+ServeCommand.register(program);
+BuildCommand.register(program);
+MigrateCommand.register(program);
+DiagnosticsCommand.register(program);
+
+program.parse();