Configuración del entorno y proyecto Express

¿Por qué configurar bien el entorno?

Una configuración correcta del entorno de desarrollo es fundamental por varias razones:

• Consistencia: Todos los desarrolladores del equipo trabajarán con la misma configuración
• Productividad: Herramientas bien configuradas aceleran el desarrollo
• Depuración: Un entorno bien configurado facilita encontrar y resolver errores
• Reproducibilidad: El proyecto funcionará igual en diferentes máquinas

Requisitos previos

Antes de comenzar, asegúrate de tener instalado:

Paso 1: Crear la estructura del proyecto

1. Abre tu terminal y crea una nueva carpeta para tu proyecto

mkdir mi-api-rest-express
cd mi-api-rest-express

1. Inicializa el proyecto con npm

npm init -y

Esto creará un archivo package.json básico. Sin embargo, para un proyecto profesional, te recomiendo inicializarlo manualmente para configurar todos los campos correctamente:

npm init

Responde las preguntas interactivamente:

Paso 2: Estructura de carpetas profesional

Una buena estructura de carpetas es esencial para mantener tu código organizado y escalable:

mi-api-rest-express/
├── src/
│   ├── controllers/    # Lógica de los endpoints
│   ├── routes/         # Definición de rutas
│   ├── models/         # Modelos de datos
│   ├── middleware/     # Funciones intermedias
│   ├── config/         # Configuración de la app
│   ├── utils/          # Funciones utilitarias
│   └── index.js        # Punto de entrada
├── tests/              # Archivos de pruebas
├── .env                # Variables de entorno
├── .env.example        # Plantilla de variables
├── .gitignore          # Archivos ignorados por Git
├── package.json        # Dependencias y scripts
└── README.md           # Documentación del proyecto

mkdir -p src/{controllers,routes,models,middleware,config,utils} tests

Paso 3: Instalar Express y dependencias esenciales

Instala Express como dependencia principal:

npm install express

Para un proyecto profesional, necesitarás herramientas adicionales:

Instala todas de una vez:

npm install express dotenv morgan cors helmet

Paso 4: Configurar package.json correctamente

Modifica tu package.json para añadir scripts útiles y configuraciones profesionales:

