fragment-ts 1.0.2 → 1.0.3

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

@@ -1,170 +1,239 @@
-
+import { Command } from 'commander';
+import * as fs from 'fs-extra';
 import * as path from 'path';
-import { CLILogger } from '../utils/logger';
-import { FileGenerator } from '../utils/file-generator';
-import inquirer from 'inquirer';
-import { controllerTemplate } from '../templates/controller.template';
-import { entityTemplate } from '../templates/entity.template';
-import { repositoryTemplate } from '../templates/repository.template';
-import { serviceTemplate } from '../templates/service.template';
+import chalk from 'chalk';
+import ora from 'ora';
 
 export class GenerateCommand {
-  async execute(type: string, name?: string): Promise<void> {
-    if (!name) {
-      const answer = await inquirer.prompt([
-        {
-          type: 'input',
-          name: 'name',
-          message: `Enter ${type} name:`,
-          validate: (input: string) => {
-            if (!input) return 'Name is required';
-            return true;
-          }
-        }
-      ]);
-      name = answer.name;
-    }
+  static register(program: Command): void {
+    program
+      .command('generate <type> <name>')
+      .alias('g')
+      .description('Generate a new resource')
+      .option('--with-repository', 'Generate repository for service')
+      .action(async (type, name, options) => {
+        await GenerateCommand.execute(type, name, options);
+      });
+  }
 
-    const pascalName = FileGenerator.toPascalCase(name!);
-    const kebabName = FileGenerator.toKebabCase(name!);
-
-    switch (type) {
-      case 'controller':
-        await this.generateController(pascalName, kebabName);
-        break;
-      case 'service':
-        await this.generateService(pascalName, kebabName);
-        break;
-      case 'repository':
-        await this.generateRepository(pascalName, kebabName);
-        break;
-      case 'entity':
-        await this.generateEntity(pascalName, kebabName);
-        break;
-      case 'resource':
-        await this.generateResource(pascalName, kebabName);
-        break;
-      default:
-        CLILogger.error(`Unknown type: ${type}`);
-        CLILogger.info('Available types: controller, service, repository, entity, resource');
+  static async execute(type: string, name: string, options: any): Promise<void> {
+    const spinner = ora();
+    
+    try {
+      spinner.start(`Generating ${type}...`);
+      
+      switch (type) {
+        case 'controller':
+          await this.generateController(name);
+          break;
+        case 'service':
+          await this.generateService(name, options.withRepository);
+          break;
+        case 'resource':
+          await this.generateResource(name);
+          break;
+        case 'entity':
+          await this.generateEntity(name);
+          break;
+        case 'dto':
+          await this.generateDto(name);
+          break;
+        case 'repository':
+          await this.generateRepository(name);
+          break;
+        default:
+          spinner.fail(`Unknown type: ${type}`);
+          return;
+      }
+      
+      spinner.succeed(`${type} generated successfully!`);
+    } catch (error) {
+      spinner.fail(`Failed to generate ${type}`);
+      console.error(chalk.red(error));
     }
   }
 
-  private async generateController(name: string, fileName: string): Promise<void> {
-    const answers = await inquirer.prompt([
-      {
-        type: 'input',
-        name: 'route',
-        message: 'Route path:',
-        default: `/api/${fileName}s`
-      }
-    ]);
+  private static async generateController(name: string): Promise<void> {
+    const className = this.capitalize(name) + 'Controller';
+    const fileName = this.kebabCase(name) + '.controller.ts';
+    const filePath = path.join(process.cwd(), 'src', 'controllers', fileName);
 
-    const filePath = path.join(process.cwd(), 'src/controllers', `${fileName}.controller.ts`);
-    
-    if (FileGenerator.fileExists(filePath)) {
-      CLILogger.error(`Controller ${name} already exists`);
-      return;
-    }
+    const content = `import { Controller, Get, Post, Put, Delete, Body, Param } from 'fragment-ts';
 
-    const content = controllerTemplate(name, answers.route);
-    FileGenerator.writeFile(filePath, content);
+@Controller('/${this.kebabCase(name)}')
+export class ${className} {
+  @Get()
+  findAll() {
+    return [];
+  }
 
-    CLILogger.success(`Controller created: src/controllers/${fileName}.controller.ts`);
-    CLILogger.info(`Route: ${answers.route}`);
+  @Get('/:id')
+  findOne(@Param('id') id: string) {
+    return { id };
   }
 
-  private async generateService(name: string, fileName: string): Promise<void> {
-    const filePath = path.join(process.cwd(), 'src/services', `${fileName}.service.ts`);
-    
-    if (FileGenerator.fileExists(filePath)) {
-      CLILogger.error(`Service ${name} already exists`);
-      return;
-    }
+  @Post()
+  create(@Body() body: any) {
+    return body;
+  }
 
-    const content = serviceTemplate(name);
-    FileGenerator.writeFile(filePath, content);
+  @Put('/:id')
+  update(@Param('id') id: string, @Body() body: any) {
+    return { id, ...body };
+  }
 
-    CLILogger.success(`Service created: src/services/${fileName}.service.ts`);
+  @Delete('/:id')
+  delete(@Param('id') id: string) {
+    return { deleted: true, id };
   }
+}
+`;
 
-  private async generateRepository(name: string, fileName: string): Promise<void> {
-    const answers = await inquirer.prompt([
-      {
-        type: 'input',
-        name: 'entity',
-        message: 'Entity name:',
-        default: name.replace('Repository', '')
-      }
-    ]);
+    await fs.ensureDir(path.dirname(filePath));
+    await fs.writeFile(filePath, content);
+  }
 
-    const filePath = path.join(process.cwd(), 'src/repositories', `${fileName}.repository.ts`);
+  private static async generateService(name: string, withRepository: boolean): Promise<void> {
+    const className = this.capitalize(name) + 'Service';
+    const fileName = this.kebabCase(name) + '.service.ts';
+    const filePath = path.join(process.cwd(), 'src', 'services', fileName);
+
+    let imports = "import { Service } from 'fragment-ts';\n";
+    let repositoryProp = '';
     
-    if (FileGenerator.fileExists(filePath)) {
-      CLILogger.error(`Repository ${name} already exists`);
-      return;
+    if (withRepository) {
+      const repoName = this.capitalize(name) + 'Repository';
+      imports += `import { ${repoName} } from '../repositories/${this.kebabCase(name)}.repository';\n`;
+      repositoryProp = `\n  constructor(private ${this.camelCase(name)}Repository: ${repoName}) {}\n`;
     }
 
-    const content = repositoryTemplate(name, answers.entity);
-    FileGenerator.writeFile(filePath, content);
+    const content = `${imports}
+@Service()
+export class ${className} {${repositoryProp}
+  async findAll() {
+    return [];
+  }
 
-    CLILogger.success(`Repository created: src/repositories/${fileName}.repository.ts`);
+  async findOne(id: string) {
+    return { id };
   }
 
-  private async generateEntity(name: string, fileName: string): Promise<void> {
-    const filePath = path.join(process.cwd(), 'src/entities', `${fileName}.entity.ts`);
+  async create(data: any) {
+    return data;
+  }
+
+  async update(id: string, data: any) {
+    return { id, ...data };
+  }
+
+  async delete(id: string) {
+    return { deleted: true, id };
+  }
+}
+`;
+
+    await fs.ensureDir(path.dirname(filePath));
+    await fs.writeFile(filePath, content);
     
-    if (FileGenerator.fileExists(filePath)) {
-      CLILogger.error(`Entity ${name} already exists`);
-      return;
+    if (withRepository) {
+      await this.generateRepository(name);
     }
+  }
+
+  private static async generateResource(name: string): Promise<void> {
+    await this.generateController(name);
+    await this.generateService(name, true);
+    await this.generateEntity(name);
+    await this.generateDto(name);
+  }
 
-    const content = entityTemplate(name);
-    FileGenerator.writeFile(filePath, content);
+  private static async generateEntity(name: string): Promise<void> {
+    const className = this.capitalize(name);
+    const fileName = this.kebabCase(name) + '.entity.ts';
+    const filePath = path.join(process.cwd(), 'src', 'entities', fileName);
 
-    CLILogger.success(`Entity created: src/entities/${fileName}.entity.ts`);
+    const content = `import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';
+
+@Entity()
+export class ${className} {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column()
+  name: string;
+
+  @Column({ type: 'timestamp', default: () => 'CURRENT_TIMESTAMP' })
+  createdAt: Date;
+
+  @Column({ type: 'timestamp', default: () => 'CURRENT_TIMESTAMP', onUpdate: 'CURRENT_TIMESTAMP' })
+  updatedAt: Date;
+}
+`;
+
+    await fs.ensureDir(path.dirname(filePath));
+    await fs.writeFile(filePath, content);
   }
 
-  private async generateResource(name: string, fileName: string): Promise<void> {
-    CLILogger.title(`🔷 Generating resource: ${name}`);
+  private static async generateDto(name: string): Promise<void> {
+    const className = 'Create' + this.capitalize(name) + 'Dto';
+    const fileName = 'create-' + this.kebabCase(name) + '.dto.ts';
+    const filePath = path.join(process.cwd(), 'src', 'dto', fileName);
 
-    const spinner = CLILogger.spinner('Generating files...');
+    const content = `export class ${className} {
+  name: string;
+}
+`;
 
-    try {
-      // Generate entity
-      const entityPath = path.join(process.cwd(), 'src/entities', `${fileName}.entity.ts`);
-      FileGenerator.writeFile(entityPath, entityTemplate(name));
-      spinner.text = 'Entity created...';
-
-      // Generate repository
-      const repoPath = path.join(process.cwd(), 'src/repositories', `${fileName}.repository.ts`);
-      FileGenerator.writeFile(repoPath, repositoryTemplate(name + 'Repository', name));
-      spinner.text = 'Repository created...';
-
-      // Generate service
-      const servicePath = path.join(process.cwd(), 'src/services', `${fileName}.service.ts`);
-      FileGenerator.writeFile(servicePath, serviceTemplate(name + 'Service'));
-      spinner.text = 'Service created...';
-
-      // Generate controller
-      const controllerPath = path.join(process.cwd(), 'src/controllers', `${fileName}.controller.ts`);
-      FileGenerator.writeFile(controllerPath, controllerTemplate(name + 'Controller', `/api/${fileName}s`));
-      spinner.text = 'Controller created...';
-
-      spinner.succeed('Resource generated successfully');
-
-      CLILogger.box('📦 Generated Files', [
-        `Entity: src/entities/${fileName}.entity.ts`,
-        `Repository: src/repositories/${fileName}.repository.ts`,
-        `Service: src/services/${fileName}.service.ts`,
-        `Controller: src/controllers/${fileName}.controller.ts`
-      ]);
-
-      CLILogger.info(`\nRoute available at: /api/${fileName}s`);
-
-    } catch (error: any) {
-      spinner.fail('Failed to generate resource');
-      CLILogger.error(error.message);
-    }
+    await fs.ensureDir(path.dirname(filePath));
+    await fs.writeFile(filePath, content);
+  }
+
+  private static async generateRepository(name: string): Promise<void> {
+    const className = this.capitalize(name) + 'Repository';
+    const entityName = this.capitalize(name);
+    const fileName = this.kebabCase(name) + '.repository.ts';
+    const filePath = path.join(process.cwd(), 'src', 'repositories', fileName);
+
+    const content = `import { Repository } from 'fragment-ts';
+import { ${entityName} } from '../entities/${this.kebabCase(name)}.entity';
+
+@Repository()
+export class ${className} {
+  async findAll(): Promise<${entityName}[]> {
+    return [];
+  }
+
+  async findById(id: number): Promise<${entityName} | null> {
+    return null;
+  }
+
+  async create(data: Partial<${entityName}>): Promise<${entityName}> {
+    return data as ${entityName};
+  }
+
+  async update(id: number, data: Partial<${entityName}>): Promise<${entityName} | null> {
+    return null;
+  }
+
+  async delete(id: number): Promise<boolean> {
+    return true;
+  }
+}
+`;
+
+    await fs.ensureDir(path.dirname(filePath));
+    await fs.writeFile(filePath, content);
+  }
+
+  private static capitalize(str: string): string {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  }
+
+  private static kebabCase(str: string): string {
+    return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+  }
+
+  private static camelCase(str: string): string {
+    return str.charAt(0).toLowerCase() + str.slice(1);
   }
 }