Autorización y autenticación en TypeScript

Autorización y autenticación en TypeScript: de la teoría a la práctica

Al desarrollar aplicaciones web modernas en TypeScript, la seguridad de los datos de los usuarios es una prioridad. Dos procesos clave — autenticación (confirmación de identidad) y autorización (verificación de permisos de acceso) — forman la base de cualquier sistema protegido. En esta guía, analizaremos el ciclo completo de implementación de autenticación y autorización en TypeScript utilizando bibliotecas populares y mejores prácticas.

1. Conceptos básicos y diferencias

Autenticación — proceso de verificar si el usuario es quien dice ser (inicio de sesión + contraseña, biometría, OAuth).
Autorización — proceso de determinar qué recursos y acciones están disponibles para un usuario autenticado (roles, permisos de acceso).

Por ejemplo: el usuario ingresó una contraseña correcta (autenticación), pero tiene prohibido eliminar publicaciones de otros (autorización).

2. Herramientas y bibliotecas necesarias

Para la implementación utilizaremos:

bcrypt — para el hash de contraseñas
jsonwebtoken (JWT) — para crear y verificar tokens
express + @types/express — parte del servidor
zod — validación de datos de entrada

3. Registro de usuario (autenticación)

Al registrarse, la contraseña nunca se almacena en texto plano. Usamos bcrypt para crear un 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);        // Guardar email + hashedPassword en la base de datos    // await db.user.create({ data: { email, password: hashedPassword } });    return { success: true };}

4. Inicio de sesión y emisión de JWT

Después de verificar correctamente la contraseña, generamos un token de acceso:

import jwt from 'jsonwebtoken';

const JWT_SECRET = process.env.JWT_SECRET!; // obligatorio en .env

async function loginUser(email: string, password: string) {    // 1. Buscar usuario en la BD por email    // const user = await db.user.findUnique({ where: { email } });    // if (!user) throw new Error('User not found');        // 2. Comparar contraseña    const isMatch = await bcrypt.compare(password, user.password);    if (!isMatch) throw new Error('Invalid password');        // 3. Crear 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 verificar JWT (autenticación)

Creamos un middleware que verificará el token en cada solicitud 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' });    }}