Formación corporativa en Node.js

Módulos y sistema de paquetes en Node.js

Este módulo aborda el corazón del ecosistema Node.js: el sistema de módulos. Se estudian en profundidad los dos sistemas de módulos que conviven en Node.js: CommonJS (basado en require/module.exports) y ES Modules (basado en import/export), con sus diferencias, ventajas y casos de uso recomendados.

Se práctica la creación de módulos propios y la organización del código en archivos reutilizables. También se cubre la gestión de dependencias con node_modules, el versionado semántico y los archivos de bloqueo (package-lock.json), así como la automatización de tareas mediante scripts en package.json. El módulo finaliza con la publicación de paquetes en el registro de npm, completando el ciclo de vida de un módulo Node.js.

Módulos del núcleo de Node.js

Node.js incluye un conjunto de módulos integrados (core modules) que proporcionan funcionalidad de bajo nivel sin necesidad de instalar dependencias externas. Este módulo repasa los más importantes y utilizados en el desarrollo cotidiano.

Se estudian fs para operaciones sobre el sistema de archivos, path para la manipulación portátil de rutas, os para acceder a información del sistema operativo y url para analizar y construir direcciones web. También se cubre crypto para hash y cifrado, util para formateo e inspección, y el módulo events con la clase EventEmitter como base de la programación orientada a eventos en Node.js.

El módulo dedica especial atención a los streams (Readable, Writable, Transform y pipeline) y a Buffer para el manejo eficiente de datos binarios, dos abstracciones fundamentales en aplicaciones de alto rendimiento.

Asincronía en Node.js

La asincronía es uno de los pilares fundamentales que distingue a Node.js de otros entornos de ejecución. Mientras que JavaScript tradicional en el navegador maneja eventos de usuario y peticiones web, Node.js extiende este modelo para gestionar operaciones del sistema como lectura de archivos, consultas a bases de datos y comunicaciones de red.

Node.js utiliza un modelo de concurrencia basado en eventos que permite manejar miles de operaciones simultáneas sin bloquear la ejecución del programa principal. Este enfoque resulta especialmente eficiente para aplicaciones que realizan muchas operaciones de entrada/salida (I/O), como servidores web o herramientas de procesamiento de datos.

El Event Loop y la naturaleza no bloqueante

El Event Loop es el mecanismo central que permite a Node.js ejecutar código JavaScript de forma asíncrona. Funciona como un bucle continuo que procesa eventos y ejecuta callbacks cuando las operaciones asíncronas se completan.

console.log('Inicio');

setTimeout(() => {
    console.log('Operación asíncrona completada');
}, 0);

console.log('Fin');

// Salida:
// Inicio
// Fin
// Operación asíncrona completada

En este ejemplo, aunque el timeout tiene un retraso de 0 milisegundos, el callback se ejecuta después del código síncrono. Esto demuestra cómo el Event Loop prioriza la ejecución del código principal antes de procesar las tareas asíncronas.

Callbacks: el patrón tradicional

Los callbacks fueron el primer mecanismo para manejar asincronía en Node.js. Un callback es una función que se pasa como argumento a otra función y se ejecuta cuando una operación asíncrona termina.

const fs = require('node:fs');

// Lectura asíncrona de archivo
fs.readFile('datos.txt', 'utf8', (error, contenido) => {
    if (error) {
        console.error('Error al leer el archivo:', error.message);
        return;
    }
    console.log('Contenido del archivo:', contenido);
});

console.log('Esta línea se ejecuta inmediatamente');

El patrón de error-first callback es una convención en Node.js donde el primer parámetro del callback siempre representa un posible error, y los siguientes contienen los datos de la operación exitosa.

Servidor HTTP en Node.js

Este módulo enseña a construir servidores web con el módulo http nativo de Node.js, sin frameworks externos. Se estudian los objetos request y response en profundidad: cabeceras, métodos HTTP, códigos de estado y el cuerpo de las peticiones.

Se implementa enrutamiento básico, se aprende a servir archivos estáticos (HTML, CSS, imágenes) y se configura un servidor HTTPS con certificados TLS/SSL. Este módulo sienta las bases para comprender cómo funcionan internamente los frameworks web de Node.js, preparando al alumno para construir APIs y aplicaciones web con un conocimiento sólido de la capa de transporte.

API REST con Node.js

