How make Auth Nestjs

O que é Autenticação?
Autenticação (auth) é o processo de verificar a identidade de um usuário. Quando você faz login em um aplicativo, está provando que é quem diz ser. Isso normalmente é feito usando um nome de usuário e uma senha, mas pode também envolver métodos mais avançados, como autenticação multifator (MFA), tokens, biometria, etc.

Exemplo de Autenticação
Um exemplo simples de autenticação seria um site onde você insere seu nome de usuário e senha para acessar uma conta. Se os dados inseridos estiverem corretos, você é autenticado e pode acessar recursos restritos.

Implementação de Autenticação em um Aplicativo NestJS
Vou explicar como implementar a autenticação em um aplicativo NestJS usando JWT (JSON Web Tokens), que é um método popular para autenticação baseada em token.

Passo a Passo

1. Instalar Dependências Primeiro, instale as dependências necessárias:

bash
Copiar código
npm install @nestjs/jwt @nestjs/passport passport passport-jwt bcryptjs

1. Configurar Módulos e Serviços Crie um módulo de autenticação (auth.module.ts), um serviço de autenticação (auth.service.ts), um serviço JWT (jwt.strategy.ts) e um controlador (auth.controller.ts).

auth.module.ts
typescript
Copiar código
import { Module } from '@nestjs/common';
import { AuthService } from './auth.service';
import { UsersModule } from '../users/users.module';
import { PassportModule } from '@nestjs/passport';
import { JwtModule } from '@nestjs/jwt';
import { JwtStrategy } from './jwt.strategy';

@Module({
imports: [
UsersModule,
PassportModule,
JwtModule.register({
secret: 'secretKey', // deve ser movido para variáveis de ambiente
signOptions: { expiresIn: '60s' },
}),
],
providers: [AuthService, JwtStrategy],
exports: [AuthService],
})
export class AuthModule {}
auth.service.ts
typescript
Copiar código
import { Injectable } from '@nestjs/common';
import { UsersService } from '../users/users.service';
import { JwtService } from '@nestjs/jwt';
import * as bcrypt from 'bcryptjs';

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

async validateUser(username: string, pass: string): Promise {
const user = await this.usersService.findOne(username);
if (user && await bcrypt.compare(pass, user.password)) {
const { password, ...result } = user;
return result;
}
return null;
}

async login(user: any) {
const payload = { username: user.username, sub: user.userId };
return {
access_token: this.jwtService.sign(payload),
};
}
}
jwt.strategy.ts
typescript
Copiar código
import { Injectable } from '@nestjs/common';
import { PassportStrategy } from '@nestjs/passport';
import { ExtractJwt, Strategy } from 'passport-jwt';
import { AuthService } from './auth.service';

@Injectable()
export class JwtStrategy extends PassportStrategy(Strategy) {
constructor(private authService: AuthService) {
super({
jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
ignoreExpiration: false,
secretOrKey: 'secretKey', // deve ser movido para variáveis de ambiente
});
}

async validate(payload: any) {
return { userId: payload.sub, username: payload.username };
}
}
auth.controller.ts
typescript
Copiar código
import { Controller, Request, Post, UseGuards } from '@nestjs/common';
import { AuthService } from './auth.service';
import { LocalAuthGuard } from './local-auth.guard';

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

@UseGuards(LocalAuthGuard)
@post('login')
async login(@Request() req) {
return this.authService.login(req.user);
}
}
local-auth.guard.ts
typescript
Copiar código
import { Injectable, ExecutionContext } from '@nestjs/common';
import { AuthGuard } from '@nestjs/passport';

@Injectable()
export class LocalAuthGuard extends AuthGuard('local') {
async canActivate(context: ExecutionContext) {
const result = (await super.canActivate(context)) as boolean;
const request = context.switchToHttp().getRequest();
await super.logIn(request);
return result;
}
}
user.module.ts e user.service.ts (Exemplo básico)
typescript
Copiar código
// user.module.ts
import { Module } from '@nestjs/common';
import { UsersService } from './users.service';

@Module({
providers: [UsersService],
exports: [UsersService],
})
export class UsersModule {}

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

@Injectable()
export class UsersService {
private readonly users = [
{
userId: 1,
username: 'john',
password: 'changeme', // Em um app real, use hash bcryptjs
},
{
userId: 2,
username: 'maria',
password: 'guess', // Em um app real, use hash bcryptjs
},
];

async findOne(username: string): Promise {
return this.users.find(user => user.username === username);
}
}

1. Configurar Estrategia Local Crie a estratégia local (local.strategy.ts):

typescript
Copiar código
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 {
const user = await this.authService.validateUser(username, password);
if (!user) {
throw new UnauthorizedException();
}
return user;
}
}

1. Protegendo Rota com JWT No seu controlador, você pode proteger rotas usando JWT com o AuthGuard:

typescript
Copiar código
import { Controller, Get, UseGuards } from '@nestjs/common';
import { JwtAuthGuard } from './jwt-auth.guard';

@Controller('profile')
export class ProfileController {
@UseGuards(JwtAuthGuard)
@Get()
getProfile(@Request() req) {
return req.user;
}
}
jwt-auth.guard.ts
typescript
Copiar código
import { Injectable } from '@nestjs/common';
import { AuthGuard } from '@nestjs/passport';

@Injectable()
export class JwtAuthGuard extends AuthGuard('jwt') {}
Resumo
Instale as dependências necessárias.
Configure módulos e serviços de autenticação.
Crie estratégias para autenticação local e JWT.
Proteja suas rotas com guardas de autenticação.
Com esses passos, você terá um sistema básico de autenticação com JWT em um aplicativo NestJS. Para produção, lembre-se de mover as chaves secretas para variáveis de ambiente e usar métodos seguros para gerenciar senhas (como hashing com bcrypt).