Express - framework de API web para Node.js

Express es un framework de aplicaciones web para Node.js  que facilita la creación de servidores y aplicaciones web. Proporciona una interfaz sencilla para manejar solicitudes y respuestas HTTP, lo que hace que la programación de servidores sea mucho más eficiente y organizada.

Estructura básica de Express:

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

app.get('/', (req, res) => {
  res.send('¡Hola desde Express!');
});

app.listen(3000, () => {
  console.log('Servidor escuchando en http://localhost:3000');
}); 

¿Para qué sirve?

1. Facilita la creación de servidores: Es ideal para construir aplicaciones web dinámicas o APIs REST.
2. Routing: Permite definir rutas para diferentes puntos de acceso (como /home, /api/usuarios).
3. Middlewares: Ofrece soporte para middlewares que gestionan solicitudes, respuestas y lógica personalizada.
4. Flexibilidad: Es altamente personalizable y se puede usar en proyectos pequeños o grandes.
5. Integración: Se combina fácilmente con otras bibliotecas y herramientas, como bases de datos (MongoDB, MySQL) y motores de plantillas (EJS, Pug).

 

  API básica de gestión de usuarios

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

// Middleware para analizar JSON en el cuerpo de las solicitudes
app.use(express.json());

// "Base de datos" simulada
const usuarios = [
  { id: 1, nombre: 'Milton', correo: 'milton@example.com' },
  { id: 2, nombre: 'Ana', correo: 'ana@example.com' }
];

// Ruta para obtener todos los usuarios
app.get('/usuarios', (req, res) => {
  res.json(usuarios);
});

// Ruta para obtener un usuario específico por ID
app.get('/usuarios/:id', (req, res) => {
  const usuario = usuarios.find(u => u.id === parseInt(req.params.id));
  if (!usuario) {
    return res.status(404).send('Usuario no encontrado');
  }
  res.json(usuario);
});

// Ruta para crear un nuevo usuario
app.post('/usuarios', (req, res) => {
  const { nombre, correo } = req.body;
  const nuevoUsuario = { id: usuarios.length + 1, nombre, correo };
  usuarios.push(nuevoUsuario);
  res.status(201).json(nuevoUsuario);
});

// Ruta para eliminar un usuario por ID
app.delete('/usuarios/:id', (req, res) => {
  const indice = usuarios.findIndex(u => u.id === parseInt(req.params.id));
  if (indice === -1) {
    return res.status(404).send('Usuario no encontrado');
  }
  usuarios.splice(indice, 1);
  res.send('Usuario eliminado');
});

// Servidor
const PORT = 3000;
app.listen(PORT, () => {
  console.log(`Servidor funcionando en el puerto ${PORT}`);
}); 

¿Qué hace este ejemplo?

1. Middleware para JSON: Configura el servidor para analizar datos JSON enviados en el cuerpo de las solicitudes.
2. Rutas dinámicas: Define rutas para listar usuarios, buscar usuarios por ID, crear nuevos usuarios y eliminar usuarios.
3. Simulación de base de datos: Utiliza un arreglo para almacenar los datos de usuarios temporalmente.
4. Respuestas HTTP: Maneja diferentes códigos de estado como 404 (no encontrado) o 201 (creado exitosamente).

Este código es un buen punto de partida para desarrollar aplicaciones más avanzadas, como una API conectada a una base de datos real.

 

API avanzada de gestión de usuarios

 API avanzada de gestión de usuarios utilizando Express.js, incluyendo características como validación, manejo de errores y conexión a una base de datos MongoDB. Esto puede servir como una base sólida para construir aplicaciones más complejas.

Proyecto/
├── controllers/
│   ├── usuarioController.js
├── models/
│   ├── usuarioModel.js
├── middlewares/
│   ├── errorHandler.js
│   ├── validarDatos.js
├── routes/
│   ├── usuarioRoutes.js
├── server.js

 