Este módulo lleva el conocimiento del servidor HTTP al siguiente nivel: la construcción de APIs REST completas sin depender de frameworks externos. Se aprende a devolver respuestas JSON, a parsear el cuerpo de las peticiones en formato JSON y formularios, y a gestionar parámetros de URL y de consulta.

Se implementa un CRUD completo (Create, Read, Update, Delete) con datos en memoria, se configura CORS para permitir el acceso desde diferentes orígenes y se establece un sistema de manejo centralizado de errores. Este módulo refuerza la comprensión del protocolo HTTP y prepara al alumno para trabajar con frameworks como Express comprendiendo lo que ocurre por debajo.

Bases de datos con Node.js

Node.js se integra con las principales bases de datos a través de drivers nativos y ORMs. Este módulo cubre la conexión a bases de datos relacionales con los drivers mysql2 y pg (PostgreSQL), incluyendo la configuración de pool de conexiones para entornos de producción, y la ejecución de consultas parametrizadas para prevenir inyecciones SQL.

También se estudia el driver oficial de MongoDB para operaciones CRUD y aggregation, el manejo de transacciones en bases de datos relacionales y una introducción práctica a los ORM más utilizados: Sequelize (con modelos, migraciones y asociaciones) y Prisma (con su enfoque de schema-first y cliente generado). Al finalizar el módulo sabrás elegir la herramienta de persistencia adecuada para cada escenario.

La seguridad es una pieza clave en cualquier aplicación que maneje datos sensibles. A continuación, se describen las prácticas recomendadas para proteger servidores en Node.js, con un enfoque centrado en el uso de módulos nativos y librerías esenciales.

Creación de un servidor HTTP

Para comenzar, se puede utilizar el módulo http de Node.js, que habilita la recepción de peticiones y la emisión de respuestas:

const http = require('node:http');

const servidor = http.createServer((req, res) => {
  // Ejemplo de ruta principal
  if (req.method === 'GET' && req.url === '/') {
    res.writeHead(200, { 'Content-Type': 'text/plain' });
    res.end('Servidor Node.js en marcha');
  } else {
    res.writeHead(404, { 'Content-Type': 'text/plain' });
    res.end('Ruta no encontrada');
  }
});

servidor.listen(3000, () => {
  console.log('Servidor activo en http://localhost:3000');
});

Este servidor básico puede ampliarse con autenticación, validaciones y control de accesos, siempre manejando de forma cuidadosa los datos que llegan en cada solicitud.

Implementación de HTTPS

Para cifrar la comunicación entre cliente y servidor, se emplea el módulo https, que requiere certificados SSL/TLS:

const https = require('node:https');
const fs = require('node:fs');

const opciones = {
  key: fs.readFileSync('ruta/privkey.pem'),
  cert: fs.readFileSync('ruta/cert.pem')
};

const servidorSeguro = https.createServer(opciones, (req, res) => {
  res.writeHead(200);
  res.end('Conexión segura en Node.js');
});

servidorSeguro.listen(443, () => {
  console.log('Servidor HTTPS activo en el puerto 443');
});

Activar HTTPS protege los datos en tránsito y evita que sean interceptados o modificados.

Variables de entorno y configuración

Para gestionar claves o credenciales sensibles (por ejemplo, tokens secretos), se recomienda usar variables de entorno. Un archivo .env puede contener valores como:

JWT_SECRET=cambiar-por-cadena-aleatoria-de-64-bytes
DB_PASSWORD=cambiar-por-contrasena-segura-del-vault

Con el paquete dotenv, se importan al inicio de la ejecución:

require('dotenv').config();

// Acceso a las variables de entorno
const claveSecreta = process.env.JWT_SECRET;

Así, se evita exponer información sensible en el repositorio de código y se mantiene la configuración centralizada.

Manejo de contraseñas

Para cifrar contraseñas de usuarios, se suele usar bcrypt. Aplicar hashing y salt reduce el riesgo de que, ante un acceso no autorizado a la base de datos, se obtengan contraseñas en texto plano:

npm install bcrypt

const bcrypt = require('bcrypt');

async function cifrarContrasena(password) {
  const saltRounds = 12;
  return await bcrypt.hash(password, saltRounds);
}

async function verificarContrasena(password, hash) {
  return await bcrypt.compare(password, hash);
}

Almacenar el hash en lugar de la contraseña real es un estándar de seguridad para cualquier sistema.

Autenticación con JSON Web Tokens

Para controlar el acceso de usuarios, se recurre a JWT. Con el paquete jsonwebtoken se generan y validan tokens, que se pueden enviar en las cabeceras de cada petición:

