Control de Roles y Permisos con JSON Web Tokens en TypeScript

Curso de NestJS: Autenticación con Passport y JWT

Contenido del curso

Introducción

Protección con guardianes

Autenticación con Passport

Autenticación con JSON Web Tokens

Deployment

Próximos pasos

22
Implementación de Autenticación y Autorización en NestJS
00:41 min

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0023:08

Control de Roles y Permisos con JSON Web Tokens en TypeScript

Curso de NestJS: Autenticación con Passport y JWT

Clase 15 de 22

Clase 15 / 22

Recursos

¿Cómo controlar los roles en una aplicación?

En la gestión de aplicaciones, el control de roles es fundamental para garantizar la seguridad y la personalización de la experiencia del usuario. Aquí exploraremos cómo implementar un sistema de roles y permisos utilizando JSON Web Tokens (JWT) y decoradores en aplicaciones TypeScript. Este enfoque permite definir qué operaciones puede realizar un usuario dependiendo de su rol.

¿Cómo empezamos a definir roles?

Lo primero es definir claramente los roles en la aplicación. Para esto, utilizamos las capacidades de TypeScript, como los enumerators o "enums", los cuales son conjuntos de valores predefinidos.

// models/rules.models.ts
enum Role {
  Customer = 'customer',
  Admin = 'admin',
}

Con estos enums, podemos evitar errores comunes como mal escribir el rol y garantizar que solo los roles predefinidos sean utilizados.

¿Cómo se implementa un decorador para roles?

Después de definir los roles, podemos crear un decorador que nos permita asignar roles específicos a las rutas de nuestra aplicación. Esto se hace añadiendo metadata al endpoint.

// decorators/roles.decorator.ts
import { SetMetadata } from '@nestjs/common';
import { Role } from '../models/rules.models';

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

Mediante este decorador, podemos definir qué roles tienen acceso a cada endpoint de la siguiente manera:

import { Controller, Post, UseGuards } from '@nestjs/common';
import { JwtAuthGuard } from './guards/jwt-auth.guard';
import { RolesGuard } from './guards/roles.guard';
import { Roles } from './decorators/roles.decorator';
import { Role } from './models/rules.models';

@Controller('api')
@UseGuards(JwtAuthGuard, RolesGuard)
export class ApiController {
  @Post('create')
  @Roles(Role.Admin)
  create() {
    // lógica del endpoint
  }
}

¿Cómo funciona el guardián de roles?

El guardián actúa como un guardián de acceso, verificando si el usuario tiene los permisos adecuados para realizar una acción específica. Este proceso incluye verificar si el rol del usuario coincide con el permitido en el decorador.

Para obtener y verificar la metadata, utilizamos el reflección:

// guards/roles.guard.ts
import { CanActivate, ExecutionContext, Injectable } from '@nestjs/common';
import { Reflector } from '@nestjs/core';
import { Role } from '../models/rules.models';

@Injectable()
export class RolesGuard implements CanActivate {
  constructor(private reflector: Reflector) {}

  canActivate(context: ExecutionContext): boolean {
    const requiredRoles = this.reflector.getAllAndOverride<Role[]>(ROLES_KEY, [
      context.getHandler(),
      context.getClass(),
    ]);
    if (!requiredRoles) {
      return true;
    }
    const { user } = context.switchToHttp().getRequest();
    return requiredRoles.some((role) => user.role?.includes(role));
  }
}

¿Cómo se asegura el acceso adecuado en endpoints?

Aquí es donde las piezas se unen. Al definir nuestro decorador y guardián de roles, los configuramos en los controladores. Esto permite que solo los usuarios con el rol correcto accedan a determinados endpoints.

Por ejemplo, al utilizar Postman o Insomnia para probar el acceso, podrías realizar una solicitud para crear un producto. Si el usuario es un administrador, la operación se permite; de lo contrario, se deniega.

¿Qué pasa con los endpoints sin roles definidos?

