Clase 8 - Jueves, 01 de octubre de 2026 (01 10 26) - Desarrollo de sistemas web backend
Manual Universitario de Desarrollo Backend con Express.js: Arquitectura, Ruteo y Servicios Web
1. Introducción General
Contexto del Tema
En el ecosistema de desarrollo con Node.js, la creación de servidores web HTTP mediante módulos nativos (como el módulo http) exige una cantidad considerable de código repetitivo para gestionar manualmente aspectos como la resolución de rutas, el procesamiento de encabezados, el parseo del cuerpo de las peticiones y el manejo de respuestas. Para optimizar este proceso, se utilizan frameworks de desarrollo web backend. Express.js es el framework web unificado e insustituible seleccionado en esta unidad para la construcción acelerada de servicios HTTP y APIs REST.
Importancia y Relevancia
El uso de Express.js permite abstracciones de alto nivel sobre la capa de servidor de Node.js. Esto significa que operaciones que antes requerían decenas de líneas de código manual y verificaciones condicionales complejas pueden reducirse a un par de líneas estructuradas. Express.js actúa como una infraestructura mínima y flexible que proporciona un conjunto robusto de características para aplicaciones web y móviles, facilitando la creación de servidores funcionales, legibles, escalables y mantenibles en menos de 13 líneas de código base.
2. Marco Conceptual
Definición de Conceptos Clave
- Framework Web: Entorno de trabajo estructurado que provee herramientas, bibliotecas y convenciones para simplificar la creación y despliegue de aplicaciones web.
- Express.js: Framework minimalista y flexible de Node.js para la construcción de servidores web y APIs REST.
- Punto de Entrada (Entry Point): Archivo raíz o madre del proyecto (generalmente
index.jsoapp.js) desde el cual Node.js inicia la lectura de la aplicación y se configuran los módulos del servidor. - Ruta (Route): Definición de un punto de acceso (URI/Endpoint) combinado con un método de petición HTTP específico (GET, POST, PUT, DELETE, etc.) que determina cómo responde la aplicación a una solicitud del cliente.
- Request (
**req**): Objeto que representa la petición HTTP realizada por el cliente (contiene encabezados, parámetros de URL, cuerpo de la petición, etc.). - Response (
**res**): Objeto que representa la respuesta HTTP que el servidor envía de regreso al cliente (modifica estados, encabezados y contenido devuelto). - Middleware: Función intermedia que tiene acceso al objeto de petición (
req), al objeto de respuesta (res) y a la siguiente función middleware (next) en el ciclo de solicitud-respuesta de la aplicación. - API REST: Interfaz de programación de aplicaciones que sigue las restricciones del estilo arquitectónico REST, utilizando métodos HTTP estándar para operar sobre recursos.
Términos Fundamentales Explicados desde Cero
[ Cliente (Navegador / Postman) ]
│
Petición HTTP (req)
│
▼
┌──────────────────────────────┐
│ Express App │
│ │
│ ┌──────────────────────┐ │
│ │ Middlewares │ │
│ └──────────┬───────────┘ │
│ │ │
│ ┌──────────▼───────────┐ │
│ │ Rutas (Router) │ │
│ └──────────┬───────────┘ │
│ │ │
│ ┌──────────▼───────────┐ │
│ │ Controladores │ │
│ └──────────────────────┘ │
└──────────────┬───────────────┘
│
Respuesta HTTP (res)
│
▼
[ Cliente (Recibe JSON / HTML) ]
- Agnosticism en la Arquitectura: Express abstrae la complejidad del protocolo HTTP subyacente. El desarrollador opera de forma agnóstica a la infraestructura interna de Node.js, concentrándose en la lógica de negocio.
- Notación Puntuada de Rutas: La sintaxis
app.get(),app.post(),app.put(),app.delete()vincula directamente un verbo HTTP a una función de callback. - Ataque a la Cadena de Suministro (Supply Chain Attack): Vulnerabilidad de seguridad donde un atacante compromete una aplicación introduciendo código malicioso a través de una de las dependencias o subdependencias de segundo o tercer nivel incluidas en el gestor de paquetes (
npm).
3. Desarrollo del Tema: Arquitectura y Funcionamiento de Express.js
Construcción Progresiva de un Servidor Web
Para inicializar y ejecutar un servidor funcional con Express.js, se sigue una secuencia lógica estandarizada:
- Creación e Inicialización del Directorio:
mkdir servidor-expreso
cd servidor-expreso
npm init -y
El comando npm init genera el archivo de configuración package.json.
- Instalación del Framework:
npm install express
Esta ejecución descarga la versión de Express (por ejemplo, v5.10 / v5.1) y la registra en las dependencias directas del proyecto, generando a su vez el archivo package-lock.json y el directorio node_modules.
- Código del Servidor Elemental (
**index.js**):
const express = require('express'); // Importación de la librería
const app = express(); // Invocación del constructor de la aplicación
const port = 4000; // Definición del puerto de escucha
// Definición de ruta primitiva (Root)
app.get('/', (req, res) => {
res.send('Hello World');
});
// Escucha activa del servidor
app.listen(port, () => {
console.log(`Servidor ejecutándose en el puerto ${port}`);
});
Estructura de un Proyecto y Ciclo de Vida de las Dependencias
El archivo package.json lista las dependencias directas del proyecto. Sin embargo, Express requiere múltiples paquetes accesorios para funcionar (módulos para parseo de encabezados, gestión de rutas, tipos MIME, etc.).
- Árbol de Subdependencias: Al instalar Express, se descarga un árbol amplio de binarios y módulos subordinados visibles dentro de
package-lock.jsonynode_modules. - Ciclo de Vida Independiente: Cada subdependencia posee su propio ciclo de desarrollo, mantenimiento y actualización. Si un módulo secundario desatiende sus parches de seguridad, expone todo el servidor a vulnerabilidades.
- Compromiso de Desarrollo (Trade-off):
- Servidor Nativo de Node.js: Menos líneas abstraídas, mayor volumen de código manual, pero menor superficie de ataque al utilizar solo módulos nativos.
- Servidor con Express.js: Reducción drástica del código fuente written (menos de 13 líneas), desarrollo ágil, pero mayor carga operativa de mantenimiento y mayor superficie de vulnerabilidad expuesta por subdependencias.
Patrón Arquitectónico en Capas (Modularización Profunda)
Para aplicaciones de producción monolíticas divididas por servicios de API REST, no es viable mantener todo el código en un único archivo. Se implementa un patrón de arquitectura modular organizado por carpetas temáticas para separar responsabilidades y facilitar la lectura, el mantenimiento y el debugging.
Estructura del Proyecto:
├── app.js / index.js # Punto de entrada principal (Servidor y Middlewares globales)
├── controllers/ # Lógica de gestión de negocio (ej. userController.js)
├── models/ # Estructura de datos o integración con bases de datos (ej. userModel.js)
├── routes/ # Definición y mapeo de endpoints (ej. userRoutes.js)
├── services/ # Servicios de interrelación externa o lógica secundaria
├── middlewares/ # Middlewares cross (autenticación, loggers, errorHandler.js)
├── package.json # Configuración de dependencias
├── package-lock.json # Árbol exacto de subdependencias instaladas
└── README.md # Documentación técnica obligatoria del proyecto
Descripción de las Capas Lógicas:
- Punto de Entrada (
**app.js**): Instancia Express, configura los middlewares globales, enlaza el prefijo de las rutas y activa la escucha en el puerto. - Rutas (
**routes/**): Utilizan el móduloexpress.Router()para definir los endpoints HTTP y asignarle a cada uno su función controladora correspondiente. - Controladores (
**controllers/**): Procesan las peticiones (req), ejecutan la validación primaria de parámetros, invocan a los modelos o servicios y devuelven la respuesta HTTP estructurada (res). - Modelos (
**models/**): Gestionan la persistencia, la estructura de las entidades y las operaciones CRUD (inicialmente simuladas mediante arreglos en memoria, posteriormente conectadas a motores de base de datos). - Middlewares (
**middlewares/**): Controlan aspectos transversales como la autorización (middlewares de tipo Guardrail), registro de eventos (logging) y captura centralizada de errores.
Resumen Parcial y Puntos Clave
- Express.js abstrae el módulo HTTP nativo de Node.js, reduciendo la complejidad del código.
- El archivo de entrada (
app.jsoindex.js) centraliza la configuración base del servidor. - El uso de frameworks introduce una mayor superficie de vulnerabilidad debido al árbol de subdependencias en
node_modules. - La modularización en carpetas (
controllers,models,routes,middlewares) es indispensable para la escalabilidad del software.
4. Ejemplos Prácticos y Análisis de Código Paso a Paso
Caso Práctico 1: Servidor de Archivos Estáticos y Variables de Entorno
A continuación se presenta un ejemplo donde el servidor lee el puerto desde el sistema operativo mediante el módulo nativo process.env y sirve un archivo HTML relativo utilizando el identificador global __dirname.
const express = require('express');
const path = require('path');
const app = express();
// Configuración dinámica del puerto a través de variables de entorno del Sistema Operativo
const port = process.env.PORT || 4000;
// Middleware para procesar JSON en el cuerpo de las peticiones
app.use(express.json());
// Servir un archivo HTML de forma relativa desde la raíz del proyecto
app.get('/', (req, res) => {
// __dirname otorga la ruta absoluta del directorio donde reside app.js
res.sendFile(path.join(__dirname, 'index.html'));
});
app.listen(port, () => {
console.log(`Servidor activo en el puerto ${port}`);
});
Nota didáctica: Si el cliente realiza una modificación en el archivo index.html servido y no observa los cambios al recargar el navegador, se debe tener precaución con el almacenamiento en caché local (browser cache).
Caso Práctico 2: Sistema Completo de Gestión de Usuarios (CRUD)
Este desarrollo demuestra la interacción completa entre la capa de servidor (app.js), el ruteador (userRoutes.js), el controlador (userController.js) y el modelo de datos simulado en memoria (userModel.js).
Capa 1: Punto de Entrada Principal (app.js)
const express = require('express');
const userRoutes = require('./routes/userRoutes');
const errorHandler = require('./middlewares/errorHandler');
const app = express();
// Habilitar el parseo automático de JSON
app.use(express.json());
// Prefijo obligatorio para todas las rutas de usuarios
app.use('/api/users', userRoutes);
// Middleware centralizado de gestión de errores
app.use(errorHandler);
// Definición segura del puerto
const port = process.env.PORT || 4000;
app.listen(port, () => {
console.log(`Servidor API REST de Usuarios corriendo en el puerto ${port}`);
});
Capa 2: Ruteador de Usuarios (routes/userRoutes.js)
const express = require('express');
const router = express.Router();
const userController = require('../controllers/userController');
// Mapeo de rutas utilizando el router de Express
router.get('/', userController.getAllUsers);
router.post('/', userController.createUser);
router.get('/:id', userController.getUserById);
router.put('/:id', userController.updateUser);
router.delete('/:id', userController.deleteUser);
module.exports = router;
Capa 3: Modelo de Datos en Memoria (models/userModel.js)
// Simulación de una base de datos basada en arreglos en memoria
let users = [
{ id: 1, name: 'Juan Perez' },
{ id: 2, name: 'Maria Gomez' }
];
module.exports = {
getAll: () => users,
getById: (id) => users.find(u => u.id === id),
create: (userData) => {
const newId = users.length > 0 ? users.length + 1 : 1;
const newUser = { id: newId, ...userData };
users.push(newUser);
return newUser;
},
update: (id, userData) => {
const index = users.findIndex(u => u.id === id);
// Validación: index debe ser distinto de -1 para confirmar existencia
if (index !== -1) {
users[index] = { id, ...userData };
return users[index];
}
return null;
},
delete: (id) => {
const index = users.findIndex(u => u.id === id);
if (index !== -1) {
const deleted = users.splice(index, 1);
return deleted[0];
}
return null;
}
};
Capa 4: Controlador de Lógica de Negocio (controllers/userController.js)
const userModel = require('../models/userModel');
// Obtenemos todos los usuarios
exports.getAllUsers = (req, res) => {
const data = userModel.getAll();
res.status(200).json(data);
};
// Creación de usuario
exports.createUser = (req, res) => {
const newUser = userModel.create(req.body);
// Código HTTP 201: Elemento Creado Exitosamente
res.status(201).json(newUser);
};
// Obtención de usuario por ID
exports.getUserById = (req, res) => {
// Conversión forzada del parámetro recibido por URL a número entero
const userId = parseInt(req.params.id, 10);
const user = userModel.getById(userId);
// Verificación condicional de existencia
if (!user) {
// Código HTTP 404: Not Found
return res.status(404).json({ message: "usuario no encontrado" });
}
res.status(200).json(user);
};
// Actualización de usuario
exports.updateUser = (req, res) => {
const userId = parseInt(req.params.id, 10);
const updatedUser = userModel.update(userId, req.body);
if (!updatedUser) {
return res.status(404).json({ message: "No se pudo actualizar: usuario no encontrado" });
}
res.status(200).json(updatedUser);
};
// Eliminación de usuario
exports.deleteUser = (req, res) => {
const userId = parseInt(req.params.id, 10);
const deletedUser = userModel.delete(userId);
if (!deletedUser) {
return res.status(404).json({ message: "No se pudo eliminar: usuario no encontrado" });
}
res.status(200).json({ message: "Usuario eliminado correctamente", user: deletedUser });
};
Resumen Parcial y Puntos Clave
express.Router()independiza la definición de endpoints del archivo principalapp.js.- El método
parseInt(req.params.id, 10)transforma los parámetros enviados en la URL (que por defecto se reciben como cadenas de texto) a tipos numéricos para su posterior comparación estricta. - El código de respuesta de creación exitosa de un recurso en estándares HTTP REST es 201 Created.
- El método
splice(index, 1)de los arreglos de JavaScript destruye o retira el elemento en la posición hallada.
5. Errores Comunes, Confusiones y Gestión de Seguridad
Validación Estricta de Parámetros
Un error común durante el procesamiento de peticiones es omitir la validación de tipos de datos al extraer valores numéricos de req.params.
// ERROR COMÚN:
// req.params.id es un String ("1"), mientras que u.id en el modelo es un Number (1).
// Si se utiliza comparación estricta (===) sin parsear, la búsqueda fallará.
const user = users.find(u => u.id === req.params.id); // Devuelve undefined
// SOLUCIÓN CORRECTA:
const userId = parseInt(req.params.id, 10);
const user = users.find(u => u.id === userId); // Comparación correcta por contenido y tipo
Se deben aplicar siempre operadores de igualdad estricta (===) acompañados de la conversión de tipos previa, garantizando que los datos introducidos no rompan la lógica interna del servidor.
Vulnerabilidades en la Cadena de Suministro (Supply Chain Attacks)
La inclusión de bibliotecas mediante gestores de paquetes como npm facilita el desarrollo acelerado pero amplía considerablemente la superficie de vulnerabilidad.
- Riesgo: Express.js arrastra docenas de subdependencias. Si los mantenedores de algún paquete secundario sufren el secuestro de sus credenciales o introducen vulnerabilidades, el proyecto backend queda expuesto.
- Mitigación:
- Mantener dependencias al mínimo indispensable.
- Ejecutar auditorías periódicas de paquetes (
npm audit). - Monitorear parches de seguridad y actualizar las versiones a la última entrega estable.
- Utilizar entornos de desarrollo automatizados como
nodemonpara acelerar pruebas sin alterar la configuración del entorno de producción.
Lógica del Índice -1 en Búsqueda sobre Arreglos
Al modificar o eliminar elementos utilizando los métodos findIndex(), el sistema devuelve el valor -1 si no encuentra correspondencia. Un error habitual es intentar operar sobre la posición -1, lo que altera de manera indeseada el último elemento del arreglo si se usa splice.
// Verificación correcta exigida en controladores/modelos:
if (index !== -1) {
// El elemento existe en el arreglo; es seguro operar.
users.splice(index, 1);
} else {
// Manejar el error de inexistencia (devuelve 404).
}
6. Fechas Importantes y Avisos Académicos
A partir del análisis exhaustivo del contexto de la materia, se consolidan las siguientes fechas, modalidades de evaluación, requerimientos de entrega e indicaciones específicas del profesor:
Cronograma Oficial de Evaluaciones
| Fecha | Evento / Evaluación | Modalidad | Descripción Detallada |
| 08/10 | Parcial 1 | Virtual (Sincrónico) | Examen teórico-práctico en la plataforma institucional. - Condición obligatoria: Cámara web encendida durante todo el examen. - Formato: Opción múltiple (Multiple Choice), preguntas de conceptos base y análisis de bloques de código/funciones de las Unidades 1 y 2. |
| 29/10 | Parcial 2 (Trabajo Práctico 2) | Presencial (Individual) | Presentación y defensa individual de aplicación Express.js. - Desarrollo de un servidor API REST (ej. gestión de productos/usuarios) sin base de datos (datos estructurados en memoria). - Requiere ruteo, manejo de métodos HTTP, códigos de respuesta estándar y captura de parámetros (query params y route params). |
| 19/11 | Parcial 3 (Trabajo Práctico 3) | Presencial (Individual) | Presentación incremental del sistema. - Construido sobre la base del Trabajo Práctico 2. - Incorporación obligatoria de temas de la Unidad 3: autenticación, autorización, middlewares de protección (Guardrail) y buenas prácticas de registro (logging). - Requisito: Integrar todas las correcciones y mejoras señaladas en el Parcial 2. |
| 26/11 | Recuperatorio General | Presencial | Única instancia de calibración o recuperación de notas. - Destinado a alumnos ausentes o aplazados en cualquiera de las instancias anteriores (Parcial 1, 2 o 3). |
| 30/11 | Cierre de Actas Academicas | Administrativo | Entrega definitiva de notas finales de la asignatura. |
Requisitos Técnicos Obligatorios Exigidos por el Profesor
- Inclusión Obligatoria del Archivo
**README.md**: Todos los proyectos de código presentados de aquí en adelante deben incluir obligatoriamente en la raíz un archivoREADME.mdexplicativo redactado para un tercero. Debe contener:- Instrucciones paso a paso para la clonación del repositorio e instalación de dependencias (
npm install). - Comandos para iniciar el servidor en entorno de desarrollo (
npm run dev/nodemon) y comandos de prueba (testing). - Tabla Documentada de Endpoints: Cuadro estructurado especificando:
- Método HTTP (GET, POST, PUT, DELETE).
- Ruta / Endpoint.
- Parámetros esperados (Query Params / Route Params / Payload Body).
- Descripción funcional en español del comportamiento.
- Instrucciones paso a paso para la clonación del repositorio e instalación de dependencias (
- Defensa Individual de Código: Durante las entregas presenciales de los Parciales 2 y 3, el profesor realizará preguntas de validación directa sobre la autoría del código presentados (ejemplos: explicación de la estructura del
req, ciclo de vida de un middleware, razonamiento del ruteo, uso deparseInt, etc.).
7. Síntesis y Conclusiones
Resumen Estructurado de Ideas Principales
- Abstracción y Eficiencia: Express.js se consolida como el framework estándar para Node.js, reduciendo la escritura de servidores web a configuraciones minimalistas y agrupadas bajo una sintaxis unificada de verbos HTTP (
get,post,put,delete). - Separación de Responsabilidades: La arquitectura profesional requerida fragmenta el backend en capas desacopladas: Punto de entrada (
app.js), Ruteador (routes), Lógica de Negocio (controllers), Datos (models) y Controladores Transversales (middlewares). - Seguridad: El uso masivo de paquetes en
node_modulesexige un monitoreo activo contra ataques a la cadena de suministro (supply chain attacks), procurando mantener dependencias mínimas y actualizadas. - Robustez en el Ruteo: Toda entrada proveniente del cliente a través de la URI (
req.params) o del cuerpo (req.body) debe parsearse y validarse formalmente tanto por contenido como por tipo de dato estricto antes de procesarse en la lógica del sistema.
8. Preguntas de Repaso (Tipo Examen)
Nivel Básico
- ¿Cuál es la función principal del archivo de entrada (
**index.js**/**app.js**) en una aplicación desarrollada con Express.js?- Respuesta: Funciona como el archivo raíz o madre del proyecto desde el cual Node.js arranca la aplicación. Se encarga de importar Express, instanciar la aplicación, configurar los middlewares globales, establecer los prefijos de las rutas de la API y activar la escucha en un puerto específico mediante
app.listen().
- Respuesta: Funciona como el archivo raíz o madre del proyecto desde el cual Node.js arranca la aplicación. Se encarga de importar Express, instanciar la aplicación, configurar los middlewares globales, establecer los prefijos de las rutas de la API y activar la escucha en un puerto específico mediante
- ¿Qué comando de npm se utiliza para instalar Express.js y registrarlo como dependencia del proyecto?
- Respuesta: El comando es
npm install express(onpm i express). Registra la librería en el objetodependenciesdel archivopackage.jsony descarga los paquetes ennode_modules.
- Respuesta: El comando es
- ¿Cuál es la diferencia entre el parámetro
**req**y el parámetro**res**en una función de callback de ruta?- Respuesta:
req(Request) es el objeto que contiene la información enviada por el cliente (encabezados, parámetros en URL, cuerpo JSON).res(Response) es el objeto que provee los métodos para construir y enviar la respuesta HTTP desde el servidor hacia el cliente (ej.res.status(),res.json(),res.sendFile()).
- Respuesta:
Nivel Intermedio
- Explique el riesgo de seguridad asociado a la "Cadena de Suministro" (Supply Chain Attack) cuando se trabaja con Node.js y Express.js.
- Respuesta: Al instalar Express.js, se descargan múltiples subdependencias indirectas dentro de
node_modules. Si alguno de los paquetes de segundo o tercer nivel es comprometido o desatendido por sus mantenedores, se pueden introducir vulnerabilidades en el servidor sin el conocimiento directo del desarrollador. La estrategia de mitigación implica mantener dependencias mínimas indispensables, auditar regularmente los paquetes y actualizar a versiones estables.
- Respuesta: Al instalar Express.js, se descargan múltiples subdependencias indirectas dentro de
- Analice el siguiente bloque de código e identifique el error de lógica que provocará que la búsqueda siempre devuelva
**undefined**:
app.get('/users/:id', (req, res) => {
const users = [{ id: 1, name: 'Ana' }, { id: 2, name: 'Pedro' }];
const user = users.find(u => u.id === req.params.id);
res.json(user);
});
- Respuesta: El error reside en que
req.params.idsiempre extrae los parámetros de la URL como un tipoString(ej."1"), mientras que eliddentro del arreglouserses de tipoNumber(1). Al utilizar el operador de comparación estricta (===), se evalúan tipo y valor, resultando falso. La solución es convertir el parámetro previamente a número:const userId = parseInt(req.params.id, 10);y luego compararu.id === userId.
- ¿Qué ventaja operativa ofrece la herramienta
**nodemon**durante la fase de desarrollo backend?- Respuesta:
nodemones un servicio de utilidad que monitorea de forma continua los archivos del código fuente del proyecto. Ante cualquier cambio guardado en el código, reinicia automáticamente el servidor Node.js sin necesidad de detener y levantar manualmente el proceso por consola.
- Respuesta:
Nivel Avanzado
- Describa el flujo de datos completo a través de las capas arquitectónicas (
**routes**,**controllers**,**models**) cuando una petición**POST**ingresa a la aplicación para crear un nuevo recurso.- Respuesta:
- La petición
POSTingresa aapp.jsy es redirigida al ruteador (routes) según su prefijo de URL. - El archivo de rutas mapea el método HTTP
POSTy la ruta raíz'/'enviando la ejecución al controlador asociado (userController.createUser). - El controlador toma los datos parseados de la petición presentes en
req.bodyy se los transmite como parámetro al métodocreatedel modelo (userModel). - El modelo procesa la inclusión del recurso en el arreglo o base de datos (calculando un nuevo ID y realizando un
push), y retorna el objeto resultante al controlador. - El controlador recibe la respuesta del modelo y emite una respuesta HTTP hacia el cliente estableciendo el código de estado
201 Createdy enviando el objeto creado codificado en formato JSON medianteres.status(201).json(newUser).
- La petición
- Respuesta:
- ¿Por qué en los métodos de actualización o eliminación que utilizan arreglos en memoria se debe verificar explícitamente que el resultado de
**findIndex()**sea distinto de**-1**?- Respuesta: El método
findIndex()devuelve-1cuando no encuentra ningún elemento que cumpla con el criterio planteado. Si no se valida esta condición y se pasa directamente el valor-1a una operación de modificación o al métodosplice(index, 1), JavaScript interpretará el índice-1comenzando la búsqueda desde el final del arreglo, eliminando o alterando involuntariamente el último elemento válido guardado. Por ende, evaluarif (index !== -1)previene la corrupción no deseada de datos y permite retornar a tiempo un estado404 Not Found.
- Respuesta: El método