¿Cómo integrar Passport.js con NestJS para la autenticación?

Para añadir autenticación robusta a nuestras aplicaciones NestJS, Passport.js es la opción ideal. Este módulo se integra fácilmente en la estructura de Nest.js, y ofrece varias estrategias de autenticación. La documentación oficial de Nest.js sugiere usar un módulo especializado de Passport para facilitar esta integración.

¿Qué librerías debemos instalar?

Para comenzar con la autenticación, necesitamos instalar varias librerías. Aquí está el paso a paso para integrar Passport.js en nuestro proyecto Nest.js:

1. Módulo de Passport para NestJS: Nos ofrece un puente entre Passport.js y la estructura de módulos de Nest.js.
2. Librería passport: Herramienta base para la autenticación.
3. Estrategia local para Passport: Para autenticar con usuario y contraseña.
4. Tipado para la estrategia local: Asegura que el tipado esté acorde con las funciones de autenticación.

En la terminal, ejecutamos la siguiente línea para instalar estas librerías:

fullscreen
$ npm install @nestjs/passport passport passport-local
$ npm install -D @types/passport-local

¿Cómo creamos un servicio de autenticación?

Con las librerías instaladas, creamos un servicio de autenticación. Usaremos el generador de Nest.js:

fullscreen
$ nest generate service auth

Ubicaremos nuestro servicio dentro del módulo adecuado y lo configuraremos para importar UserService. Este servicio se encargará de verificar a los usuarios basándose en su email:

fullscreen
import { Injectable } from '@nestjs/common';
import { UserService } from '../user/user.service';

@Injectable()
export class AuthService {
  constructor(private userService: UserService) {}

  async validateUser(email: string, password: string): Promise<any> {
    const user = await this.userService.findByEmail(email);
    if (user && user.password === password) {
      return user;
    }
    return null;
  }
}

¿Cómo verificamos credenciales de usuario?

Al crear el método validateUser, compararemos las credenciales proporcionadas con las almacenadas en la base de datos utilizando técnicas seguras. Aquí usamos bcrypt para comparar contraseñas cifradas:

fullscreen
import * as bcrypt from 'bcrypt';

async validateUser(email: string, password: string): Promise<any> {
  const user = await this.userService.findByEmail(email);
  if (user && await bcrypt.compare(password, user.password)) {
    return user;
  }
  return null;
}

¿Qué es una strategy en Passport.js?

Una strategy define cómo autenticar usuarios. Passport.js diversifica sus estrategias para diferentes placas, como Local, JWT, OAuth, entre otras.

¿Cómo creamos una estrategia local?

Ubicamos la strategy en una nueva carpeta strategies dentro de nuestro módulo:

fullscreen
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(email: string, password: string): Promise<any> {
    const user = await this.authService.validateUser(email, password);
    if (!user) {
      throw new UnauthorizedException();
    }
    return user;
  }
}

¿Cómo integramos el módulo de Passport en el módulo de autenticación?

El último paso es asegurar que el módulo de autenticación integre todas las piezas correctamente. Importamos el PassportModule y registramos la estrategia local:

fullscreen
import { Module } from '@nestjs/common';
import { PassportModule } from '@nestjs/passport';
import { AuthService } from './auth.service';
import { LocalStrategy } from './strategies/local.strategy';
import { UserModule } from '../user/user.module';

@Module({
  imports: [
    UserModule,
    PassportModule.register({ defaultStrategy: 'local' }),
  ],
  providers: [AuthService, LocalStrategy],
})
export class AuthModule {}

Con esto, hemos implementado la base para autenticación utilizando Passport.js y NestJS. Cada paso que sigues te acerca más a crear una aplicación segura. ¡No olvides explorar más estrategias para seguir mejorando!