Creación de Sistema de Usuarios en Express

Crear un sistema de usuarios es una parte fundamental al desarrollar una aplicación web, ya que permite gestionar la autenticación y autorización de los usuarios, así como también la personalización de la experiencia del usuario. En esta tercera parte de nuestra serie sobre la creación de una aplicación web utilizando Express, nos enfocaremos en cómo implementar un sistema de usuarios.

1. Configuración del Proyecto:

Antes de comenzar a trabajar en el sistema de usuarios, asegúrate de tener tu proyecto de Express configurado y funcionando correctamente. Puedes crear un nuevo proyecto o utilizar el proyecto que hemos estado desarrollando en las partes anteriores de esta serie.

2. Instalación de Dependencias:

Para implementar el sistema de usuarios, necesitaremos algunas dependencias adicionales. Puedes instalarlas utilizando npm:

bashCopy code
npm install bcryptjs jsonwebtoken

Estas dependencias nos ayudarán a gestionar la encriptación de contraseñas y la generación de tokens de autenticación.

3. Creación del Modelo de Usuario:

Comencemos creando un modelo de usuario para representar los datos de nuestros usuarios en la base de datos. Puedes usar cualquier base de datos que prefieras, como MongoDB con Mongoose, PostgreSQL con Sequelize, etc. Aquí un ejemplo usando Mongoose:

javascriptCopy code
// models/User.js

const mongoose = require('mongoose');

const userSchema = new mongoose.Schema({
  username: { type: String, required: true, unique: true },
  password: { type: String, required: true },
  email: { type: String, required: true, unique: true },
  // Otros campos que desees para el usuario
});

const User = mongoose.model('User', userSchema);

module.exports = User;

4. Creación de las Rutas de Autenticación:

Ahora, necesitamos definir las rutas que manejarán la autenticación de los usuarios, como el registro, inicio de sesión y cierre de sesión. Aquí tienes un ejemplo utilizando Express:

javascriptCopy code
// routes/auth.js

const express = require('express');
const router = express.Router();
const bcrypt = require('bcryptjs');
const jwt = require('jsonwebtoken');
const User = require('../models/User');

// Ruta para el registro de usuarios
router.post('/register', async (req, res) => {
  try {
    const { username, email, password } = req.body;
    // Verificar si el usuario ya existe
    let user = await User.findOne({ email });
    if (user) {
      return res.status(400).json({ message: 'El usuario ya existe' });
    }
    // Crear un nuevo usuario
    user = new User({ username, email, password });
    // Encriptar la contraseña
    const salt = await bcrypt.genSalt(10);
    user.password = await bcrypt.hash(password, salt);
    // Guardar el usuario en la base de datos
    await user.save();
    res.json({ message: 'Usuario registrado exitosamente' });
  } catch (error) {
    console.error(error.message);
    res.status(500).send('Error del servidor');
  }
});

// Ruta para el inicio de sesión de usuarios
router.post('/login', async (req, res) => {
  try {
    const { email, password } = req.body;
    // Verificar si el usuario existe
    const user = await User.findOne({ email });
    if (!user) {
      return res.status(400).json({ message: 'Credenciales inválidas' });
    }
    // Verificar la contraseña
    const isMatch = await bcrypt.compare(password, user.password);
    if (!isMatch) {
      return res.status(400).json({ message: 'Credenciales inválidas' });
    }
    // Generar y enviar el token de autenticación
    const payload = { user: { id: user.id } };
    jwt.sign(payload, 'secreto', { expiresIn: '1h' }, (error, token) => {
      if (error) throw error;
      res.json({ token });
    });
  } catch (error) {
    console.error(error.message);
    res.status(500).send('Error del servidor');
  }
});

module.exports = router;

5. Protección de Rutas:

Ahora que hemos configurado las rutas de autenticación, es importante proteger ciertas rutas de nuestra aplicación para que solo los usuarios autenticados puedan acceder a ellas. Podemos lograr esto creando un middleware de autenticación que verifique la validez del token de autenticación antes de permitir el acceso a una ruta protegida. Aquí está un ejemplo de cómo podríamos hacerlo:

javascriptCopy code
// middleware/auth.js

const jwt = require('jsonwebtoken');

module.exports = function(req, res, next) {
  // Obtener el token de la cabecera HTTP
  const token = req.header('x-auth-token');
  // Verificar si no hay token
  if (!token) {
    return res.status(401).json({ message: 'No hay token, autorización denegada' });
  }
  // Verificar el token
  try {
    const decoded = jwt.verify(token, 'secreto');
    req.user = decoded.user;
    next();
  } catch (error) {
    res.status(401).json({ message: 'Token no válido' });
  }
};

6. Protección de Rutas Específicas:

Ahora que tenemos nuestro middleware de autenticación, podemos usarlo para proteger rutas específicas en nuestras definiciones de ruta. Por ejemplo:

javascriptCopy code
// routes/protected.js

const express = require('express');
const router = express.Router();
const auth = require('../middleware/auth');

// Ruta protegida que requiere autenticación
router.get('/dashboard', auth, (req, res) => {
  // El usuario está autenticado, podemos acceder a req.user para obtener su información
  res.json({ message: 'Bienvenido a tu panel de control' });
});

module.exports = router;

7. Integración con la Aplicación Principal:

Finalmente, integra las rutas de autenticación y las rutas protegidas en tu aplicación principal de Express. Esto generalmente se hace montando las rutas en la aplicación principal:

javascriptCopy code
// app.js

const express = require('express');
const app = express();
const authRoutes = require('./routes/auth');
const protectedRoutes = require('./routes/protected');

// Middleware para permitir el análisis de JSON
app.use(express.json());

// Montar las rutas de autenticación
app.use('/api/auth', authRoutes);

// Montar las rutas protegidas
app.use('/api/protected', protectedRoutes);

// Iniciar el servidor
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => console.log(`Servidor iniciado en el puerto ${PORT}`));

Conclusión:

En esta tercera parte de nuestra serie sobre la creación de una aplicación web con Express, hemos cubierto cómo implementar un sistema de usuarios que incluye el registro, inicio de sesión y protección de rutas. Este sistema de usuarios proporciona una base sólida para construir aplicaciones web más complejas que requieren autenticación de usuarios. Recuerda siempre mantener la seguridad en mente al desarrollar sistemas de autenticación y autorización. ¡Espero que esta guía te haya sido útil en tu viaje de desarrollo web con Express!