Rutas y manejo de solicitudes en Express

Métodos HTTP

Los métodos HTTP son las acciones fundamentales que definen el tipo de operación que queremos realizar sobre un recurso del servidor. Express proporciona métodos específicos para manejar cada uno de estos tipos de solicitud, permitiendo crear aplicaciones web y APIs estructuradas y eficientes.

Métodos HTTP principales

Express implementa los métodos HTTP más utilizados a través de funciones específicas que se ejecutan cuando el servidor recibe una solicitud del tipo correspondiente. Los métodos más comunes son GET, POST, PUT, DELETE y PATCH, cada uno con un propósito específico en el desarrollo web moderno.

El método GET se utiliza para solicitar información del servidor sin modificar datos. Es el método más básico y seguro, ya que no produce efectos secundarios en el servidor:

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

// Ruta GET básica
app.get('/', (req, res) => {
    res.send('¡Bienvenido a mi aplicación Express!');
});

// GET para obtener una lista de usuarios
app.get('/usuarios', (req, res) => {
    const usuarios = ['Ana', 'Carlos', 'María'];
    res.json(usuarios);
});

El método POST se emplea para enviar datos al servidor y crear nuevos recursos. Los datos se envían en el cuerpo de la solicitud:

// Middleware para procesar JSON (necesario para POST)
app.use(express.json());

// POST para crear un nuevo usuario
app.post('/usuarios', (req, res) => {
    const nuevoUsuario = req.body;
    console.log('Usuario recibido:', nuevoUsuario);
    
    // Simulamos la creación del usuario
    res.status(201).json({
        mensaje: 'Usuario creado exitosamente',
        usuario: nuevoUsuario
    });
});

El método PUT se utiliza para actualizar completamente un recurso existente, reemplazando toda la información:

// PUT para actualizar un usuario completo
app.put('/usuarios/:id', (req, res) => {
    const id = req.params.id;
    const datosActualizados = req.body;
    
    // Simulamos la actualización
    res.json({
        mensaje: `Usuario ${id} actualizado completamente`,
        datos: datosActualizados
    });
});

El método PATCH permite actualizaciones parciales de un recurso, modificando solo los campos especificados:

// PATCH para actualizar parcialmente un usuario
app.patch('/usuarios/:id', (req, res) => {
    const id = req.params.id;
    const cambios = req.body;
    
    res.json({
        mensaje: `Usuario ${id} actualizado parcialmente`,
        cambios: cambios
    });
});

El método DELETE se emplea para eliminar recursos del servidor:

// DELETE para eliminar un usuario
app.delete('/usuarios/:id', (req, res) => {
    const id = req.params.id;
    
    // Simulamos la eliminación
    res.json({
        mensaje: `Usuario ${id} eliminado correctamente`
    });
});

Diferencias entre métodos de actualización

La distinción entre PUT y PATCH es importante en el desarrollo de APIs REST. PUT requiere enviar todos los datos del recurso, incluso los que no cambian, mientras que PATCH solo necesita los campos a modificar:

// Ejemplo comparativo: actualizar información de usuario

// PUT - Requiere todos los campos
app.put('/perfil/:id', (req, res) => {
    // Se espera: { nombre: "Ana", email: "ana@email.com", edad: 25 }
    const perfilCompleto = req.body;
    
    res.json({
        mensaje: 'Perfil reemplazado completamente',
        perfil: perfilCompleto
    });
});

// PATCH - Solo los campos a cambiar
app.patch('/perfil/:id', (req, res) => {
    // Se puede enviar: { edad: 26 } solamente
    const cambios = req.body;
    
    res.json({
        mensaje: 'Perfil actualizado parcialmente',
        cambios: cambios
    });
});

Manejo de múltiples métodos en una ruta

Express permite manejar múltiples métodos HTTP en la misma ruta utilizando app.route() o definiendo métodos específicos para cada endpoint:

// Método encadenado para una misma ruta
app.route('/productos')
    .get((req, res) => {
        res.json({ mensaje: 'Obtener todos los productos' });
    })
    .post((req, res) => {
        res.json({ mensaje: 'Crear nuevo producto', datos: req.body });
    });

// O definir cada método por separado
app.get('/productos/:id', (req, res) => {
    res.json({ mensaje: `Obtener producto ${req.params.id}` });
});

app.delete('/productos/:id', (req, res) => {
    res.json({ mensaje: `Eliminar producto ${req.params.id}` });
});

Códigos de estado HTTP

Cada método HTTP debe devolver códigos de estado apropiados para indicar el resultado de la operación. Express facilita esto a través del método status():

app.get('/datos', (req, res) => {
    // 200 OK (por defecto para GET exitoso)
    res.json({ datos: 'información solicitada' });
});

app.post('/crear', (req, res) => {
    // 201 Created para recursos nuevos
    res.status(201).json({ mensaje: 'Recurso creado' });
});

app.put('/actualizar/:id', (req, res) => {
    // 200 OK para actualización exitosa
    res.status(200).json({ mensaje: 'Recurso actualizado' });
});

app.delete('/eliminar/:id', (req, res) => {
    // 204 No Content para eliminación exitosa
    res.status(204).send();
});

Parámetros de ruta y de consulta

Los parámetros en Express permiten capturar información dinámica desde las URLs, haciendo que las aplicaciones sean flexibles y puedan responder de manera personalizada según los datos recibidos. Existen dos tipos principales: los parámetros de ruta, que forman parte del camino de la URL, y los parámetros de consulta, que se envían después del símbolo de interrogación.

Parámetros de ruta

Los parámetros de ruta se definen en el camino de la URL utilizando dos puntos (:) seguidos del nombre del parámetro. Express captura automáticamente estos valores y los hace disponibles a través del objeto req.params.

// Parámetro simple en la ruta
app.get('/usuarios/:id', (req, res) => {
    const userId = req.params.id;
    res.json({
        mensaje: `Obteniendo información del usuario ${userId}`,
        parametro: userId
    });
});

// Múltiples parámetros en una ruta
app.get('/tienda/:categoria/:producto', (req, res) => {
    const { categoria, producto } = req.params;
    
    res.json({
        mensaje: 'Producto encontrado',
        categoria: categoria,
        producto: producto
    });
});

Parámetros opcionales y comodines

Express permite definir parámetros opcionales utilizando el símbolo de interrogación (?) y parámetros comodín con el asterisco (*):

// Parámetro opcional - el año puede estar presente o no
app.get('/articulos/:titulo/:año?', (req, res) => {
    const titulo = req.params.titulo;
    const año = req.params.año || 'No especificado';
    
    res.json({
        titulo: titulo,
        año: año
    });
});

// Parámetro comodín para capturar múltiples segmentos
app.get('/archivos/*', (req, res) => {
    const rutaCompleta = req.params[0]; // El comodín se almacena en el índice 0
    
    res.json({
        mensaje: 'Accediendo a archivo',
        ruta: rutaCompleta
    });
});

Parámetros de consulta

Los parámetros de consulta (query parameters) se envían después del símbolo ? en la URL y están disponibles a través del objeto req.query. Son especialmente útiles para filtros, paginación y opciones de configuración:

// URL de ejemplo: /buscar?termino=javascript&categoria=tutorial&orden=fecha
app.get('/buscar', (req, res) => {
    const termino = req.query.termino;
    const categoria = req.query.categoria;
    const orden = req.query.orden || 'relevancia'; // valor por defecto
    
    res.json({
        busqueda: {
            termino: termino,
            categoria: categoria,
            ordenarPor: orden
        }
    });
});

// Múltiples valores para el mismo parámetro
// URL: /productos?tag=electronica&tag=oferta&tag=nuevo
app.get('/productos', (req, res) => {
    const tags = req.query.tag; // Puede ser string o array
    const tagsArray = Array.isArray(tags) ? tags : [tags];
    
    res.json({
        mensaje: 'Productos filtrados',
        tags: tagsArray
    });
});