Si hay endpoints que no requieren verificación de roles, simplemente establecemos una condición para dejarlos pasar si no hay metadata de roles:

canActivate(context: ExecutionContext): boolean {
  const requiredRoles = this.reflector.getAllAndOverride<Role[]>(ROLES_KEY, [
    context.getHandler(),
    context.getClass(),
  ]);
  if (!requiredRoles) {
    return true;
  }
  // Procedemos con la lógica de verificación de roles
}

El manejo de roles es clave en aplicaciones modernas para mantener la seguridad y personalización de usuario. Si tu aplicación maneja roles dinámicos, podrías ampliar esta lógica integrando consultas a una base de datos para roles y permisos. Siempre es genial ver cómo las diferentes piezas del código trabajan en conjunto para crear soluciones eficientes y robustas, así que sigue perfeccionando tus habilidades y explorando nuevas posibilidades en el mundo del desarrollo.

Andrés Esteban Rodríguez Jiménez

Hace 3 años

Control de roles en NestJS

Ya logramos proteger nuestros Enpoint con una autenticación de usuario, pero un usuario común de nuestra aplicación no puede tener los mismos permisos que tiene un usuario administrador, es por ende que tenemos que crear un control de roles en nuestra aplicación.

Para esto primero tenemos que definir cuales son los roles en nuestra aplicación, para esto vamos a ir a la carpeta de models y crearemos el siguiente modelo:

src/auth/models/roles.model.ts:

// vamos a crear un enum con dos roles
export enum Role {
  CUSTOMER = 'customer',
  ADMIN = 'admin',
}

Una vez creada esta estructura, vamos a crear un decorador propio que nos permita validar estos roles:

src/auth/decorators/roles.decorator.ts:

// importamos el inyectador de metadata
import { SetMetadata } from '@nestjs/common';

// nos traemos al modelo de role
import { Role } from '../models/roles.model';

// creamos una llave indicadora
export const ROLES_KEY = 'roles';

// creamos un decorador en el que recibiremos un arreglo de roles
export const Roles = (...roles: Role[]) => SetMetadata(ROLES_KEY, roles);

Bien, ahora podremos definir en los Endpoints que roles queremos que puedan acceder a los Endpoints, veamos como hacer esto en los controladores:

**src/products/controllers/product.controller.ts**:

// nos traemos al decorador
import { Roles } from 'src/auth/decorators/roles.decorator';
// nos traemos al modelo
import { Role } from 'src/auth/models/roles.model';

// ...

@UseGuards(JwtAuthGuard)
@ApiTags('products')
@Controller('products')
export class ProductsController {
  // ...

  // con este decorador indicamos que solo los administradores pueden crear un producto
  @Post()
  create(@Body() payload: CreateProductDto) {
    return this.productsService.create(payload);
  }
}

Esto solo en parte, porque aún no hemos programado la lógica para que esto funcione, solo estamos enviando la metadata al Endpoint, así que vamos a programar la lógica para que esto funcione:

Para esto vamos a crear un nuevo guardian en el que si el usuario Autenticado tiene el rol, le damos acceso, y si no tiene el rol, no le damos acceso:

Para esto vamos a nuestra terminal y ejecutamos el siguiente comando:

nest g gu auth/guards/roles

Ahora manejemos la lógica de este nuevo guardian:

import {
  CanActivate,
  ExecutionContext,
  Injectable,
  UnauthorizedException,
} from '@nestjs/common';
// importamos al reflector, qu es el que nos trae esta metadata
import { Reflector } from '@nestjs/core';
import { Observable } from 'rxjs';
// nos traemos a la key de los roles
import { ROLES_KEY } from '../decorators/roles.decorator';
// nos traemos los modelos de los roles
import { Role } from '../models/roles.model';
// nos traemos al modelo de autenticación de usuario
import { PayloadToken } from '../models/token.model';

@Injectable()
export class RolesGuard implements CanActivate {
  constructor(private reflector: Reflector) {}

