Autorização e Autenticação em TypeScript

Autorização e Autenticação em TypeScript: da teoria à prática

No desenvolvimento de aplicações web modernas em TypeScript, a segurança dos dados dos usuários é uma prioridade. Dois processos-chave — autenticação (confirmação de identidade) e autorização (verificação de permissões de acesso) — formam a base de qualquer sistema protegido. Neste guia, abordaremos o ciclo completo de implementação de autenticação e autorização em TypeScript usando bibliotecas populares e melhores práticas.

1. Conceitos básicos e diferenças

Autenticação — processo de verificar se o usuário é quem diz ser (login + senha, biometria, OAuth).
Autorização — processo de determinar quais recursos e ações estão disponíveis para um usuário autenticado (funções, permissões de acesso).

Por exemplo: o usuário digitou a senha correta (autenticação), mas não tem permissão para excluir postagens de outros usuários (autorização).

2. Ferramentas e bibliotecas necessárias

Para a implementação, usaremos:

bcrypt — para hash de senhas
jsonwebtoken (JWT) — para criação e verificação de tokens
express + @types/express — parte do servidor
zod — validação de dados de entrada

3. Registro de usuário (autenticação)

No registro, a senha nunca é armazenada em texto puro. Usamos bcrypt para criar o hash:

import bcrypt from 'bcrypt';import { z } from 'zod';

const registerSchema = z.object({    email: z.string().email(),    password: z.string().min(8)});

async function registerUser(email: string, password: string) {    const validated = registerSchema.parse({ email, password });    const saltRounds = 10;    const hashedPassword = await bcrypt.hash(validated.password, saltRounds);        // Salvar email + hashedPassword no banco de dados    // await db.user.create({ data: { email, password: hashedPassword } });    return { success: true };}

4. Login e emissão de JWT

Após verificar a senha com sucesso, geramos um token de acesso:

import jwt from 'jsonwebtoken';

const JWT_SECRET = process.env.JWT_SECRET!; // obrigatório no .env

async function loginUser(email: string, password: string) {    // 1. Encontrar usuário no banco pelo email    // const user = await db.user.findUnique({ where: { email } });    // if (!user) throw new Error('User not found');        // 2. Comparar senha    const isMatch = await bcrypt.compare(password, user.password);    if (!isMatch) throw new Error('Invalid password');        // 3. Criar JWT    const token = jwt.sign(        { userId: user.id, role: user.role },        JWT_SECRET,        { expiresIn: '1h' }    );        return { token, user: { id: user.id, email: user.email } };}

5. Middleware para verificação de JWT (autenticação)

Criamos um middleware que verificará o token em cada requisição protegida:

import { Request, Response, NextFunction } from 'express';

interface AuthRequest extends Request {    user?: { userId: string; role: string };}

export function authMiddleware(req: AuthRequest, res: Response, next: NextFunction) {    const authHeader = req.headers.authorization;    if (!authHeader?.startsWith('Bearer ')) {        return res.status(401).json({ error: 'No token provided' });    }        const token = authHeader.split(' ')[1];    try {        const decoded = jwt.verify(token, JWT_SECRET) as { userId: string; role: string };        req.user = decoded;        next();    } catch (err) {        return res.status(403).json({ error: 'Invalid or expired token' });    }}