Combinando parámetros de ruta y consulta

En aplicaciones reales es común combinar ambos tipos de parámetros para crear endpoints flexibles y expresivos:

// URL: /usuarios/123/pedidos?estado=pendiente&limite=10&pagina=1
app.get('/usuarios/:id/pedidos', (req, res) => {
    const userId = req.params.id;
    const estado = req.query.estado || 'todos';
    const limite = parseInt(req.query.limite) || 20;
    const pagina = parseInt(req.query.pagina) || 1;
    
    res.json({
        usuario: userId,
        filtros: {
            estado: estado,
            limite: limite,
            pagina: pagina
        },
        mensaje: `Obteniendo pedidos del usuario ${userId}`
    });
});

Validación y conversión de tipos

Los parámetros siempre llegan como cadenas de texto, por lo que es importante validar y convertir los tipos cuando sea necesario:

app.get('/calcular/:numero1/:numero2', (req, res) => {
    const num1 = parseFloat(req.params.numero1);
    const num2 = parseFloat(req.params.numero2);
    const operacion = req.query.op || 'suma';
    
    // Validación básica
    if (isNaN(num1) || isNaN(num2)) {
        return res.status(400).json({
            error: 'Los parámetros deben ser números válidos'
        });
    }
    
    let resultado;
    switch(operacion) {
        case 'suma':
            resultado = num1 + num2;
            break;
        case 'resta':
            resultado = num1 - num2;
            break;
        case 'multiplicacion':
            resultado = num1 * num2;
            break;
        default:
            return res.status(400).json({
                error: 'Operación no válida'
            });
    }
    
    res.json({
        numero1: num1,
        numero2: num2,
        operacion: operacion,
        resultado: resultado
    });
});

Desestructuración y valores por defecto

Una técnica útil es utilizar desestructuración junto con valores por defecto para hacer el código más limpio y robusto:

app.get('/api/productos/:categoria', (req, res) => {
    const { categoria } = req.params;
    
    // Desestructuración con valores por defecto
    const {
        limite = 10,
        pagina = 1,
        orden = 'nombre',
        direccion = 'asc'
    } = req.query;
    
    // Validación de la categoría
    const categoriasValidas = ['electronica', 'ropa', 'hogar', 'deportes'];
    if (!categoriasValidas.includes(categoria)) {
        return res.status(404).json({
            error: 'Categoría no encontrada',
            categoriasDisponibles: categoriasValidas
        });
    }
    
    res.json({
        categoria: categoria,
        configuracion: {
            limite: parseInt(limite),
            pagina: parseInt(pagina),
            orden: orden,
            direccion: direccion
        }
    });
});

Patrones comunes de uso

Los parámetros se utilizan frecuentemente en patrones específicos que conviene conocer:

// Patrón de recurso anidado
app.get('/blogs/:blogId/comentarios/:comentarioId', (req, res) => {
    const { blogId, comentarioId } = req.params;
    
    res.json({
        mensaje: `Comentario ${comentarioId} del blog ${blogId}`,
        recurso: {
            blog: blogId,
            comentario: comentarioId
        }
    });
});

// Patrón de búsqueda y filtrado
app.get('/eventos', (req, res) => {
    const {
        ciudad,
        fecha_desde,
        fecha_hasta,
        tipo,
        precio_max
    } = req.query;
    
    const filtros = {};
    
    // Solo agregar filtros si tienen valor
    if (ciudad) filtros.ciudad = ciudad;
    if (fecha_desde) filtros.fecha_desde = fecha_desde;
    if (fecha_hasta) filtros.fecha_hasta = fecha_hasta;
    if (tipo) filtros.tipo = tipo;
    if (precio_max) filtros.precio_max = parseFloat(precio_max);
    
    res.json({
        mensaje: 'Eventos encontrados',
        filtrosAplicados: filtros
    });
});