Middleware en Express

El middleware constituye el núcleo arquitectónico de Express, funcionando como una serie de funciones que se ejecutan secuencialmente durante el ciclo de vida de una petición HTTP. Cada función de middleware tiene acceso a los objetos de petición (req), respuesta (res) y la función next() que permite continuar con el siguiente middleware en la cadena.

Anatomía del middleware

Una función de middleware en Express sigue una estructura específica que incluye tres parámetros fundamentales:

function miMiddleware(req, res, next) {
  // Lógica del middleware
  console.log('Middleware ejecutado');
  next(); // Continúa al siguiente middleware
}

El parámetro next es crucial para el flujo de control. Si no se invoca next(), la petición quedará colgada y nunca llegará a su destino final. Este mecanismo permite crear cadenas de procesamiento donde cada middleware puede modificar la petición, realizar validaciones o ejecutar lógica específica.

Tipos de middleware

Express organiza el middleware en diferentes categorías según su propósito y momento de ejecución:

Middleware de aplicación se registra directamente en la instancia de Express:

const express = require('express');
const app = express();

// Middleware que se ejecuta en todas las rutas
app.use((req, res, next) => {
  req.timestamp = Date.now();
  next();
});

// Middleware específico para una ruta
app.use('/api', (req, res, next) => {
  console.log('Acceso a API');
  next();
});

Middleware de router funciona de manera similar pero se aplica a un router específico:

const router = express.Router();

router.use((req, res, next) => {
  console.log('Middleware del router');
  next();
});

router.get('/users', (req, res) => {
  res.json({ users: [] });
});

Middleware incorporado

Express incluye middleware integrado que cubre necesidades comunes de desarrollo web:

// Servir archivos estáticos
app.use(express.static('public'));

// Parsear JSON en el cuerpo de las peticiones
app.use(express.json());

// Parsear datos de formularios URL-encoded
app.use(express.urlencoded({ extended: true }));

El middleware express.json() es especialmente importante para APIs REST, ya que permite que Express procese automáticamente el cuerpo de las peticiones que contienen JSON y lo haga disponible en req.body.

Orden de ejecución

El orden de registro del middleware determina su secuencia de ejecución. Express procesa el middleware en el orden exacto en que se define:

// Primer middleware - logging
app.use((req, res, next) => {
  console.log(`${req.method} ${req.path}`);
  next();
});

// Segundo middleware - autenticación
app.use((req, res, next) => {
  if (req.headers.authorization) {
    req.user = { id: 1, name: 'Usuario' };
  }
  next();
});

// Tercer middleware - validación
app.use('/protected', (req, res, next) => {
  if (!req.user) {
    return res.status(401).json({ error: 'No autorizado' });
  }
  next();
});

Manejo de errores

El middleware de manejo de errores requiere cuatro parámetros y debe registrarse después de todas las rutas:

// Middleware de manejo de errores
app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).json({ 
    error: 'Error interno del servidor',
    message: err.message 
  });
});

Para activar el middleware de errores, se puede pasar un error al método next():

app.get('/error-example', (req, res, next) => {
  const error = new Error('Algo salió mal');
  error.status = 400;
  next(error); // Pasa al middleware de errores
});

Middleware condicional

Es posible crear middleware condicional que se ejecute solo bajo ciertas circunstancias:

// Middleware que solo se ejecuta en desarrollo
if (process.env.NODE_ENV === 'development') {
  app.use((req, res, next) => {
    console.log('Modo desarrollo activo');
    next();
  });
}

// Middleware con lógica condicional interna
app.use((req, res, next) => {
  if (req.path.startsWith('/admin')) {
    // Lógica específica para rutas de administración
    console.log('Acceso a zona de administración');
  }
  next();
});

Middleware de terceros

Express tiene un ecosistema extenso de middleware de terceros que amplía sus capacidades:

const cors = require('cors');
const helmet = require('helmet');
const morgan = require('morgan');

// Middleware de seguridad
app.use(helmet());

// Middleware de CORS
app.use(cors({
  origin: 'http://localhost:3000',
  credentials: true
}));

// Middleware de logging
app.use(morgan('combined'));

La modularidad del sistema de middleware permite componer aplicaciones complejas combinando funcionalidades específicas según las necesidades del proyecto.