Express API REST

Express.js se ha consolidado como el framework web más utilizado para Node.js, proporcionando una base sólida y flexible para construir APIs REST de nivel profesional.

Su filosofía minimalista y su extenso ecosistema de middlewares lo convierten en la elección preferida por desarrolladores y empresas para crear servicios web escalables y mantenibles.

¿Qué es Express.js?

Express.js es un framework web minimalista para Node.js que simplifica significativamente el proceso de creación de aplicaciones web y APIs. A diferencia de otros frameworks más pesados, Express adopta un enfoque no opinativo, permitiendo a los desarrolladores estructurar sus aplicaciones según sus necesidades específicas.

El framework proporciona una capa de abstracción sobre el módulo HTTP nativo de Node.js, ofreciendo características esenciales como:

• Sistema de enrutamiento robusto y flexible
• Gestión de middlewares para el procesamiento de peticiones
• Manejo simplificado de peticiones y respuestas HTTP
• Integración nativa con motores de plantillas
• Soporte completo para métodos HTTP estándar

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

// Ruta básica
app.get('/', (req, res) => {
  res.json({ mensaje: 'API funcionando correctamente' });
});

app.listen(3000, () => {
  console.log('Servidor ejecutándose en puerto 3000');
});

Arquitectura REST

Las APIs REST (Representational State Transfer) definen un conjunto de principios arquitectónicos para diseñar servicios web que sean escalables, mantenibles y fáciles de consumir. Express.js facilita enormemente la implementación de estos principios mediante su sistema de enrutamiento y manejo de métodos HTTP.

Principios REST fundamentales

Los servicios REST se basan en varios conceptos clave que Express implementa de manera natural:

• Recursos identificables: Cada recurso tiene una URL única
• Métodos HTTP estándar: GET, POST, PUT, DELETE para diferentes operaciones
• Representaciones: Los datos se intercambian en formatos como JSON
• Sin estado: Cada petición contiene toda la información necesaria

// Ejemplo de rutas RESTful para un recurso 'usuarios'
app.get('/api/usuarios', obtenerUsuarios);        // Listar todos
app.get('/api/usuarios/:id', obtenerUsuario);     // Obtener uno específico
app.post('/api/usuarios', crearUsuario);          // Crear nuevo
app.put('/api/usuarios/:id', actualizarUsuario);  // Actualizar completo
app.delete('/api/usuarios/:id', eliminarUsuario); // Eliminar

Métodos HTTP

Express proporciona métodos específicos para cada verbo HTTP, permitiendo una implementación clara y semánticamente correcta de las operaciones CRUD (Create, Read, Update, Delete).

GET: Recuperación de datos

El método GET se utiliza para recuperar información sin modificar el estado del servidor. Express maneja estas peticiones de forma eficiente, permitiendo tanto la recuperación de colecciones completas como de recursos específicos.

// Obtener todos los productos
app.get('/api/productos', (req, res) => {
  const productos = obtenerTodosLosProductos();
  res.json(productos);
});

// Obtener producto específico
app.get('/api/productos/:id', (req, res) => {
  const { id } = req.params;
  const producto = obtenerProductoPorId(id);
  
  if (!producto) {
    return res.status(404).json({ error: 'Producto no encontrado' });
  }
  
  res.json(producto);
});

POST: Creación de recursos

Las peticiones POST permiten crear nuevos recursos en el servidor. Express facilita el acceso a los datos enviados en el cuerpo de la petición mediante middlewares de parsing.

app.use(express.json()); // Middleware para parsear JSON

app.post('/api/productos', (req, res) => {
  const { nombre, precio, categoria } = req.body;
  
  // Validación básica
  if (!nombre || !precio) {
    return res.status(400).json({ 
      error: 'Nombre y precio son obligatorios' 
    });
  }
  
  const nuevoProducto = crearProducto({ nombre, precio, categoria });
  res.status(201).json(nuevoProducto);
});

PUT y PATCH: Actualización de recursos

Express distingue entre actualizaciones completas (PUT) y actualizaciones parciales (PATCH), permitiendo implementar estrategias de actualización flexibles según las necesidades de la aplicación.

// Actualización completa con PUT
app.put('/api/productos/:id', (req, res) => {
  const { id } = req.params;
  const datosCompletos = req.body;
  
  const productoActualizado = reemplazarProducto(id, datosCompletos);
  res.json(productoActualizado);
});

// Actualización parcial con PATCH
app.patch('/api/productos/:id', (req, res) => {
  const { id } = req.params;
  const cambios = req.body;
  
  const productoActualizado = actualizarProductoParcial(id, cambios);
  res.json(productoActualizado);
});

Parámetros y Query Strings

Express proporciona acceso directo a diferentes tipos de parámetros que pueden enviarse en las peticiones HTTP, facilitando la creación de APIs flexibles y expresivas.

Parámetros de ruta

Los parámetros de ruta permiten capturar valores dinámicos directamente desde la URL, proporcionando una forma limpia de identificar recursos específicos.

// Parámetro simple
app.get('/api/usuarios/:id', (req, res) => {
  const userId = req.params.id;
  // Procesar petición...
});

// Múltiples parámetros
app.get('/api/usuarios/:userId/pedidos/:pedidoId', (req, res) => {
  const { userId, pedidoId } = req.params;
  // Procesar petición con ambos parámetros...
});

Query parameters

Los query parameters ofrecen una forma flexible de enviar parámetros opcionales, especialmente útiles para filtrado, paginación y ordenamiento.

app.get('/api/productos', (req, res) => {
  const { 
    categoria, 
    precio_min, 
    precio_max, 
    orden = 'nombre',
    pagina = 1,
    limite = 10 
  } = req.query;
  
  const filtros = {
    categoria,
    precioMin: precio_min,
    precioMax: precio_max
  };
  
  const productos = buscarProductos(filtros, orden, pagina, limite);
  res.json(productos);
});

Request y response

Express enriquece significativamente los objetos de petición y respuesta nativos de Node.js, proporcionando métodos y propiedades adicionales que simplifican el desarrollo de APIs.

Request

El objeto request contiene toda la información sobre la petición HTTP entrante, incluyendo datos, cabeceras, parámetros y metadatos útiles.

app.post('/api/analizar-peticion', (req, res) => {
  // Información básica de la petición
  console.log('Método:', req.method);
  console.log('URL:', req.url);
  console.log('IP del cliente:', req.ip);
  
  // Cabeceras
  console.log('User-Agent:', req.get('User-Agent'));
  console.log('Content-Type:', req.get('Content-Type'));
  
  // Datos de la petición
  console.log('Parámetros de ruta:', req.params);
  console.log('Query parameters:', req.query);
  console.log('Cuerpo de la petición:', req.body);
  
  res.json({ mensaje: 'Petición analizada correctamente' });
});

Response

El objeto response proporciona métodos para enviar respuestas al cliente, configurar cabeceras y gestionar el estado de la respuesta.

app.get('/api/respuesta-completa', (req, res) => {
  // Configurar cabeceras
  res.set('X-API-Version', '1.0');
  res.set('Cache-Control', 'no-cache');
  
  // Configurar código de estado y enviar respuesta
  res.status(200).json({
    datos: { mensaje: 'Respuesta exitosa' },
    timestamp: new Date().toISOString(),
    version: '1.0'
  });
});