novatec-cli 1.0.2 → 2.0.0

package/lib/create.js

@@ -1,277 +1,378 @@
 import path from 'path';
 import chalk from 'chalk';
 import fse from 'fs-extra';
+import ora from 'ora';
+import { execSync, spawnSync } from 'child_process';
 import { askProjectOptions } from './prompts.js';
 import { generateFrontend } from './generators/frontend.js';
 import { generateBackend } from './generators/backend.js';
 import { generateReadme } from './generators/readme.js';
 import { run, isInstalled } from './utils.js';
+import boxen from 'boxen';
 
-const boxen = await import('boxen');
+// ── PROGRESO ──────────────────────────────────────────────────────────────────
+function progressBar(current, total, label) {
+  const width = 30;
+  const filled = Math.round((current / total) * width);
+  const empty = width - filled;
+  const pct = Math.round((current / total) * 100);
+  const bar = chalk.white('█'.repeat(filled)) + chalk.gray('░'.repeat(empty));
+  process.stdout.write(`\r  [${bar}] ${chalk.white(pct + '%')}  ${chalk.gray(label)}          `);
+}
 
-async function runCreate(nameArg, options) {
+// ── MAIN ──────────────────────────────────────────────────────────────────────
+export async function runCreate(nameArg, options) {
+  const startTime = Date.now();
   const config = await askProjectOptions(nameArg, options);
   const projectPath = path.resolve(process.cwd(), config.name);
 
-  if (await fse.pathExists(projectPath)) {
-    throw new Error(`La carpeta "${config.name}" ya existe en este directorio.`);
-  }
-
-  console.log(chalk.cyan(`\n📁 Creando proyecto en: ${chalk.bold(projectPath)}\n`));
+  // Asegurar carpeta
   await fse.ensureDir(projectPath);
 
-  await generateFrontend(config, projectPath);
-  await generateBackend(config, projectPath);
-  await generateReadme(config, projectPath);
+  const isPython = ['fastapi', 'django', 'flask'].includes(config.backend);
+  const isNode   = !isPython && config.backend !== 'spring' && config.backend !== 'gin';
 
+  // Calcular pasos totales
   const extras = config.extras || [];
+  const steps = [
+    'Generando frontend',
+    'Generando backend',
+    'Generando README',
+    extras.includes('env')          && 'Archivos .env',
+    extras.includes('editorconfig') && '.editorconfig',
+    extras.includes('eslint')       && 'ESLint + Prettier',
+    extras.includes('husky')        && 'Husky',
+    extras.includes('testing')      && 'Vitest',
+    extras.includes('ci')           && 'GitHub Actions',
+    extras.includes('docker')       && 'Docker',
+    extras.includes('auth')         && 'Auth JWT',
+    extras.includes('tailwind')     && 'Tailwind CSS',
+    extras.includes('git')          && 'Git init',
+    config.frontendDeps?.length     && 'Instalando deps frontend',
+    config.backendDeps?.length      && 'Instalando deps backend',
+  ].filter(Boolean);
+
+  console.log();
+  let step = 0;
+
+  const tick = (label) => {
+    step++;
+    progressBar(step, steps.length, label);
+  };
+
+  // 1. Frontend
+  tick('Generando frontend...');
+  await generateFrontend(config, projectPath);
 
-  if (extras.includes('env'))          await generateEnvFiles(config, projectPath);
-  if (extras.includes('editorconfig')) await fse.writeFile(path.join(projectPath, '.editorconfig'), EDITORCONFIG);
-  if (extras.includes('eslint'))       await setupEslint(config, projectPath);
-  if (extras.includes('husky'))        await setupHusky(config, projectPath);
-  if (extras.includes('testing'))      await setupTesting(config, projectPath);
-  if (extras.includes('ci'))           await setupCI(config, projectPath);
-  if (extras.includes('docker'))       await generateDocker(config, projectPath);
+  // 2. Backend
+  tick('Generando backend...');
+  await generateBackend(config, projectPath);
+
+  // 3. README personalizado
+  tick('Generando README...');
+  await generateCustomReadme(config, projectPath);
 
+  // 4. Extras
+  if (extras.includes('env')) {
+    tick('Archivos .env...');
+    await generateEnvFiles(config, projectPath);
+  }
+  if (extras.includes('editorconfig')) {
+    tick('.editorconfig...');
+    await fse.writeFile(path.join(projectPath, '.editorconfig'), EDITORCONFIG);
+  }
+  if (extras.includes('eslint')) {
+    tick('ESLint + Prettier...');
+    await setupEslint(config, projectPath);
+  }
+  if (extras.includes('husky')) {
+    tick('Husky...');
+    await setupHusky(config, projectPath);
+  }
+  if (extras.includes('testing')) {
+    tick('Vitest...');
+    await setupTesting(config, projectPath);
+  }
+  if (extras.includes('ci')) {
+    tick('GitHub Actions...');
+    await setupCI(config, projectPath);
+  }
+  if (extras.includes('docker')) {
+    tick('Docker...');
+    await generateDocker(config, projectPath);
+  }
+  if (extras.includes('auth')) {
+    tick('Auth JWT...');
+    await setupAuth(config, projectPath);
+  }
+  if (extras.includes('tailwind')) {
+    tick('Tailwind CSS...');
+    await setupTailwind(config, projectPath);
+  }
   if (extras.includes('git') && isInstalled('git')) {
-    try { run('git init', projectPath, 'Inicializando repositorio git'); } catch {}
+    tick('Git init...');
+    try { run('git init', projectPath, 'git init'); } catch {}
     await fse.writeFile(path.join(projectPath, '.gitignore'), GITIGNORE);
   }
 
+  // 5. Instalar dependencias automáticamente
+  if (config.frontendDeps?.length && isInstalled('npm')) {
+    tick('Instalando deps frontend...');
+    const frontendPath = path.join(projectPath, 'frontend');
+    try {
+      spawnSync('npm', ['install', ...config.frontendDeps], { cwd: frontendPath, shell: true, stdio: 'pipe' });
+    } catch {}
+  }
+  if (config.backendDeps?.length && isNode && isInstalled('npm')) {
+    tick('Instalando deps backend...');
+    const backendPath = path.join(projectPath, 'backend');
+    try {
+      spawnSync('npm', ['install', ...config.backendDeps], { cwd: backendPath, shell: true, stdio: 'pipe' });
+    } catch {}
+  }
+
+  // Barra al 100%
+  progressBar(steps.length, steps.length, 'Completado');
+  console.log('\n');
+
+  // Tiempo total
+  const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+
   // Resumen final
   const backendCmd = {
-    express: 'npm run dev',
-    nestjs: 'npm run start:dev',
-    fastify: 'npm run dev',
-    hono: 'npm run dev',
-    fastapi: 'uvicorn main:app --reload',
-    django: 'python manage.py runserver',
-    flask: 'python run.py',
-    spring: 'mvn spring-boot:run',
-    deno: 'deno task dev',
-    gin: 'go run main.go'
+    express: 'npm run dev', nestjs: 'npm run start:dev', fastify: 'npm run dev',
+    hono: 'npm run dev', fastapi: 'uvicorn main:app --reload', django: 'python manage.py runserver',
+    flask: 'python run.py', spring: 'mvn spring-boot:run', deno: 'deno task dev', gin: 'go run main.go',
   };
 
-  // Resumen final
   console.log(
-    boxen.default(
-      chalk.bold.white('  ✔  PROYECTO CREADO EXITOSAMENTE\n\n') +
-      chalk.white('  Nombre   ') + chalk.gray('│ ') + chalk.bold.white(config.name) + '\n' +
-      chalk.white('  Frontend ') + chalk.gray('│ ') + chalk.bold.white(config.frontend) + '\n' +
-      chalk.white('  Backend  ') + chalk.gray('│ ') + chalk.bold.white(config.backend) + '\n\n' +
-      chalk.gray('  ─────────────────────────────────────────\n\n') +
-      chalk.white('  Iniciar Frontend\n') +
-      chalk.gray(`    cd ${config.name}/frontend\n`) +
-      chalk.white('    npm run dev\n\n') +
-      chalk.white('  Iniciar Backend\n') +
-      chalk.gray(`    cd ${config.name}/backend\n`) +
-      chalk.white(`    ${backendCmd[config.backend] || 'npm start'}`),
-      {
-        padding: 1,
-        margin: { top: 1, left: 2 },
-        borderStyle: 'round',
-        borderColor: 'white',
-        dimBorder: true,
-      }
+    boxen(
+      chalk.bold.white('  ✔  PROYECTO LISTO\n\n') +
+      chalk.gray('  Nombre     │ ') + chalk.white(config.name) + '\n' +
+      chalk.gray('  Frontend   │ ') + chalk.white(config.frontend) + (config.typescript ? chalk.gray(' + TypeScript') : '') + '\n' +
+      chalk.gray('  Backend    │ ') + chalk.white(config.backend) + '\n' +
+      chalk.gray('  Base datos │ ') + chalk.white(config.db || 'ninguna') + '\n' +
+      chalk.gray('  Tiempo     │ ') + chalk.white(elapsed + 's') + '\n\n' +
+      chalk.gray('  ─────────────────────────────────────\n\n') +
+      chalk.white('  cd ' + config.name + '/frontend  →  npm run dev\n') +
+      chalk.white('  cd ' + config.name + '/backend   →  ' + (backendCmd[config.backend] || 'npm start')),
+      { padding: 1, margin: { top: 1, left: 2 }, borderStyle: 'round', borderColor: 'white', dimBorder: true }
     )
   );
+
+  // Abrir VS Code si está instalado
+  if (isInstalled('code')) {
+    try {
+      spawnSync('code', [projectPath], { shell: true, stdio: 'ignore', detached: true });
+      console.log('  ' + chalk.gray('VS Code abierto automáticamente ✔'));
+    } catch {}
+  }
+
+  console.log();
+}
+
+// ── README PERSONALIZADO ──────────────────────────────────────────────────────
+async function generateCustomReadme(config, projectPath) {
+  const ts = config.typescript ? ' + TypeScript' : '';
+  const dbSection = config.db && config.db !== 'none'
+    ? `\n## Base de datos\n\n**${config.db}** — Configura la conexión en \`backend/.env\`\n` : '';
+
+  const content = `# ${config.name}
+
+> Proyecto generado con [NOVATEC CLI](https://www.npmjs.com/package/novatec-cli)
+
+## Stack
+
+| Capa | Tecnología |
+|------|-----------|
+| Frontend | **${config.frontend}**${ts} |
+| Backend | **${config.backend}**${ts} |
+| Base de datos | **${config.db || 'No configurada'}** |
+${dbSection}
+## Inicio rápido
+
+\`\`\`bash
+# Frontend
+cd ${config.name}/frontend
+npm install
+npm run dev
+
+# Backend
+cd ${config.name}/backend
+${['fastapi','django','flask'].includes(config.backend) ? 'pip install -r requirements.txt\n' : 'npm install\n'}\
+${config.backend === 'fastapi' ? 'uvicorn main:app --reload' :
+  config.backend === 'django'  ? 'python manage.py runserver' :
+  config.backend === 'flask'   ? 'python run.py' :
+  config.backend === 'spring'  ? 'mvn spring-boot:run' :
+  config.backend === 'gin'     ? 'go run main.go' : 'npm run dev'}
+\`\`\`
+${config.extras?.includes('docker') ? '\n## Docker\n\n```bash\ndocker-compose up --build\n```\n' : ''}
+## Generado con
+
+\`\`\`
+novatec create ${config.name}
+\`\`\`
+
+---
+*Generado el ${new Date().toLocaleDateString('es-MX')} con NOVATEC CLI*
+`;
+  await fse.writeFile(path.join(projectPath, 'README.md'), content);
 }
 
-// ── ESLint + Prettier ─────────────────────────────────────────────────────────
+// ── AUTH JWT ──────────────────────────────────────────────────────────────────
+async function setupAuth(config, projectPath) {
+  const backendPath = path.join(projectPath, 'backend');
+  const isPython = ['fastapi', 'django', 'flask'].includes(config.backend);
+
+  if (isPython) return; // Django/FastAPI ya tienen su propio auth
+
+  const authDir = path.join(backendPath, 'src', 'auth');
+  await fse.ensureDir(authDir);
+
+  const middleware = `import jwt from 'jsonwebtoken';
+
+export function authMiddleware(req, res, next) {
+  const token = req.headers.authorization?.split(' ')[1];
+  if (!token) return res.status(401).json({ message: 'Token requerido' });
+  try {
+    req.user = jwt.verify(token, process.env.JWT_SECRET || 'change_me');
+    next();
+  } catch {
+    res.status(401).json({ message: 'Token inválido' });
+  }
+}
+`;
+  const authRoutes = `import { Router } from 'express';
+import jwt from 'jsonwebtoken';
+import bcrypt from 'bcryptjs';
+
+const router = Router();
+
+// POST /api/auth/register
+router.post('/register', async (req, res) => {
+  const { email, password } = req.body;
+  const hash = await bcrypt.hash(password, 10);
+  // TODO: guardar usuario en BD
+  const token = jwt.sign({ email }, process.env.JWT_SECRET || 'change_me', { expiresIn: '7d' });
+  res.json({ token });
+});
+
+// POST /api/auth/login
+router.post('/login', async (req, res) => {
+  const { email, password } = req.body;
+  // TODO: buscar usuario en BD y verificar hash
+  const token = jwt.sign({ email }, process.env.JWT_SECRET || 'change_me', { expiresIn: '7d' });
+  res.json({ token });
+});
+
+export default router;
+`;
+
+  await fse.writeFile(path.join(authDir, 'middleware.js'), middleware);
+  await fse.writeFile(path.join(authDir, 'routes.js'), authRoutes);
+
+  // Instalar deps de auth
+  try {
+    spawnSync('npm', ['install', 'jsonwebtoken', 'bcryptjs'], { cwd: backendPath, shell: true, stdio: 'pipe' });
+  } catch {}
+}
+
+// ── TAILWIND AUTO ─────────────────────────────────────────────────────────────
+async function setupTailwind(config, projectPath) {
+  const frontendPath = path.join(projectPath, 'frontend');
+  const tailwindConfig = `/** @type {import('tailwindcss').Config} */
+export default {
+  content: ['./index.html', './src/**/*.{js,ts,jsx,tsx,vue,svelte}'],
+  theme: { extend: {} },
+  plugins: [],
+}
+`;
+  const postcssConfig = `export default {
+  plugins: { tailwindcss: {}, autoprefixer: {} },
+}
+`;
+  await fse.writeFile(path.join(frontendPath, 'tailwind.config.js'), tailwindConfig);
+  await fse.writeFile(path.join(frontendPath, 'postcss.config.js'), postcssConfig);
+
+  // Agregar imports al CSS principal
+  const cssPath = path.join(frontendPath, 'src', 'index.css');
+  const tailwindImports = `@tailwind base;\n@tailwind components;\n@tailwind utilities;\n\n`;
+  if (await fse.pathExists(cssPath)) {
+    const existing = await fse.readFile(cssPath, 'utf8');
+    await fse.writeFile(cssPath, tailwindImports + existing);
+  } else {
+    await fse.ensureDir(path.join(frontendPath, 'src'));
+    await fse.writeFile(cssPath, tailwindImports);
+  }
+
+  try {
+    spawnSync('npm', ['install', '-D', 'tailwindcss', 'postcss', 'autoprefixer'], { cwd: frontendPath, shell: true, stdio: 'pipe' });
+  } catch {}
+}
+
+// ── ESLint ────────────────────────────────────────────────────────────────────
 async function setupEslint(config, projectPath) {
   const frontendPath = path.join(projectPath, 'frontend');
-  const eslintConfig = `{
-  "env": { "browser": true, "es2021": true, "node": true },
-  "extends": ["eslint:recommended"],
-  "parserOptions": { "ecmaVersion": "latest", "sourceType": "module" },
-  "rules": { "no-unused-vars": "warn", "no-console": "off" }
-}\n`;
-  const prettierConfig = `{
-  "semi": true,
-  "singleQuote": true,
-  "tabWidth": 2,
-  "trailingComma": "es5"
-}\n`;
-
-  await fse.writeFile(path.join(frontendPath, '.eslintrc.json'), eslintConfig);
-  await fse.writeFile(path.join(frontendPath, '.prettierrc'), prettierConfig);
-  run('npm install -D eslint prettier eslint-config-prettier', frontendPath, 'Instalando ESLint + Prettier');
-  console.log(chalk.green('✔ ESLint + Prettier configurados'));
+  await fse.writeFile(path.join(frontendPath, '.eslintrc.json'), `{"env":{"browser":true,"es2021":true},"extends":["eslint:recommended"],"parserOptions":{"ecmaVersion":"latest","sourceType":"module"},"rules":{"no-unused-vars":"warn"}}\n`);
+  await fse.writeFile(path.join(frontendPath, '.prettierrc'), `{"semi":true,"singleQuote":true,"tabWidth":2,"trailingComma":"es5"}\n`);
+  try { spawnSync('npm', ['install', '-D', 'eslint', 'prettier'], { cwd: frontendPath, shell: true, stdio: 'pipe' }); } catch {}
 }
 
-// ── Husky + lint-staged ───────────────────────────────────────────────────────
+// ── Husky ─────────────────────────────────────────────────────────────────────
 async function setupHusky(config, projectPath) {
   const frontendPath = path.join(projectPath, 'frontend');
   try {
-    run('npm install -D husky lint-staged', frontendPath, 'Instalando Husky + lint-staged');
-    run('npx husky init', frontendPath, 'Inicializando Husky');
+    spawnSync('npm', ['install', '-D', 'husky', 'lint-staged'], { cwd: frontendPath, shell: true, stdio: 'pipe' });
+    spawnSync('npx', ['husky', 'init'], { cwd: frontendPath, shell: true, stdio: 'pipe' });
+    await fse.ensureDir(path.join(frontendPath, '.husky'));
     await fse.writeFile(path.join(frontendPath, '.husky', 'pre-commit'), '#!/bin/sh\nnpx lint-staged\n');
-    const pkgPath = path.join(frontendPath, 'package.json');
-    const pkg = await fse.readJSON(pkgPath);
-    pkg['lint-staged'] = { '*.{js,jsx,ts,tsx,vue}': ['eslint --fix', 'prettier --write'] };
-    await fse.writeJSON(pkgPath, pkg, { spaces: 2 });
-    console.log(chalk.green('✔ Husky + lint-staged configurados'));
-  } catch { console.log(chalk.yellow('⚠ Husky requiere git init primero')); }
+  } catch {}
 }
 
 // ── Testing ───────────────────────────────────────────────────────────────────
 async function setupTesting(config, projectPath) {
   const frontendPath = path.join(projectPath, 'frontend');
-  const isReactLike = ['react', 'next', 'solid', 'remix', 'qwik'].includes(config.frontend);
-
-  run('npm install -D vitest @vitest/ui', frontendPath, 'Instalando Vitest');
-
   const testDir = path.join(frontendPath, 'src', '__tests__');
   await fse.ensureDir(testDir);
-
-  const sampleTest = isReactLike
-    ? `import { describe, it, expect } from 'vitest';\n\ndescribe('App', () => {\n  it('should work', () => {\n    expect(1 + 1).toBe(2);\n  });\n});\n`
-    : `import { describe, it, expect } from 'vitest';\n\ndescribe('App', () => {\n  it('should work', () => {\n    expect(true).toBe(true);\n  });\n});\n`;
-
-  await fse.writeFile(path.join(testDir, 'app.test.js'), sampleTest);
-
-  const pkgPath = path.join(frontendPath, 'package.json');
-  const pkg = await fse.readJSON(pkgPath);
-  pkg.scripts = { ...pkg.scripts, test: 'vitest', 'test:ui': 'vitest --ui' };
-  await fse.writeJSON(pkgPath, pkg, { spaces: 2 });
-  console.log(chalk.green('✔ Vitest configurado con test de ejemplo'));
+  await fse.writeFile(path.join(testDir, 'app.test.js'), `import { describe, it, expect } from 'vitest';\n\ndescribe('App', () => {\n  it('works', () => expect(1 + 1).toBe(2));\n});\n`);
+  try { spawnSync('npm', ['install', '-D', 'vitest'], { cwd: frontendPath, shell: true, stdio: 'pipe' }); } catch {}
 }
 
-// ── GitHub Actions CI ─────────────────────────────────────────────────────────
+// ── GitHub Actions ────────────────────────────────────────────────────────────
 async function setupCI(config, projectPath) {
   const ciDir = path.join(projectPath, '.github', 'workflows');
   await fse.ensureDir(ciDir);
-
-  const ci = `name: CI
-
-on:
-  push:
-    branches: [main, develop]
-  pull_request:
-    branches: [main]
-
-jobs:
-  frontend:
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: frontend
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 20
-          cache: npm
-          cache-dependency-path: frontend/package-lock.json
-      - run: npm ci
-      - run: npm run build
-${config.extras.includes('testing') ? '      - run: npm test\n' : ''}
-  backend:
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: backend
-    steps:
-      - uses: actions/checkout@v4
-${['fastapi', 'django', 'flask'].includes(config.backend) ? `      - uses: actions/setup-python@v5
-        with:
-          python-version: '3.11'
-      - run: pip install -r requirements.txt` : `      - uses: actions/setup-node@v4
-        with:
-          node-version: 20
-      - run: npm ci`}
-`;
-  await fse.writeFile(path.join(ciDir, 'ci.yml'), ci);
-  console.log(chalk.green('✔ GitHub Actions CI configurado'));
+  const isPython = ['fastapi', 'django', 'flask'].includes(config.backend);
+  await fse.writeFile(path.join(ciDir, 'ci.yml'), `name: CI\non:\n  push:\n    branches: [main]\njobs:\n  build:\n    runs-on: ubuntu-latest\n    steps:\n      - uses: actions/checkout@v4\n      - uses: actions/setup-node@v4\n        with:\n          node-version: 20\n      - run: cd frontend && npm ci && npm run build\n${isPython ? '' : '      - run: cd backend && npm ci\n'}`);
 }
 
 // ── Docker ────────────────────────────────────────────────────────────────────
 async function generateDocker(config, projectPath) {
   const isPython = ['fastapi', 'django', 'flask'].includes(config.backend);
-  const backendPort = isPython ? (config.backend === 'gin' ? '8080' : '8000') : '3001';
-
-  const backendService = isPython
-    ? `  backend:
-    build: ./backend
-    ports:
-      - "${backendPort}:${backendPort}"
-    volumes:
-      - ./backend:/app
-    environment:
-      - DEBUG=True`
-    : `  backend:
-    build: ./backend
-    ports:
-      - "${backendPort}:${backendPort}"
-    volumes:
-      - ./backend:/app
-      - /app/node_modules
-    environment:
-      - NODE_ENV=development`;
-
-  const compose = `version: '3.9'
-services:
-  frontend:
-    build: ./frontend
-    ports:
-      - "5173:5173"
-    volumes:
-      - ./frontend:/app
-      - /app/node_modules
-    environment:
-      - NODE_ENV=development
-${backendService}
-  db:
-    image: postgres:16-alpine
-    environment:
-      POSTGRES_DB: mydb
-      POSTGRES_USER: user
-      POSTGRES_PASSWORD: password
-    ports:
-      - "5432:5432"
-    volumes:
-      - pgdata:/var/lib/postgresql/data
-
-volumes:
-  pgdata:
-`;
-  await fse.writeFile(path.join(projectPath, 'docker-compose.yml'), compose);
-  console.log(chalk.green('✔ docker-compose.yml generado (con PostgreSQL)'));
+  const backendPort = isPython ? '8000' : '3001';
+  const dbService = config.db === 'postgres' ? `\n  db:\n    image: postgres:16-alpine\n    environment:\n      POSTGRES_DB: mydb\n      POSTGRES_USER: user\n      POSTGRES_PASSWORD: password\n    ports:\n      - "5432:5432"\n    volumes:\n      - pgdata:/var/lib/postgresql/data\n\nvolumes:\n  pgdata:` :
+                    config.db === 'mongo'    ? `\n  db:\n    image: mongo:7\n    ports:\n      - "27017:27017"\n    volumes:\n      - mongodata:/data/db\n\nvolumes:\n  mongodata:` :
+                    config.db === 'mysql'    ? `\n  db:\n    image: mysql:8\n    environment:\n      MYSQL_DATABASE: mydb\n      MYSQL_ROOT_PASSWORD: password\n    ports:\n      - "3306:3306"` : '';
+
+  await fse.writeFile(path.join(projectPath, 'docker-compose.yml'),
+    `version: '3.9'\nservices:\n  frontend:\n    build: ./frontend\n    ports:\n      - "5173:5173"\n  backend:\n    build: ./backend\n    ports:\n      - "${backendPort}:${backendPort}"\n    env_file: ./backend/.env${dbService}\n`
+  );
 }
 
-// ── Archivos .env ─────────────────────────────────────────────────────────────
+// ── .env ──────────────────────────────────────────────────────────────────────
 async function generateEnvFiles(config, projectPath) {
   await fse.writeFile(path.join(projectPath, 'frontend', '.env.example'), 'VITE_API_URL=http://localhost:3001\n');
   const isPython = ['fastapi', 'django', 'flask'].includes(config.backend);
+  const dbUrl = config.db === 'postgres' ? 'postgresql://user:password@localhost:5432/mydb' :
+                config.db === 'mysql'    ? 'mysql://user:password@localhost:3306/mydb' :
+                config.db === 'mongo'    ? 'mongodb://localhost:27017/mydb' :
+                config.db === 'sqlite'   ? 'file:./dev.db' : '';
   if (!isPython) {
-    await fse.writeFile(path.join(projectPath, 'backend', '.env.example'), 'PORT=3001\nDB_URL=\nJWT_SECRET=change_me\nNODE_ENV=development\n');
+    await fse.writeFile(path.join(projectPath, 'backend', '.env.example'),
+      `PORT=3001\nNODE_ENV=development\nJWT_SECRET=change_me_in_production\n${dbUrl ? 'DATABASE_URL=' + dbUrl + '\n' : ''}`
+    );
   }
-  console.log(chalk.green('✔ Archivos .env.example generados'));
 }
 
-const EDITORCONFIG = `root = true
-[*]
-indent_style = space
-indent_size = 2
-end_of_line = lf
-charset = utf-8
-trim_trailing_whitespace = true
-insert_final_newline = true
-`;
-
-const GITIGNORE = `node_modules/
-dist/
-.next/
-.nuxt/
-.svelte-kit/
-.env
-*.log
-__pycache__/
-.venv/
-*.pyc
-target/
-*.class
-`;
-
-export { runCreate };
+const EDITORCONFIG = `root = true\n[*]\nindent_style = space\nindent_size = 2\nend_of_line = lf\ncharset = utf-8\ntrim_trailing_whitespace = true\ninsert_final_newline = true\n`;
+const GITIGNORE = `node_modules/\ndist/\n.next/\n.nuxt/\n.svelte-kit/\n.env\n*.log\n__pycache__/\n.venv/\n*.pyc\ntarget/\n*.class\n.DS_Store\n`;