Autenticación en NestJS

La autenticación es uno de los pilares fundamentales en el desarrollo de aplicaciones web modernas. En el contexto de NestJS, este proceso se encarga de verificar la identidad de los usuarios que intentan acceder a nuestros recursos protegidos.

NestJS proporciona un ecosistema robusto para implementar diferentes estrategias de autenticación, desde las más tradicionales como sesiones y cookies, hasta las más modernas como JWT (JSON Web Tokens) y OAuth. El framework aprovecha su arquitectura modular y el sistema de decoradores para crear soluciones de autenticación elegantes y mantenibles.

Fundamentos de la autenticación

El proceso de autenticación en aplicaciones web sigue un patrón bien definido: el usuario proporciona sus credenciales (generalmente usuario y contraseña), el servidor las valida contra una fuente de datos confiable, y si son correctas, genera algún tipo de token o sesión que identifica al usuario en futuras peticiones.

En NestJS, este flujo se implementa típicamente mediante guards, que son clases especiales que determinan si una petición debe ser procesada o rechazada. Los guards actúan como middleware especializado que se ejecuta antes de que la petición llegue al controlador.

import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common';
import { Observable } from 'rxjs';

@Injectable()
export class AuthGuard implements CanActivate {
  canActivate(
    context: ExecutionContext,
  ): boolean | Promise<boolean> | Observable<boolean> {
    const request = context.switchToHttp().getRequest();
    return this.validateRequest(request);
  }

  private validateRequest(request: any): boolean {
    // Lógica de validación
    return true;
  }
}

Passport y estrategias de autenticación

NestJS integra de forma nativa con Passport, una biblioteca de autenticación para Node.js que soporta más de 500 estrategias diferentes. Esta integración permite implementar sistemas de autenticación complejos con relativamente poco código.

Las estrategias de Passport en NestJS se implementan como servicios que extienden la clase PassportStrategy. Cada estrategia define cómo se deben validar las credenciales y qué información del usuario debe extraerse:

import { Strategy } from 'passport-local';
import { PassportStrategy } from '@nestjs/passport';
import { Injectable, UnauthorizedException } from '@nestjs/common';
import { AuthService } from './auth.service';

@Injectable()
export class LocalStrategy extends PassportStrategy(Strategy) {
  constructor(private authService: AuthService) {
    super();
  }

  async validate(username: string, password: string): Promise<any> {
    const user = await this.authService.validateUser(username, password);
    if (!user) {
      throw new UnauthorizedException();
    }
    return user;
  }
}

Autenticación basada en JWT

Los JSON Web Tokens se han convertido en el estándar de facto para la autenticación en aplicaciones modernas. Un JWT es un token autocontenido que incluye información del usuario y puede ser verificado sin necesidad de consultar una base de datos.

La implementación de JWT en NestJS requiere la configuración de dos componentes principales: la generación del token durante el login y la validación del token en peticiones posteriores:

import { Injectable } from '@nestjs/common';
import { JwtService } from '@nestjs/jwt';

@Injectable()
export class AuthService {
  constructor(private jwtService: JwtService) {}

  async login(user: any) {
    const payload = { username: user.username, sub: user.userId };
    return {
      access_token: this.jwtService.sign(payload),
    };
  }

  async validateUser(username: string, password: string): Promise<any> {
    // Validación de credenciales contra la base de datos
    const user = await this.findUser(username);
    if (user && await this.comparePasswords(password, user.password)) {
      const { password, ...result } = user;
      return result;
    }
    return null;
  }
}

Protección de rutas

Una vez implementado el sistema de autenticación, el siguiente paso es proteger las rutas que requieren autenticación. NestJS permite aplicar guards tanto a nivel de controlador como a nivel de método individual:

import { Controller, Get, Post, UseGuards, Request } from '@nestjs/common';
import { JwtAuthGuard } from './jwt-auth.guard';
import { LocalAuthGuard } from './local-auth.guard';

@Controller('auth')
export class AuthController {
  @UseGuards(LocalAuthGuard)
  @Post('login')
  async login(@Request() req) {
    return this.authService.login(req.user);
  }

  @UseGuards(JwtAuthGuard)
  @Get('profile')
  getProfile(@Request() req) {
    return req.user;
  }
}

Manejo de roles y permisos

Los sistemas de autenticación modernos no solo verifican la identidad del usuario, sino que también gestionan sus permisos y roles. NestJS facilita esta implementación mediante decoradores personalizados y guards especializados.

El patrón más común es crear un decorador de roles que marque qué roles pueden acceder a cada endpoint:

import { SetMetadata } from '@nestjs/common';

export const Roles = (...roles: string[]) => SetMetadata('roles', roles);

// Uso en controladores
@Roles('admin', 'moderator')
@Get('admin-panel')
getAdminPanel() {
  return { message: 'Panel de administración' };
}

Configuración del módulo de autenticación

La configuración modular es una de las fortalezas de NestJS. El módulo de autenticación típicamente incluye la configuración de Passport, JWT y los servicios relacionados:

import { Module } from '@nestjs/common';
import { JwtModule } from '@nestjs/jwt';
import { PassportModule } from '@nestjs/passport';
import { AuthService } from './auth.service';
import { LocalStrategy } from './local.strategy';
import { JwtStrategy } from './jwt.strategy';

@Module({
  imports: [
    PassportModule,
    JwtModule.register({
      secret: process.env.JWT_SECRET,
      signOptions: { expiresIn: '1h' },
    }),
  ],
  providers: [AuthService, LocalStrategy, JwtStrategy],
  exports: [AuthService],
})
export class AuthModule {}

La gestión de secretos y configuración sensible debe manejarse mediante variables de entorno, nunca hardcodeada en el código fuente. NestJS proporciona el ConfigModule para gestionar esta configuración de forma segura y flexible.