npm install jsonwebtoken

const jwt = require('jsonwebtoken');

// Generar un token con información de usuario
function generarToken(usuarioId) {
  return jwt.sign({ id: usuarioId }, process.env.JWT_SECRET, { expiresIn: '1h' });
}

// Verificar si un token es válido
function verificarToken(token) {
  try {
    const datos = jwt.verify(token, process.env.JWT_SECRET);
    return datos;
  } catch (error) {
    return null;
  }
}

Con este mecanismo, cada ruta de tu servidor puede comprobar el token antes de procesar la petición, reforzando la seguridad de los recursos.

Validación de datos

Controlar la información que los usuarios envían evita inyecciones o contenido malicioso. Una opción es usar la librería validator, que aporta métodos para revisar formatos, como correos electrónicos y cadenas:

npm install validator

const validator = require('validator');

function esEmailValido(email) {
  return validator.isEmail(email);
}

También es posible crear funciones personalizadas para verificar longitudes de cadenas, estructuras de JSON u otros requisitos específicos.

Control de acceso y rate limiting

Para evitar ataques de fuerza bruta, se puede imponer un límite de peticiones por IP. Una estrategia sencilla consiste en mantener un registro temporal de solicitudes y denegar acceso al sobrepasar un umbral determinado en un lapso de tiempo. Un ejemplo breve:

const mapaPeticiones = new Map();
const LIMITE_PETICIONES = 100;
const VENTANA_TIEMPO = 60 * 1000; // 1 minuto

function verificarLimite(ip) {
  const tiempoActual = Date.now();
  if (!mapaPeticiones.has(ip)) {
    mapaPeticiones.set(ip, { conteo: 1, inicio: tiempoActual });
    return true;
  }

  const registro = mapaPeticiones.get(ip);
  if ((tiempoActual - registro.inicio) < VENTANA_TIEMPO) {
    if (registro.conteo < LIMITE_PETICIONES) {
      registro.conteo++;
      return true;
    }
    return false;
  } else {
    registro.conteo = 1;
    registro.inicio = tiempoActual;
    return true;
  }
}

En cada llamada entrante, se verifica la IP y se decide si permitir o bloquear el acceso. Este mecanismo refuerza la seguridad ante intentos masivos de acceder al servidor.

Manejo de errores y mensajes de respuesta

Para no exponer información interna, es conveniente responder con mensajes genéricos ante errores, registrando los detalles sensibles en un sistema de logs o en la consola. Un manejo responsable de excepciones impide a posibles atacantes obtener pistas sobre la infraestructura de la aplicación.

try {
  // Operación que podría fallar
} catch (error) {
  console.error('Error interno:', error);
  // Responder con un código 500
}

Monitorización y auditoría

Mantener un ciclo de auditoría de dependencias con npm audit o herramientas similares ayuda a corregir vulnerabilidades. También se aconseja actualizar periódicamente Node.js para aprovechar parches de seguridad y mejoras de rendimiento.

Asimismo, contar con un sistema de logs permite rastrear acciones sospechosas, detectar patrones de ataque y responder a incidentes con mayor precisión.

A la hora de desarrollar proyectos en Node.js, contar con un sistema de testing sólido garantiza la confiabilidad de la aplicación y previene errores en producción. A continuación, se describen los pasos y herramientas más comunes para aplicar pruebas unitarias, de integración y de cobertura.

Importancia del testing en Node.js

En Node.js, el enfoque asíncrono y la reutilización de módulos requieren asegurar que cada parte funcione según lo esperado. Un testing adecuado disminuye la probabilidad de fallos y optimiza la mantenibilidad, permitiendo que el equipo de desarrollo identifique los problemas antes de implementar cambios en el entorno productivo.

Configuración inicial del proyecto

Para comenzar, se recomienda tener un archivo package.json bien definido en el proyecto. En este archivo se registran las dependencias de testing y los scripts que automatizan la ejecución de pruebas. Tras inicializar el proyecto con:

npm init -y

se agregan las librerías de testing que se requieran.

Elección de frameworks de pruebas

Existen varias librerías populares para testing en Node.js:

1. Mocha: Destaca por su flexibilidad y su amplia adopción en la comunidad.
2. Jest: Es mantenida por el equipo de React, provee un entorno de prueba completo y facilita la configuración de mocks.
3. Chai: Ofrece funciones de aserción y se integra bien con Mocha para realizar verificaciones con sintaxis clara.
4. AVA: Enfatiza la ejecución de pruebas en paralelo, maximizando la velocidad en equipos con múltiples núcleos.