{
  "name": "mi-api-rest-express",
  "version": "1.0.0",
  "description": "API RESTful construida con Node.js y Express",
  "main": "src/index.js",
  "scripts": {
    "start": "node src/index.js",
    "dev": "node --watch src/index.js",
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": ["node", "express", "api", "rest"],
  "author": "Tu Nombre",
  "license": "MIT"
}

Paso 5: Crear el archivo de configuración de entorno

Crea un archivo .env en la raíz del proyecto:

PORT=3000
NODE_ENV=development
DB_HOST=localhost
DB_PORT=5432
DB_NAME=mydb
DB_USER=myuser
DB_PASSWORD=mypassword

Crea también un archivo .env.example sin valores sensibles para compartir con otros desarrolladores:

PORT=3000
NODE_ENV=development
DB_HOST=localhost
DB_PORT=5432
DB_NAME=mydb
DB_USER=myuser
DB_PASSWORD=mypassword

Paso 6: Crear el archivo .gitignore

# Dependencias
node_modules/

# Variables de entorno
.env
.env.local
.env.*.local

# Logs
logs/
*.log
npm-debug.log*

# Sistema operativo
.DS_Store
Thumbs.db

# IDE
.vscode/
.idea/
*.swp
*.swo

# Archivos de pruebas
coverage/

# Build
dist/
build/

Paso 7: Crear el archivo principal de la aplicación

Crea el archivo src/index.js con la configuración básica:

// src/index.js
require('dotenv').config();
const express = require('express');
const cors = require('cors');
const helmet = require('helmet');
const morgan = require('morgan');

const app = express();
const PORT = process.env.PORT || 3000;

// Middlewares
app.use(helmet()); // Seguridad
app.use(cors({ origin: 'http://localhost:5173' })); // Solo el frontend local de la práctica
app.use(morgan('dev')); // Registro de peticiones
app.use(express.json()); // Parsear JSON
app.use(express.urlencoded({ extended: true })); // Parsear URL-encoded

// Rutas de prueba
app.get('/', (req, res) => {
  res.json({ 
    message: 'API RESTful con Express',
    version: '1.0.0',
    status: 'running'
  });
});

// Ruta de salud para verificar que el servidor está activo
app.get('/health', (req, res) => {
  res.json({ 
    status: 'healthy',
    timestamp: new Date().toISOString()
  });
});

// Iniciar servidor
app.listen(PORT, () => {
  console.log(`🚀 Servidor ejecutándose en http://localhost:${PORT}`);
  console.log(`📊 Entorno: ${process.env.NODE_ENV || 'development'}`);
});

Paso 8: Probar el servidor

Inicia el servidor con el script que configuramos:

npm start

Deberías ver en la terminal:

🚀 Servidor ejecutándose en http://localhost:3000
📊 Entorno: development

Abre tu navegador o Postman y visita:

• http://localhost:3000/ - Verás el mensaje de bienvenida
• http://localhost:3000/health - Verás el estado de salud

// src/config/express.js
const express = require('express');
const cors = require('cors');
const helmet = require('helmet');
const morgan = require('morgan');

function configureExpress(app) {
  // Seguridad
  app.use(helmet()); // Conserva la política CSP predeterminada

  const allowedOrigin = process.env.CORS_ORIGIN || 'http://localhost:5173';
  if (process.env.NODE_ENV === 'production' && !process.env.CORS_ORIGIN) {
    throw new Error('Configura CORS_ORIGIN para el frontend autorizado');
  }
  // CORS no sustituye autenticación ni autorización.
  app.use(cors({
    origin: allowedOrigin,
    methods: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH'],
    allowedHeaders: ['Content-Type', 'Authorization']
  }));

  // Morgan con formato personalizado
  app.use(morgan(':method :url :status :response-time ms - :res[content-length]'));

  // Límite de tamaño de payload
  app.use(express.json({ limit: '100kb' }));
  app.use(express.urlencoded({ extended: true, limit: '100kb' }));

  // Compression (requiere npm install compression)
  // app.use(compression());
}

module.exports = configureExpress;

"scripts": {
  "start": "node src/index.js",
  "start:prod": "NODE_ENV=production node src/index.js",
  "dev": "NODE_ENV=development nodemon src/index.js",
  "test": "jest",
  "test:watch": "jest --watch",
  "lint": "eslint src/",
  "lint:fix": "eslint src/ --fix"
}

Resumen de lo aprendido

En esta lección hemos configurado un entorno de desarrollo profesional para crear APIs REST con Express. Los puntos clave son:

1. Creamos la estructura de carpetas siguiendo las mejores prácticas
2. Inicializamos el proyecto con npm init
3. Instalamos Express y dependencias esenciales (helmet, cors, morgan, dotenv)
4. Configuramos los scripts de npm para diferentes entornos
5. Creamos archivos de configuración para variables de entorno
6. Estructuramos el código principal con middlewares de seguridad
7. Probamos que el servidor funciona correctamente

Un proyecto bien configurado desde el inicio nos ahorra tiempo y problemas a medida que el código crece.

Antes de usarlo fuera de tu equipo

La práctica permite solamente el origen del frontend local. En producción, configura el origen exacto, conserva los encabezados de Helmet y valida entradas, identidad y permisos de cada operación. CORS decide qué respuestas puede leer un navegador desde otro origen; no bloquea por sí solo las llamadas de otros clientes.

Referencias: soporte de Node.js, middleware CORS, guía de seguridad de Express y configuración de Helmet. Sirve tráfico público mediante HTTPS y elige límites de petición según las necesidades reales de la API.