fragment-ts 1.0.2 → 1.0.3

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

@@ -1,395 +1,383 @@
-
-import * as fs from 'fs';
-import * as path from 'path';
-import { execSync } from 'child_process';
-import { CLILogger } from '../utils/logger';
-import { FileGenerator } from '../utils/file-generator';
-import inquirer from 'inquirer';
-import chalk from 'chalk';
+import { Command } from "commander";
+import * as fs from "fs-extra";
+import * as path from "path";
+import inquirer from "inquirer";
+import ora from "ora";
+import chalk from "chalk";
+import { execSync } from "child_process";
 
 export class InitCommand {
-  async execute(projectName?: string): Promise<void> {
-    CLILogger.title('🔷 Fragment Framework Initializer');
-
-    const answers = await inquirer.prompt([
-      {
-        type: 'input',
-        name: 'projectName',
-        message: 'Project name:',
-        default: projectName || 'my-fragment-app',
-        validate: (input: string) => {
-          if (!/^[a-z0-9-]+$/.test(input)) {
-            return 'Project name must contain only lowercase letters, numbers, and hyphens';
-          }
-          return true;
+  static register(program: Command): void {
+    program
+      .command("init [directory]")
+      .description("Initialize a new Fragment project")
+      .option("-t, --template <template>", "Project template", "api")
+      .option(
+        "-f, --features <features>",
+        "Features to include (comma-separated)",
+      )
+      .option("--skip-install", "Skip npm install")
+      .action(async (directory, options) => {
+        await InitCommand.execute(directory || ".", options);
+      });
+  }
+
+  static async execute(directory: string, options: any): Promise<void> {
+    const spinner = ora();
+
+    try {
+      const projectPath = path.resolve(process.cwd(), directory);
+      const projectName = path.basename(projectPath);
+
+      spinner.start("Creating project directory...");
+      await fs.ensureDir(projectPath);
+      spinner.succeed();
+
+      const answers = await inquirer.prompt([
+        {
+          type: "input",
+          name: "name",
+          message: "Project name:",
+          default: projectName,
+        },
+        {
+          type: "input",
+          name: "description",
+          message: "Project description:",
+          default: "A Fragment Framework project",
+        },
+        {
+          type: "checkbox",
+          name: "features",
+          message: "Select features:",
+          choices: [
+            { name: "Authentication", value: "auth", checked: true },
+            { name: "Database (TypeORM)", value: "database", checked: true },
+            { name: "AI Integration", value: "ai", checked: false },
+            { name: "Testing", value: "testing", checked: true },
+          ],
+        },
+      ]);
+
+      const features = options.features
+        ? options.features.split(",").map((f: string) => f.trim())
+        : answers.features;
+
+      spinner.start("Generating project files...");
+      await this.generateProjectStructure(projectPath, {
+        name: answers.name,
+        description: answers.description,
+        template: options.template,
+        features,
+      });
+      spinner.succeed();
+
+      spinner.start("Creating configuration files...");
+      await this.createConfigFiles(projectPath, answers.name, features);
+      spinner.succeed();
+
+      if (!options.skipInstall) {
+        spinner.start("Installing dependencies...");
+        try {
+          execSync("npm install", { cwd: projectPath, stdio: "ignore" });
+          spinner.succeed();
+        } catch (error) {
+          spinner.fail("Failed to install dependencies");
+          console.log(
+            chalk.yellow(
+              "You can install them manually by running: npm install",
+            ),
+          );
         }
-      },
-      {
-        type: 'list',
-        name: 'database',
-        message: 'Select database:',
-        choices: ['PostgreSQL', 'MySQL', 'SQLite', 'MongoDB'],
-        default: 'PostgreSQL'
-      },
-      {
-        type: 'confirm',
-        name: 'useOpenAI',
-        message: 'Enable OpenAI integration?',
-        default: true
-      },
-      {
-        type: 'confirm',
-        name: 'useAuth',
-        message: 'Include authentication system?',
-        default: true
-      },
-      {
-        type: 'list',
-        name: 'packageManager',
-        message: 'Package manager:',
-        choices: ['npm', 'yarn', 'pnpm'],
-        default: 'npm'
       }
-    ]);
 
-    const projectPath = path.join(process.cwd(), answers.projectName);
+      console.log("\n" + chalk.green("✨ Project created successfully!"));
+      console.log("\nNext steps:");
+      if (directory !== ".") {
+        console.log(chalk.cyan(`  cd ${directory}`));
+      }
+      if (options.skipInstall) {
+        console.log(chalk.cyan("  npm install"));
+      }
+      console.log(chalk.cyan("  fragment serve"));
+      console.log("");
+    } catch (error) {
+      spinner.fail("Failed to initialize project");
+      console.error(chalk.red(error));
+      process.exit(1);
+    }
+  }
 
-    if (fs.existsSync(projectPath)) {
-      CLILogger.error(`Directory ${answers.projectName} already exists`);
-      return;
+  private static async generateProjectStructure(
+    projectPath: string,
+    config: any,
+  ): Promise<void> {
+    const dirs = [
+      "src",
+      "src/controllers",
+      "src/services",
+      "src/entities",
+      "src/dto",
+      "src/repositories",
+      "src/middlewares",
+      "src/config",
+    ];
+
+    if (config.features.includes("database")) {
+      dirs.push("src/migrations");
+      dirs.push("src/seeds");
     }
 
-    const spinner = CLILogger.spinner('Creating project structure...');
+    if (config.features.includes("testing")) {
+      dirs.push("test");
+    }
 
-    try {
-      // Create project directory
-      FileGenerator.createDirectory(projectPath);
-
-      // Create directory structure
-      const dirs = [
-        'src/controllers',
-        'src/services',
-        'src/repositories',
-        'src/entities',
-        'src/middlewares',
-        'src/core/decorators',
-        'src/core/container',
-        'src/core/config',
-        'src/database',
-        'config'
-      ];
-
-      if (answers.useOpenAI) {
-        dirs.push('src/core/openai');
-      }
+    for (const dir of dirs) {
+      await fs.ensureDir(path.join(projectPath, dir));
+    }
 
-      if (answers.useAuth) {
-        dirs.push('src/auth', 'src/auth/dto');
-      }
+    await this.generateMainFile(projectPath, config);
+    await this.generateExampleController(projectPath);
+    await this.generateExampleService(projectPath);
 
-      dirs.forEach(dir => {
-        FileGenerator.createDirectory(path.join(projectPath, dir));
-      });
+    if (config.features.includes("database")) {
+      await this.generateExampleEntity(projectPath);
+    }
 
-      spinner.text = 'Generating configuration files...';
-
-      // Generate package.json
-      const packageJson = {
-        name: answers.projectName,
-        version: '1.0.0',
-        description: 'Fragment Framework Application',
-        main: 'dist/server.js',
-        scripts: {
-          dev: 'ts-node-dev --respawn --transpile-only src/server.ts',
-          build: 'tsc',
-          start: 'node dist/server.js',
-          'frg:generate': 'frg generate',
-          'frg:migrate': 'frg migrate'
-        },
-        dependencies: {
-          express: '^4.18.2',
-          typeorm: '^0.3.17',
-          'reflect-metadata': '^0.1.13',
-          bcrypt: '^5.1.1',
-          'js-yaml': '^4.1.0',
-          pino: '^8.16.0',
-          'pino-pretty': '^10.2.3'
-        },
-        devDependencies: {
-          '@types/express': '^4.17.20',
-          '@types/node': '^20.9.0',
-          '@types/bcrypt': '^5.0.2',
-          '@types/js-yaml': '^4.0.9',
-          typescript: '^5.2.2',
-          'ts-node': '^10.9.1',
-          'ts-node-dev': '^2.0.0'
-        }
-      };
+    if (config.features.includes("auth")) {
+      await this.generateAuthFiles(projectPath);
+    }
+  }
 
-      // Add database driver
-      const dbDrivers: { [key: string]: string } = {
-        'PostgreSQL': 'pg@^8.11.3',
-        'MySQL': 'mysql2@^3.6.5',
-        'SQLite': 'sqlite3@^5.1.6',
-        'MongoDB': 'mongodb@^6.3.0'
-      };
-      packageJson.dependencies = {
-        ...packageJson.dependencies,
-        [dbDrivers[answers.database].split('@')[0]]: dbDrivers[answers.database].split('@')[1]
-      };
+  private static async createConfigFiles(
+    projectPath: string,
+    projectName: string,
+    features: string[],
+  ): Promise<void> {
+    const packageJson = {
+      name: projectName,
+      version: "1.0.0",
+      main: "dist/main.js",
+      scripts: {
+        start: "node dist/main.js",
+        dev: "fragment serve",
+        build: "fragment build",
+        test: "fragment test",
+      },
+      dependencies: {
+        fragment: "^1.0.0",
+        "reflect-metadata": "^0.1.13",
+      },
+      devDependencies: {
+        typescript: "^5.3.3",
+        "@types/node": "^20.10.5",
+      },
+    };
 
-      FileGenerator.writeFile(
-        path.join(projectPath, 'package.json'),
-        JSON.stringify(packageJson, null, 2)
-      );
-
-      // Generate tsconfig.json
-      const tsConfig = {
-        compilerOptions: {
-          target: 'ES2020',
-          module: 'commonjs',
-          lib: ['ES2020'],
-          outDir: './dist',
-          rootDir: './src',
-          strict: true,
-          esModuleInterop: true,
-          skipLibCheck: true,
-          forceConsistentCasingInFileNames: true,
-          resolveJsonModule: true,
-          experimentalDecorators: true,
-          emitDecoratorMetadata: true,
-          moduleResolution: 'node',
-          allowSyntheticDefaultImports: true
-        },
-        include: ['src/**/*'],
-        exclude: ['node_modules', 'dist']
-      };
+    await fs.writeJSON(path.join(projectPath, "package.json"), packageJson, {
+      spaces: 2,
+    });
+
+    const tsConfig = {
+      compilerOptions: {
+        target: "ES2020",
+        module: "commonjs",
+        lib: ["ES2020"],
+        outDir: "./dist",
+        rootDir: "./src",
+        strict: true,
+        esModuleInterop: true,
+        experimentalDecorators: true,
+        emitDecoratorMetadata: true,
+        skipLibCheck: true,
+      },
+      include: ["src/**/*"],
+      exclude: ["node_modules", "dist"],
+    };
 
-      FileGenerator.writeFile(
-        path.join(projectPath, 'tsconfig.json'),
-        JSON.stringify(tsConfig, null, 2)
-      );
-
-      // Generate fragment.yaml
-      const dbConfig = this.getDatabaseConfig(answers.database);
-      const fragmentConfig = `app:
-  name: ${answers.projectName}
-  port: 3000
-  env: development
-
-database:
-${dbConfig}
-
-${answers.useOpenAI ? `openai:
-  apiKey: \${OPENAI_API_KEY}
-  model: gpt-4
-` : ''}
-${answers.useAuth ? `auth:
-  tokenExpiry: 7d
-  sessionExpiry: 30d
-` : ''}`;
-
-      FileGenerator.writeFile(
-        path.join(projectPath, 'config/fragment.yaml'),
-        fragmentConfig
-      );
-
-      // Generate .env.example
-      let envExample = `NODE_ENV=development
-PORT=3000
+    await fs.writeJSON(path.join(projectPath, "tsconfig.json"), tsConfig, {
+      spaces: 2,
+    });
 
-${this.getEnvTemplate(answers.database)}`;
+    const fragmentConfig: any = {
+      server: {
+        port: 3000,
+        host: "0.0.0.0",
+      },
+    };
 
-      if (answers.useOpenAI) {
-        envExample += '\nOPENAI_API_KEY=sk-your-openai-api-key';
-      }
+    if (features.includes("database")) {
+      fragmentConfig.database = {
+        type: "sqlite",
+        database: "database.sqlite",
+        synchronize: true,
+        logging: false,
+        entities: ["dist/**/*.entity.js"],
+        migrations: ["dist/migrations/**/*.js"],
+      };
+    }
 
-      FileGenerator.writeFile(
-        path.join(projectPath, '.env.example'),
-        envExample
-      );
-
-      // Generate .gitignore
-      const gitignore = `node_modules/
-dist/
-.env
-*.log
-.DS_Store
-config/fragment.lock.yaml`;
-
-      FileGenerator.writeFile(
-        path.join(projectPath, '.gitignore'),
-        gitignore
-      );
-
-      // Generate README.md
-      const readme = this.generateReadme(answers.projectName, answers);
-      FileGenerator.writeFile(
-        path.join(projectPath, 'README.md'),
-        readme
-      );
-
-      spinner.text = 'Copying core framework files...';
-
-      // Copy all core files (decorators, container, config, etc.)
-      await this.copyFrameworkCore(projectPath, answers);
-
-      spinner.succeed('Project structure created');
-
-      // Install dependencies
-      const installSpinner = CLILogger.spinner(`Installing dependencies with ${answers.packageManager}...`);
-      
-      try {
-        execSync(`cd ${projectPath} && ${answers.packageManager} install`, {
-          stdio: 'pipe'
-        });
-        installSpinner.succeed('Dependencies installed');
-      } catch (error) {
-        installSpinner.fail('Failed to install dependencies');
-        CLILogger.warning('You can install them manually by running:');
-        console.log(`  cd ${answers.projectName} && ${answers.packageManager} install`);
-      }
+    await fs.writeJSON(
+      path.join(projectPath, "fragment.json"),
+      fragmentConfig,
+      { spaces: 2 },
+    );
 
-      // Success message
-      CLILogger.box('🎉 Project Created Successfully!', [
-        `Project: ${answers.projectName}`,
-        `Location: ${projectPath}`,
-        `Database: ${answers.database}`,
-        `OpenAI: ${answers.useOpenAI ? 'Enabled' : 'Disabled'}`,
-        `Auth: ${answers.useAuth ? 'Enabled' : 'Disabled'}`
-      ]);
+    const envContent = `NODE_ENV=development
+PORT=3000
+JWT_SECRET=your-secret-key-change-this
+${features.includes("database") ? "DATABASE_URL=sqlite:database.sqlite" : ""}
+`;
 
-      console.log(chalk.bold('\nNext steps:'));
-      console.log(`  1. cd ${answers.projectName}`);
-      console.log(`  2. cp .env.example .env`);
-      console.log(`  3. Configure your database in .env`);
-      if (answers.useOpenAI) {
-        console.log(`  4. Add your OpenAI API key to .env`);
-      }
-      console.log(`  ${answers.useOpenAI ? '5' : '4'}. ${answers.packageManager} run dev`);
-
-      CLILogger.section('Available Commands:');
-      CLILogger.table({
-        'frg generate controller <name>': 'Generate a new controller',
-        'frg generate service <name>': 'Generate a new service',
-        'frg generate resource <name>': 'Generate controller, service, repository & entity',
-        'frg config ai': 'Configure OpenAI settings',
-        'frg migrate': 'Run database migrations',
-        'frg serve': 'Start development server'
-      });
+    await fs.writeFile(path.join(projectPath, ".env"), envContent);
+    await fs.writeFile(
+      path.join(projectPath, ".gitignore"),
+      "node_modules/\ndist/\n.env\n*.sqlite\n",
+    );
+  }
 
-    } catch (error: any) {
-      spinner.fail('Failed to create project');
-      CLILogger.error(error.message);
+  // In the generateMainFile method, update to:
+  private static async generateMainFile(
+    projectPath: string,
+    config: any,
+  ): Promise<void> {
+    const content = `import 'reflect-metadata';
+  import { FragmentApplication } from 'fragment-ts';
+  import { FragmentWebApplication } from 'fragment-ts';
+  import { AppController } from './controllers/app.controller';
+
+  @FragmentApplication({
+    port: 3000,
+    autoScan: true
+  })
+  class Application {
+    constructor() {
+      console.log('Fragment application initialized');
     }
   }
 
-  private getDatabaseConfig(database: string): string {
-    const configs: { [key: string]: string } = {
-      'PostgreSQL': `  type: postgres
-  host: \${DB_HOST:localhost}
-  port: \${DB_PORT:5432}
-  username: \${DB_USERNAME:postgres}
-  password: \${DB_PASSWORD:postgres}
-  database: \${DB_DATABASE:fragment_db}
-  synchronize: true
-  logging: false`,
-      'MySQL': `  type: mysql
-  host: \${DB_HOST:localhost}
-  port: \${DB_PORT:3306}
-  username: \${DB_USERNAME:root}
-  password: \${DB_PASSWORD:root}
-  database: \${DB_DATABASE:fragment_db}
-  synchronize: true
-  logging: false`,
-      'SQLite': `  type: sqlite
-  database: \${DB_DATABASE:database.sqlite}
-  synchronize: true
-  logging: false`,
-      'MongoDB': `  type: mongodb
-  host: \${DB_HOST:localhost}
-  port: \${DB_PORT:27017}
-  database: \${DB_DATABASE:fragment_db}
-  synchronize: true
-  logging: false`
-    };
-    return configs[database];
+  async function bootstrap() {
+    console.log('Starting Fragment application...');
+    const app = new FragmentWebApplication();
+    await app.bootstrap(Application);
   }
 
-  private getEnvTemplate(database: string): string {
-    if (database === 'SQLite') {
-      return 'DB_DATABASE=database.sqlite';
-    }
-    return `DB_HOST=localhost
-DB_PORT=${database === 'PostgreSQL' ? '5432' : database === 'MySQL' ? '3306' : '27017'}
-DB_USERNAME=${database === 'PostgreSQL' ? 'postgres' : 'root'}
-DB_PASSWORD=${database === 'PostgreSQL' ? 'postgres' : 'root'}
-DB_DATABASE=fragment_db`;
+  bootstrap().catch(console.error);
+  `;
+
+    await fs.writeFile(path.join(projectPath, "src", "main.ts"), content);
   }
 
-  private generateReadme(projectName: string, answers: any): string {
-    return `# ${projectName}
+  private static async generateExampleController(
+    projectPath: string,
+  ): Promise<void> {
+    const content = `import { Controller, Get } from 'fragment-ts';
 
-A Fragment Framework application.
+@Controller('/api')
+export class AppController {
+  @Get('/health')
+  health() {
+    return { status: 'ok', timestamp: new Date().toISOString() };
+  }
+}
+`;
 
-## Getting Started
+    await fs.writeFile(
+      path.join(projectPath, "src", "controllers", "app.controller.ts"),
+      content,
+    );
+  }
 
-\`\`\`bash
-# Install dependencies
-${answers.packageManager} install
+  private static async generateExampleService(
+    projectPath: string,
+  ): Promise<void> {
+    const content = `import { Service } from 'fragment-ts';
 
-# Configure environment
-cp .env.example .env
+@Service()
+export class AppService {
+  getMessage(): string {
+    return 'Welcome to Fragment Framework!';
+  }
+}
+`;
 
-# Start development server
-${answers.packageManager} run dev
-\`\`\`
+    await fs.writeFile(
+      path.join(projectPath, "src", "services", "app.service.ts"),
+      content,
+    );
+  }
 
-## Fragment CLI Commands
+  private static async generateExampleEntity(
+    projectPath: string,
+  ): Promise<void> {
+    const content = `import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';
 
-\`\`\`bash
-# Generate resources
-frg generate controller <name>    # Generate controller
-frg generate service <name>       # Generate service
-frg generate repository <name>    # Generate repository
-frg generate entity <name>        # Generate entity
-frg generate resource <name>      # Generate all of the above
+@Entity()
+export class User {
+  @PrimaryGeneratedColumn()
+  id: number;
 
-# Configuration
-frg config ai                     # Configure OpenAI settings
-frg config db                     # Configure database settings
+  @Column()
+  email: string;
 
-# Database
-frg migrate                       # Run migrations
+  @Column()
+  name: string;
 
-# Development
-frg serve                         # Start development server
-frg build                         # Build for production
-\`\`\`
+  @Column({ type: 'timestamp', default: () => 'CURRENT_TIMESTAMP' })
+  createdAt: Date;
+}
+`;
 
-## Project Structure
+    await fs.writeFile(
+      path.join(projectPath, "src", "entities", "user.entity.ts"),
+      content,
+    );
+  }
+
+  private static async generateAuthFiles(projectPath: string): Promise<void> {
+    const controllerContent = `import { Controller, Post, Body } from 'fragment-ts';
+import { AuthService } from '../services/auth.service';
 
-\`\`\`
-src/
-├── controllers/    # HTTP request handlers
-├── services/       # Business logic
-├── repositories/   # Data access layer
-├── entities/       # Database models
-├── middlewares/    # Express middlewares
-└── core/          # Framework core
-\`\`\`
+@Controller('/auth')
+export class AuthController {
+  constructor(private authService: AuthService) {}
 
-## Documentation
+  @Post('/login')
+  async login(@Body() body: any) {
+    return this.authService.login(body.email, body.password);
+  }
 
-Visit [Fragment Framework Documentation](https://fragment-framework.dev) for more information.
+  @Post('/register')
+  async register(@Body() body: any) {
+    return this.authService.register(body);
+  }
+}
 `;
+
+    const serviceContent = `import { Service } from 'fragment-ts';
+import { AuthModule } from 'fragment-ts';
+
+@Service()
+export class AuthService {
+  async login(email: string, password: string) {
+    const token = AuthModule.generateToken({ userId: '1', email });
+    return { token };
+  }
+
+  async register(userData: any) {
+    const hashedPassword = await AuthModule.hashPassword(userData.password);
+    return { message: 'User registered successfully' };
   }
+}
+`;
 
-  private async copyFrameworkCore(projectPath: string, answers: any): Promise<void> {
-    // This would copy all the core framework files
-    // For brevity, I'll show the structure
-    // In a real implementation, these would be actual file copies
-    
-    CLILogger.info('Core framework files copied');
+    await fs.writeFile(
+      path.join(projectPath, "src", "controllers", "auth.controller.ts"),
+      controllerContent,
+    );
+    await fs.writeFile(
+      path.join(projectPath, "src", "services", "auth.service.ts"),
+      serviceContent,
+    );
   }
-}
+}