  canActivate(
    context: ExecutionContext,
  ): boolean | Promise<boolean> | Observable<boolean> {
    // obtenemos los roles de la metadata, nos los dsrán como un arrar de roles
    const roles: Role[] = this.reflector.get(ROLES_KEY, context.getHandler());
    // preguntamos si en la metadata recibimos algún rol, si no hay roles
    if (!roles) {
      // lo dejamos pasar sin más
      return true;
    }
    // obtenemos el Request
    const request = context.switchToHttp().getRequest();
    // del request, quiero obtener al usuario
    const user = request.user as PayloadToken;
    // verificamos su el usuario autentificado tiene permisos para usar el Endpoint
    const isAuth = roles.some((role) => role === user.role);
    // si el usuario no tiene permisos para entrar
    if (!isAuth) {
      // retornamos un error de no autorizado
      throw new UnauthorizedException('Your role is not accepted >:(');
    }
    // tiene permisos lo dejamos pasar
    return isAuth;
  }
}

Ahora en nuestro controlador tenemos que utilizar al guardián:

**src/products/controllers/product.controller.ts**:

// importamos el nuevo guadian
import { RolesGuard } from 'src/auth/guards/roles.guard';

// lo usamos en el controlador
@UseGuards(..., RolesGuard)
@ApiTags('products')
@Controller('products')
export class ProductsController {
  // ...
}

Y listo, de esta forma ya estamos manejando roles en nuestra aplicación con Nest.js y tenemos una lógica de negocio firme :3.

Andres Trujillo

Hace 3 años

ty!

Comentarios (15)15 comentarios

Manuel Alejandro Blanco Lamas

Hace 5 años

Luis Abdel Rangel Castro

David Montoya Perez

Rony Porraz Vargas

Juan Esteban Galvis

Carlos Luis Marin

Cesar Augusto Guzman Garrido

Hace 4 años

Jessica Yurani Leonel Pinzón

yerson lasso

Jairo Campos Ruiz

Lorenzo Gómez

Diego Cumbe

Ricardo Lopez

Cristian Alejandro Perez Dejoy

Brian Guzman

Brian Jacobo

Claudio Anibal Morales Pérez

Guillermo Rodas Gómez

Jonathan Ardila

Irving Caamal

Introducción

Autenticación de Usuarios en APIs con Nest.js y JWT

Configuración de Autenticación en Proyectos Mongo y TimeORM

Implementación de Autentificación y Autorización en API Node.js

Protección con guardianes

Creación y Uso de Guardianes en NestJS para Autorización de Endpoints

Decoradores para Control de Acceso en Controladores NETJS

Gestión de Variables de Entorno en Aplicaciones Node.js

Autenticación con Passport

Hashing de Contraseñas en Bases de Datos con Node.js

Implementación de Hashing en Proyecto Mongo con Node.js

Autenticación con Passport.js en Nest.js: Estrategias Locales

Implementación de Controlador de Login con NestJS y Estrategia Local

Autenticación con JSON Web Tokens

Implementación de JSON Web Tokens en APIs para Autenticación Segura

Implementación de JWT en Módulo de Autenticación con Variables de Entorno

Estrategia y Guardia de Autenticación con JWT en NestJS

Extensión de Guardianes JWT en NestJS para Endpoints Públicos

Control de Roles y Permisos con JSON Web Tokens en TypeScript

Creación de Endpoints Seguros con JWT en NestJS

Deployment

Configuración y Despliegue de MongoDB Atlas en Heroku

Configuración de Variables de Entorno en Heroku para MongoDB

Configuración de PostgreSQL en Heroku para Node.js

Configuración de Conexiones a Base de Datos en Heroku y Entorno Local

Migraciones con TimeORM en Producción: Configuración y Ejecución

Próximos pasos

Implementación de Autenticación y Autorización en NestJS

Control de Roles y Permisos con JSON Web Tokens en TypeScript

Progreso del curso

Introducción

Protección con guardianes

Autenticación con Passport

Autenticación con JSON Web Tokens

Deployment

Próximos pasos

Recursos

Recursos