Cada herramienta presenta ventajas particulares, aunque todas brindan la capacidad de ejecutar pruebas automatizadas en Node.js.

Ejemplo con Mocha y Chai

La dupla Mocha + Chai es habitual para escribir pruebas en un estilo BDD (Behavior Driven Development). Se instalan con:

npm install mocha chai --save-dev

Luego, se puede crear una carpeta test y un archivo test/usuario.test.js:

const { expect } = require('chai');

describe('Módulo de usuario', () => {
  it('Debe crear un usuario con nombre y edad', () => {
    const usuario = { nombre: 'Ana', edad: 25 };
    expect(usuario).to.have.property('nombre').that.equals('Ana');
    expect(usuario).to.have.property('edad').that.equals(25);
  });
});

En el archivo package.json, se define el script de testing:

{
  "scripts": {
    "test": "mocha"
  }
}

Al ejecutar npm test, se inician las pruebas y se genera un reporte de los resultados.

Ejemplo con Jest

Para quienes prefieran una solución integrada, Jest agrupa en un solo paquete las funciones de pruebas unitarias, mocks y coverage. Para instalarlo:

npm install jest --save-dev

Un ejemplo de prueba con Jest luce así:

// archivo: test/calculadora.test.js
function sumar(a, b) {
  return a + b;
}

test('sumar 2 + 3 debe dar 5', () => {
  expect(sumar(2, 3)).toBe(5);
});

Tras añadir "test": "jest" en package.json, npm test ejecuta las comprobaciones de manera sencilla.

Mocks y simulación de dependencias

En proyectos de Node.js, es frecuente que ciertos módulos dependan de servicios externos o funcionalidades complejas. Para aislar la lógica principal de estas dependencias, se usan mocks o stubs que simulan comportamientos y devuelven datos controlados. Esto ayuda a probar la aplicación en un entorno estable sin depender de recursos externos.

Cobertura de código

Medir la cobertura de las pruebas garantiza que la mayor parte del proyecto esté verificada. Con Jest, basta con añadir la bandera --coverage en el script de testing para generar un reporte. En Mocha, se suele integrar nyc:

npm install nyc --save-dev

Luego, en el package.json:

{
  "scripts": {
    "test": "nyc mocha"
  }
}

De este modo, se visualiza el porcentaje de líneas, funciones y archivos cubiertos por pruebas, identificando qué partes del código requieren mayor atención.

Pruebas de integración

Las pruebas de integración comprueban la interacción entre varios módulos de la aplicación. En Node.js, se suelen usar los mismos frameworks que en las pruebas unitarias, pero se inician servicios reales o simulados para asegurar que múltiples componentes funcionen en conjunto. Por ejemplo, si un proyecto necesita conectarse a una base de datos, se ejecuta el servicio en un entorno de prueba para verificar operaciones CRUD.

Ejecución continua y entornos de CI

Automatizar el testing en plataformas de CI (Continuous Integration), como GitHub Actions o GitLab CI, otorga confianza en cada actualización de la base de código. Configurar un archivo de pipeline que ejecute npm test en cada push o pull request evita que cambios defectuosos lleguen a la rama principal.

Buenas prácticas para testing en Node.js

• Mantener las pruebas en carpetas separadas con nombres relevantes.
• Escribir pruebas claras y aisladas, que verifiquen una única funcionalidad cada vez.
• Utilizar variables de entorno específicas y datos ficticios para no afectar el entorno de producción.
• Emplear test doubles para simular servicios externos en las pruebas de unidad.
• Revisar periódicamente la cobertura para detectar áreas sin verificar.

Herramientas y producción en Node.js

Este módulo prepara al alumno para llevar aplicaciones Node.js a entornos de producción reales. Se comienza con la depuración mediante el flag --inspect y las Chrome DevTools, técnica esencial para localizar errores en código asíncrono complejo.

A continuación se estudia la escalabilidad: el módulo cluster para aprovechar todos los núcleos del procesador, worker_threads para ejecutar tareas de cómputo intensivo sin bloquear el event loop, y child_process para lanzar procesos hijo con exec, spawn y fork. Se cubren también la gestión de procesos en producción con PM2, la contenedorización con Docker, el logging estructurado con pino y winston, y las buenas prácticas de despliegue. El módulo culmina con un proyecto integrador que aplica todo lo aprendido en el curso.