flare-api/flareapi-installer.js

A modern, fast, and intuitive Node.js framework for building APIs

#!/usr/bin/env node
const inquirer = require('inquirer');
const fs = require('fs');
const path = require('path');
const execSync = require('child_process').execSync;
const themes = require('./themes/themes.json');  // Cargar el archivo JSON con las temáticas

// Preguntas iniciales para el asistente
async function init() {
  const answers = await inquirer.prompt([
    {
      type: 'input',
      name: 'projectName',
      message: '¿Cómo se llama tu proyecto?',
      default: 'my-flareapi-project',
    },
    {
      type: 'list',
      name: 'theme',
      message: '¿Cuál es la temática de tu proyecto?',
      choices: Object.keys(themes.themes),  // Cargar las temáticas del archivo JSON
    },
    {
      type: 'confirm',
      name: 'installSwagger',
      message: '¿Deseas instalar Swagger para la documentación automática?',
      default: true,
    },
    {
      type: 'confirm',
      name: 'installTypeORM',
      message: '¿Deseas instalar TypeORM para la gestión de base de datos?',
      default: true,
    }
  ]);

  // Si elige "Otros", preguntar por entidades personalizadas
  if (answers.theme === 'Otros') {
    const customEntities = await inquirer.prompt([
      {
        type: 'input',
        name: 'entities',
        message: 'Introduce las entidades personalizadas separadas por comas:',
        filter: (input) => input.split(',').map(ent => ent.trim())
      }
    ]);
    answers.entities = customEntities.entities;
  } else {
    // Si selecciona una temática predefinida, usar las entidades del archivo JSON
    answers.entities = Object.keys(themes.themes[answers.theme].entities);
  }

  return answers;
}

// Generar la estructura del proyecto
function generateProjectStructure(answers) {
  const projectRoot = process.cwd();  // Directorio actual donde está el proyecto

  // Crear las carpetas básicas
  const folders = ['controllers', 'services', 'entities', 'tests', 'utils'];
  folders.forEach(folder => {
    const folderPath = path.join(projectRoot, 'src', folder);
    if (!fs.existsSync(folderPath)) {
      fs.mkdirSync(folderPath, { recursive: true });
    }
  });

  // Crear archivo básico de inicio (index.ts)
  const indexContent = `
import { FlareApplication } from 'flare-api';
const app = new FlareApplication();
app.listen(3000, () => console.log('Server running on port 3000'));
`;
  fs.writeFileSync(path.join(projectRoot, 'src', 'index.ts'), indexContent);

  // Generar las entidades seleccionadas
  answers.entities.forEach(entity => generateEntity(entity, answers.theme, projectRoot));

  console.log('Proyecto generado exitosamente.');
}

// Generar una entidad base según la temática seleccionada
function generateEntity(entityName, theme, projectRoot) {
  const entityFields = themes.themes[theme]?.entities[entityName] || {};  // Campos de la entidad según la temática
  let fieldsContent = '';

  // Crear el contenido de la entidad con sus campos
  for (const [field, type] of Object.entries(entityFields)) {
    fieldsContent += `  ${field}: ${type};\n`;
  }

  const entityContent = `
export class ${entityName} {
${fieldsContent || '  // Define aquí tus campos personalizados\n'}
}
`;
  fs.writeFileSync(path.join(projectRoot, 'src', 'entities', `${entityName}.entity.ts`), entityContent);

  // Generar un controlador para la entidad
  const controllerContent = `
import { Controller, Get, Post, Body, Param } from 'flare-api';
import { ${entityName}Service } from '../services/${entityName.toLowerCase()}.service';

@Controller('${entityName.toLowerCase()}')
export class ${entityName}Controller {
  constructor(private readonly ${entityName.toLowerCase()}Service: ${entityName}Service) {}

  @Get()
  getAll() {
    return this.${entityName.toLowerCase()}Service.findAll();
  }

  @Post()
  create(@Body() ${entityName.toLowerCase()}Data: any) {
    return this.${entityName.toLowerCase()}Service.create(${entityName.toLowerCase()}Data);
  }

  @Get(':id')
  getOne(@Param('id') id: number) {
    return this.${entityName.toLowerCase()}Service.findOne(id);
  }
}
`;
  fs.writeFileSync(path.join(projectRoot, 'src', 'controllers', `${entityName}.controller.ts`), controllerContent);

  // Generar un servicio para la entidad
  const serviceContent = `
export class ${entityName}Service {
  private ${entityName.toLowerCase()}s = [];

  findAll() {
    return this.${entityName.toLowerCase()}s;
  }

  create(${entityName.toLowerCase()}Data: any) {
    this.${entityName.toLowerCase()}s.push(${entityName.toLowerCase()}Data);
    return '${entityName} creado';
  }

  findOne(id: number) {
    return this.${entityName.toLowerCase()}s.find(item => item.id === id);
  }
}
`;
  fs.writeFileSync(path.join(projectRoot, 'src', 'services', `${entityName.toLowerCase()}.service.ts`), serviceContent);
}

// Instalar dependencias adicionales
function installDependencies(answers) {
  if (answers.installSwagger) {
    execSync('npm install swagger-ui-express swagger-jsdoc', { stdio: 'inherit' });
  }
  if (answers.installTypeORM) {
    execSync('npm install typeorm reflect-metadata', { stdio: 'inherit' });
  }
}

// Ejecución del instalador
(async () => {
  const answers = await init();
  generateProjectStructure(answers);
  installDependencies(answers);
})();