1- Modelo de datos: usuarioModel.js

Define el esquema y el modelo para los usuarios usando Mongoose.

const mongoose = require('mongoose');

const usuarioSchema = new mongoose.Schema({
  nombre: { type: String, required: true },
  correo: { type: String, required: true, unique: true },
  edad: { type: Number, required: true }
});

module.exports = mongoose.model('Usuario', usuarioSchema);

2- Controlador: usuarioController.js

Contiene la lógica para las operaciones de usuarios.

const Usuario = require('../models/usuarioModel');

exports.obtenerUsuarios = async (req, res, next) => {
  try {
    const usuarios = await Usuario.find();
    res.json(usuarios);
  } catch (error) {
    next(error);
  }
};

exports.crearUsuario = async (req, res, next) => {
  try {
    const nuevoUsuario = new Usuario(req.body);
    const usuarioGuardado = await nuevoUsuario.save();
    res.status(201).json(usuarioGuardado);
  } catch (error) {
    next(error);
  }
};

exports.eliminarUsuario = async (req, res, next) => {
  try {
    const usuarioEliminado = await Usuario.findByIdAndDelete(req.params.id);
    if (!usuarioEliminado) {
      return res.status(404).json({ mensaje: 'Usuario no encontrado' });
    }
    res.json({ mensaje: 'Usuario eliminado' });
  } catch (error) {
    next(error);
  }
};

3- Middleware para validación: validarDatos.js

Valida los datos de entrada.

exports.validarUsuario = (req, res, next) => {
  const { nombre, correo, edad } = req.body;
  if (!nombre || !correo || !edad) {
    return res.status(400).json({ error: 'Todos los campos son obligatorios: nombre, correo, edad' });
  }
  next();
};

 

4- Middleware para manejo de errores: errorHandler.js

Centraliza el manejo de errores.

exports.errorHandler = (err, req, res, next) => {
  console.error(err.message);
  res.status(500).json({ error: 'Ocurrió un error en el servidor' });
};

 

5- Rutas: usuarioRoutes.js

Define las rutas para los usuarios.

const express = require('express');
const { obtenerUsuarios, crearUsuario, eliminarUsuario } = require('../controllers/usuarioController');
const { validarUsuario } = require('../middlewares/validarDatos');
const router = express.Router();

router.get('/', obtenerUsuarios);
router.post('/crear', validarUsuario, crearUsuario);
router.delete('/:id', eliminarUsuario);

module.exports = router;

6- Servidor principal: server.js

Configura la aplicación y se conecta a MongoDB.

const express = require('express');
const mongoose = require('mongoose');
const usuarioRoutes = require('./routes/usuarioRoutes');
const { errorHandler } = require('./middlewares/errorHandler');

const app = express();

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

// Conectar a MongoDB
mongoose.connect('mongodb://localhost:27017/gestionUsuarios', { useNewUrlParser: true, useUnifiedTopology: true })
  .then(() => console.log('Conectado a MongoDB'))
  .catch(err => console.error('Error al conectar a MongoDB', err));

// Rutas
app.use('/usuarios', usuarioRoutes);

// Middleware para manejo de errores
app.use(errorHandler);

// Servidor
const PORT = 3000;
app.listen(PORT, () => {
  console.log(`Servidor funcionando en el puerto ${PORT}`);
});

 

 

Características de esta API

1. Base de datos MongoDB: Almacena usuarios con campos como nombre, correo y edad.
2. Middlewares: Incluyen validaciones personalizadas y un manejador de errores global.
3. Controladores: Encapsulan la lógica de negocio, haciéndola reutilizable y mantenible.
4. Rutas REST: Exponen puntos de acceso para obtener, crear y eliminar usuarios.
5. Escalabilidad: Estructura modular que facilita agregar nuevas funcionalidades.

Este ejemplo es perfecto para comenzar un proyecto avanzado.