Tutorial Nest: Login y registro

El login y registro son procesos esenciales para asegurar que los usuarios tengan acceso adecuado a recursos y datos, así como para proteger la aplicación contra el acceso no autorizado.

Configuración inicial

Antes de sumergirse en la lógica de autenticación, se necesita una nueva aplicación NestJS e instalar las siguientes dependencias:

npm install @nestjs/jwt @nestjs/passport passport passport-jwt bcrypt

Módulo de autenticación

Se crea un módulo para manejar la autenticación.

nest generate module auth

Dentro de este módulo, se necesita:

• Un servicio para manejar lógica de autenticación.
• Un controlador para manejar las peticiones HTTP.
• Estrategias Passport para manejar JWT (JSON Web Tokens).

Implementando el registro

Antes de implementar el registro, se necesita un modelo de usuario y un servicio para manejar las operaciones con la base de datos.

Modelo de usuario

export class Usuario {
  id: number;
  email: string;
  password: string;
}

Servicio de autenticación

El servicio de autenticación manejará la lógica de registro y login.

import { Injectable } from '@nestjs/common';
import { UsuariosService } from '../usuarios/usuarios.service';
import * as bcrypt from 'bcrypt';

@Injectable()
export class AuthService {
    constructor(private usuariosService: UsuariosService) {}

    async registro(data: any): Promise<any> {
        const hashedPassword = await bcrypt.hash(data.password, 10);
        const user = await this.usuariosService.create({
            ...data,
            password: hashedPassword,
        });

        return user;
    }
}

En este ejemplo, el servicio AuthService recibe los datos del usuario, cifra la contraseña y luego llama al UsuariosService para crear un nuevo usuario en la base de datos.

Se utiliza el paquete bcrypt para cifrar la contraseña antes de guardarla en la base de datos.

Registro en el controlador

El controlador maneja las solicitudes HTTP relacionadas con el registro.

import { Controller, Post, Body } from '@nestjs/common';
import { AuthService } from './auth.service';

@Controller('auth')
export class AuthController {
    constructor(private authService: AuthService) {}

    @Post('registro')
    registro(@Body() data: any) {
        return this.authService.registro(data);
    }
}

En este ejemplo, el método registro del controlador llama al método registro del servicio AuthService, pasándole los datos del usuario extraídos del cuerpo de la solicitud HTTP. Esto inicia el proceso de registro de un nuevo usuario en la aplicación.

Implementando el login

Para el login, es común usar JWT (JSON Web Tokens).

Un JWT es un token que se envía con cada solicitud para verificar la identidad del usuario.

Estrategia JWT

Una "estrategia" es una forma de manejar la autenticación. En este caso, se usará JWT.

//jwt.strategy.ts
import { Injectable, UnauthorizedException } from '@nestjs/common';
import { PassportStrategy } from '@nestjs/passport';
import { Strategy, ExtractJwt } from 'passport-jwt';
import { UsuariosService } from '../usuarios/usuarios.service';

@Injectable()
export class JwtStrategy extends PassportStrategy(Strategy) {
  constructor(private readonly usuariosService: UsuariosService) {
    super({
      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(), 
      ignoreExpiration: false,
      secretOrKey: 'SECRET_KEY', // En la vida real, no se debe guardar directamente en el código
    });
  }

  async validate(payload: any) {
    const { email } = payload;
    const usuario = this.usuariosService.encontrarPorEmail(email);
    if (!usuario) {
      throw new UnauthorizedException();
    }
    return usuario;
  }
}

En este código se verifica la firma del token y se busca el usuario correspondiente en el servicio de usuarios antes de permitir el acceso a rutas protegidas.

Servicio y controlador de autenticación

Se necesita un servicio para manejar la creación del JWT y el controlador para el endpoint de login:

//auth.service.ts
@Injectable()
export class AuthService {
  constructor(private readonly usuariosService: UsuariosService) {}

  async login(email: string, password: string): Promise<string> {
    const usuario = this.usuariosService.encontrarPorEmail(email);
    if (usuario && usuario.password === password) {
      const payload = { email };
      return jwt.sign(payload, 'SECRET_KEY', { expiresIn: '1h' });
    } else {
      throw new UnauthorizedException();
    }
  }
}

// Controlador
@Controller('auth')
export class AuthController {
  constructor(
    private readonly authService: AuthService,
    private readonly usuariosService: UsuariosService
  ) {}

  @Post('login')
  async login(@Body('email') email: string, @Body('password') password: string): Promise<any> {
    return { access_token: await this.authService.login(email, password) };
  }
}

En este ejemplo, el método login del servicio AuthService recibe el email y la contraseña del usuario, verifica las credenciales y luego crea un JWT firmado con el email del usuario. Este JWT se devuelve al usuario firmado con una clave secreta(SECRET_KEY) y con una duración de 1 hora.

En el controlador, el método login llama al método login del servicio AuthService para autenticar al usuario. Si la autenticación es exitosa, se devuelve un objeto que contiene el token JWT(access_token) al usuario.