🚂 2.7 · Express.js: APIs profesionales en minutos

🎯 Objetivo del tema

🗺️ Mapa del tema

En el Tema 2.6 creaste un servidor HTTP nativo con Node. Funcionaba, pero era verboso: tenías que parsear la URL manualmente, manejar Content-Type, hacer if/else para cada ruta. Express es una capa delgada sobre Node que te da una API más limpia, routing expresivo, middleware reutilizable, y mucho menos código boilerplate. Es el estándar de facto para APIs en Node.js desde 2010.

2.7.1 Qué es Express y por qué usarlo

Express es un framework minimalista para Node.js: añade una capa de azúcar sobre el módulo http nativo, sin opacar la libertad de Node. Es OPINIONATED solo en lo esencial: routing con métodos HTTP, middleware encadenable, y req/res con propiedades útiles. Lo demás (bases de datos, autenticación, etc.) lo eliges tú.

2.7.2 Tu primer servidor Express

Crear un servidor con Express es tan simple como: importar, instanciar, definir rutas, escuchar. En 5 líneas tienes un servidor funcionando. Las rutas se definen con app.METHOD(path, handler).

// app.js: tu primer servidor Express
import express from 'express';

const app = express();
const PORT = 3000;

// Middleware: parsear JSON del body (necesario para POST)
app.use(express.json());

// RUTAS
app.get('/', (req, res) => {
  res.json({ mensaje: 'Hola desde Express!' });
});

app.get('/api/usuarios', (req, res) => {
  res.json([
    { id: 1, nombre: 'Ana' },
    { id: 2, nombre: 'Luis' },
  ]);
});

app.post('/api/usuarios', (req, res) => {
  const { nombre } = req.body;
  res.status(201).json({ id: 3, nombre });
});

// Iniciar servidor
app.listen(PORT, () => {
  console.log(`Servidor en http://localhost:${PORT}`);
});

Servidor Express básico en 15 líneas

2.7.3 Routing: app.get, app.post, app.use

Express organiza las rutas con métodos que coinciden con los verbos HTTP: app.get para leer, app.post para crear, app.put para actualizar, app.delete para eliminar. Cada ruta recibe un handler con (req, res). También puedes agrupar rutas con Router, separando tu API en módulos.

// routes/usuarios.js: rutas agrupadas con Router
import { Router } from 'express';
const router = Router();

// Rutas: relativas al prefijo /api/usuarios
router.get('/', (req, res) => res.json([]));
router.get('/:id', (req, res) => res.json({ id: req.params.id }));
router.post('/', (req, res) => res.status(201).json({ id: 1 }));
router.put('/:id', (req, res) => res.json({ id: req.params.id, ...req.body }));
router.delete('/:id', (req, res) => res.status(204).send());

export default router;

// app.js: monta el router con un prefijo
import usuariosRouter from './routes/usuarios.js';
app.use('/api/usuarios', usuariosRouter);
// Ahora:
// GET    /api/usuarios       -> listar
// GET    /api/usuarios/5     -> ver uno
// POST   /api/usuarios       -> crear
// PUT    /api/usuarios/5     -> actualizar
// DELETE /api/usuarios/5     -> eliminar

Routing modular con Router y prefijos

2.7.4 Middleware: el concepto clave de Express

Un middleware es una función que se ejecuta ENTRE la petición y la respuesta. Pueden modificar req/res, terminar la petición (con res.send), o pasar al siguiente middleware con next(). Es el patrón que hace a Express tan extensible y elegante.

La anatomía de un middleware

// Un middleware es una función con esta firma:
function miMiddleware(req, res, next) {
  // 1. Hacer algo con la petición (logging, auth, parse, etc.)
  console.log(`${req.method} ${req.url}`);

  // 2a. O TERMINAR la petición (enviar respuesta)
  // res.status(401).json({ error: 'No autorizado' });

  // 2b. O PASAR al siguiente middleware con next()
  next();
}

// Registrarlo GLOBALMENTE (se ejecuta para TODAS las rutas):
app.use(miMiddleware);

// O solo para rutas específicas:
app.use('/api', miMiddleware);

Anatomía de un middleware

Los 5 middlewares más usados en producción

2.7.5 req y res: leer peticiones, enviar respuestas

Express enriquece los objetos req (request) y res (response) de Node con propiedades y métodos útiles. Conocerlos bien te permite manejar cualquier tipo de petición HTTP sin reinventar la rueda.

2.7.6 Manejo de errores profesional

Express tiene un mecanismo especial para errores: cuando pasas un error a next(err), salta al siguiente middleware de errores. Esto te permite tener UN SOLO lugar donde manejar todos los errores de tu app, en vez de try/catch en cada ruta.

El patrón moderno: async/await con wrapper

// utils/asyncHandler.js: wrapper que captura errores async
const asyncHandler = (fn) => (req, res, next) => {
  Promise.resolve(fn(req, res, next)).catch(next);
};

// routes/usuarios.js: uso limpio
router.get('/', asyncHandler(async (req, res) => {
  const usuarios = await db.query('SELECT * FROM usuarios');
  res.json(usuarios);
}));

router.post('/', asyncHandler(async (req, res) => {
  if (!req.body.email) {
    const error = new Error('Email requerido');
    error.status = 400;
    throw error;
  }
  const usuario = await db.query('INSERT INTO usuarios ...');
  res.status(201).json(usuario);
}));

// Middleware de errores (SIEMPRE al final, con 4 parámetros)
app.use((err, req, res, next) => {
  console.error(err.stack);
  const status = err.status || 500;
  res.status(status).json({
    error: err.message || 'Error interno del servidor',
  });
});

Manejo de errores con asyncHandler

📚 Contenido ampliado

Material adicional, referencias externas verificadas y ejemplos extendidos.