Creación de Endpoints Seguros con JWT en NestJS

Clase 16 de 22 • 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

En la clase anterior vimos como puedes hacer para identificar un rol y de acuerdo a eso poder darle acceso a un endpoint, ahora te pongo el siguiente escenario:

¿Como crear un endpoint que retorne todas las órdenes relacionados con el usuario que tiene sesión?

Una solución válida a este problema es que puedes crear un endpoint que enviándole el ID de un usuario te retorne dichas órdenes, algo como esto:

http://localhost:3000/users/1/orders Este endpoint me retornaría todas las órdenes del usuario con ID 1, sin embargo puede ser algo peligroso, es decir, este endpoint solo debería estar disponible para los roles administrativos, pero no para los usuarios porque si conoces el ID de algún cliente podrías obtener la información de órdenes de compra de un usuario.

La solución más práctica para este caso es crear un endpoint de este tipo:

http://localhost:3000/profile/my-orders

Como ves en el endpoint anterior no estás colocando de forma explícita el ID de un usuario. ¿Entonces como sabe a qué usuario le pertenecen las órdenes? Sencillo, sí nuestro usuario ya tiene una sesión, esta información ya está en el JWT que se le otorgó a ese usuario al autentificarse en el sistema así con eso podemos inferirlo de acuerdo a la sesión

Ok, ok, cerebrito, suena bien pero, ¿y el código...? Vamos a iniciar con ello. Lo primero es que vamos a hacer es crear un nuevo controlador para todos las solicitudes que sean de este tipo. Lo vamos a crear con el nombre ProfileController.

nest g co users/controllers/profile --flat

Allí vamos a exponer un nuevo endpoint que va a recibir la solicitud y gracias al decorador de @UseGuards(JwtAuthGuard, RolesGuard) nos aseguramos que tenga un token válido, así que en ese método recogemos la información de usuario que tiene esa sesión así:

  @Roles(Role.CUSTOMER)
  @Get('my-orders')
  getOrders(@Req() req: Request) {
    const user = req.user as PayloadToken;
    return this.orderService.findOne(user.sub);
  }

Simplemente con decirle que dentro del método que queremos la información del Request podemos obtener la información del usuario que tiene sesión, luego simplemente obtenemos el ID y ya con eso podemos crear un método en nuestro servicio de órdenes que las retorne, algo así:

  ordersByCustomer(customerId: number) {
    return this.orderRepo.find({
      where: {
        customer: customerId,
      },
    });
  }

Este sería el código completo del nuevo controlador ProfileController:

import { Controller, Get, UseGuards, Req } from '@nestjs/common';
import { ApiTags } from '@nestjs/swagger';

import { Request } from 'express';

import { JwtAuthGuard } from '../../auth/guards/jwt-auth.guard';
import { RolesGuard } from '../../auth/guards/roles.guard';
import { Roles } from '../../auth/decorators/roles.decorator';
import { Role } from '../../auth/models/roles.model';
import { PayloadToken } from 'src/auth/models/token.model';
import { OrdersService } from '../services/orders.service';

@UseGuards(JwtAuthGuard, RolesGuard)
@ApiTags('profile')
@Controller('profile')
@Controller('profile')
export class ProfileController {
  constructor(private orderService: OrdersService) {}

  @Roles(Role.CUSTOMER)
  @Get('my-orders')
  getOrders(@Req() req: Request) {
    const user = req.user as PayloadToken;
    return this.orderService.ordersByCustomer(user.sub);
  }
}

Puedes ver toda esta solución en la rama 14.

Comentarios

Jesús Israel Santiago Gutiérrez

student•

A mi no me traía las ordenes del cliente, debido a que el JWT el sub viene firmado con el id del usuario y no del customer. Mi solución fue la siguiente: Inyecté el repositorio de usuario en el constructor de OrdersService:

 @InjectRepository(User) private userRepo: Repository<User>,

Luego modifiqué el método de la lectura de la siguiente manera:

async ordersByCustomer(userId: number) {
    const customerId = (await this.userRepo.findOne(userId,{relations: ["customer"]})).customer.id;
    return this.orderRepo.find({
      where: {
        customer: customerId,
      },
      relations: ['items', 'items.product'],
    });
  }

Y así ya me trae las ordenes de mi cliente y con sus respectivos productos por orden.

Espero les ayude en algo. Excelente curso!

Enmanuel Josue Sarmiento Benitez

student•

Gracias !

Andres Trujillo

student•

NiceQ

Carmelo Buelvas Comas

student•

Comparto el codigo para MongoDB

PayloadToken

export interface PayloadToken {
  role: string;
  sub: string;
}

AuthService

generateJWT(user: User) {
    const payload: PayloadToken = { role: user.role, sub: user._id };
    return {
      access_token: this.jwtService.sign(payload),
      user,
    };
  }

ProfileController

@Roles(Role.CUSTOMER)
  @Get('my-orders')
  getOrders(@Req() req: Request) {
    const user = req.user as PayloadToken;
    return this.orderService.ordersByUser(user.sub);
  }

OrdersService

async ordersByUser(customer: string) {
    return await this.orderModel.findOne({customer}).exec();
}

Nicolas Molina

teacher•

Hola, genial aporte aunque había un error en la lectura que ya está corregido gracias a tu aporte.

Realmente en OrdersService debería hacer uso de find para obtener todas las órdenes relacionadas con el usuario y no solo una

Italo Fernando Bejarano Gonzales

student•

¿Sería mala práctica agregar el customerId en el payload?

Andres Prieto

student•

David Bryan Arias Castro

student•

async ordersByCustomer(userId: number) {
    const customerId = (
      await this.userRepo.findOne({
        relations: ['customer'],
        where: { id: userId },
      })
    ).customer.id;

    return this.orderRepo.find({
      where: {
        **customer**: customerId,
      },
      relations: ['items', 'items.product'],
    });
  }

Tengo este error en el customer:

Type 'number' is not assignable to type 'boolean | FindOperator<any> | FindOptionsWhere<Customer> | FindOptionsWhere<Customer>[] | EqualOperator<Customer>'.

Juan Camilo Noreña López

student•

Hola mira lo puedes hacer asi:

async ordersByCustomer(userId: number) {
    const user = await this.userRepo.findOne({
      where: { id: userId },
      relations: ['customer'],
    });
    const customerId = user.customer.id;
    return await this.orderRepo.find({
      where: { customer: { id: customerId } },
    });
  }

Gabriel Rodriguez

student•

El método del servicio está mal y no retornará nunca nada. La solución es la siguiente

  ordersByCustomer(customerId: number) {
    return this.orderRepo.find( { customer: customerId } ); //👈🏻 acá está el problema
  }

Ya que el 'orderRepo' está tipado con el modelo de Order. Entonces hay que indicarle que filtre por alguno de estos parámetros. En nuestro caso queremos que traiga todas las órdenes del customer que haga la petición(recuerden que el id viene vía JWT)

@Schema()
export class Order extends Document{
  @Prop({type: Date})
  date: Date;

  @Prop({type: Types.ObjectId, ref: Customers.name, required: true})
  customer: Customers | Types.ObjectId;

  @Prop({type: [{type: Types.ObjectId, ref: Product.name}]})
  products: Types.Array<Product>;
}

Pablo Lionel Benitez

student•

Decorador:

// auth/current-user.decorator.ts
import {
  createParamDecorator,
  ExecutionContext,
  PreconditionFailedException,
} from '@nestjs/common';

export const CurrnetUser = createParamDecorator(
  (_: unknown, ctx: ExecutionContext) => {
    const request = ctx.switchToHttp().getRequest();
    const { user } = request;

    if (!user) {
      throw new PreconditionFailedException('User not authenticated.');
    }

    return user;
  },
);

Uso:

// user/profile.controller.ts

// ... agrega UseGuards(JwtAuthGuard)...

@UseGuards(JwtGuard, RolesGuard)
@Controller('profile')
export class ProfileController {
	// ... en el método de tu controlador, hacer: .. 
	@Get()
	myMethod(@CurrentUser() user: PayloadToken) {
		return this.myService.findOne(user.sub);
	}
}

Christian Guevara

student•

Para mongo:

Para realizar este ejercicio hay un error de logica, primero deben agregar el objeto de "Customer" como propiedad referenciada, es una relacion 1:1 asi que no hay problema.

// user.entity.ts

@Schema()
export class User extends Document {
  @Prop({ required: true })
  name: string;

  @Prop({ required: true, unique: true })
  email: string;

  @ExcludeProperty()
  @Prop({ required: true })
  password: string;

  @Prop({ required: true })
  role: string;

  @Prop({ type: Types.ObjectId, ref: Customer.name, required: true })
  customer: Customer | Types.ObjectId; // relacion 1:1 referenciada
}

La estructura del controlador no tiene errores asi que esta todo en orden, pero la consulta la debemos cambiar porque en si establecimos una relacio en el paso anterior hasta ahora:

// order.service.ts

async ordersByCustomer(userId: string) {
    
    /*Nos traemos el usuario debido a que es quien contiene la referencia del customer.*/
    const user = await (await this.userService.getUser(userId)).toJSON();

/*Hacemos la consulta en base al customer ID*/
    return await this.orderModel
// como el id es un objeto debemos transformarlo a un string para poder comparar, sino da error.
      .find({ customer: user.customer._id.toString() }) 
      .populate('products') // populamos la consulta
      .exec();
  }

Puede que tengan un error de tipado, esto es debido a que el sub de nuestro PayloadToken es de tipo number y los "Id" de mongo son ObjectId o Strings, asi que debemos cambiarlo tambien:

// token.model.ts

export interface PayloadToken {
  role: string;
  sub: string;
}

Espero que les halla funcionado.

Juan Camilo Noreña López

student•

De donde viene el @ExcludeProperty() ??

Joao Villamore

student•

Para realizar una consulta anidada es mejor utilizar:

return this.orderRepo.find({
      where: {
        customer: {
          id: customerId,
        },
      },
      relations: ['customer'],
    });
```En vez de realizar la consulta por separado, espero les sirva

import { Controller, Get, UseGuards, Req } from '@nestjs/common';
import { ApiTags } from '@nestjs/swagger';

import { Request } from 'express';

import { JwtAuthGuard } from '../../auth/guards/jwt-auth.guard';
import { RolesGuard } from '../../auth/guards/roles.guard';
import { Roles } from '../../auth/decorators/roles.decorator';
import { Role } from '../../auth/models/roles.model';
import { PayloadToken } from 'src/auth/models/token.model';
import { OrdersService } from '../services/orders.service';

@UseGuards(JwtAuthGuard, RolesGuard)
@ApiTags('profile')
@Controller('profile')
@Controller('profile')
export class ProfileController {
  constructor(private orderService: OrdersService) {}

  @Roles(Role.CUSTOMER)
  @Get('my-orders')
  getOrders(@Req() req: Request) {
    const user = req.user as PayloadToken;
    return this.orderService.ordersByCustomer(user.sub);
  }
}

async ordersByCustomer(userId: number) {
    const customerId = (await this.userRepo.findOne(userId,{relations: ["customer"]})).customer.id;
    return this.orderRepo.find({
      where: {
        customer: customerId,
      },
      relations: ['items', 'items.product'],
    });
  }

async ordersByCustomer(userId: number) {
    const customerId = (
      await this.userRepo.findOne({
        relations: ['customer'],
        where: { id: userId },
      })
    ).customer.id;

    return this.orderRepo.find({
      where: {
        **customer**: customerId,
      },
      relations: ['items', 'items.product'],
    });
  }

async ordersByCustomer(userId: number) {
    const user = await this.userRepo.findOne({
      where: { id: userId },
      relations: ['customer'],
    });
    const customerId = user.customer.id;
    return await this.orderRepo.find({
      where: { customer: { id: customerId } },
    });
  }

@Schema()
export class Order extends Document{
  @Prop({type: Date})
  date: Date;

  @Prop({type: Types.ObjectId, ref: Customers.name, required: true})
  customer: Customers | Types.ObjectId;

  @Prop({type: [{type: Types.ObjectId, ref: Product.name}]})
  products: Types.Array<Product>;
}

// auth/current-user.decorator.ts
import {
  createParamDecorator,
  ExecutionContext,
  PreconditionFailedException,
} from '@nestjs/common';

export const CurrnetUser = createParamDecorator(
  (_: unknown, ctx: ExecutionContext) => {
    const request = ctx.switchToHttp().getRequest();
    const { user } = request;

    if (!user) {
      throw new PreconditionFailedException('User not authenticated.');
    }

    return user;
  },
);

// user/profile.controller.ts

// ... agrega UseGuards(JwtAuthGuard)...

@UseGuards(JwtGuard, RolesGuard)
@Controller('profile')
export class ProfileController {
	// ... en el método de tu controlador, hacer: .. 
	@Get()
	myMethod(@CurrentUser() user: PayloadToken) {
		return this.myService.findOne(user.sub);
	}
}

// user.entity.ts

@Schema()
export class User extends Document {
  @Prop({ required: true })
  name: string;

  @Prop({ required: true, unique: true })
  email: string;

  @ExcludeProperty()
  @Prop({ required: true })
  password: string;

  @Prop({ required: true })
  role: string;

  @Prop({ type: Types.ObjectId, ref: Customer.name, required: true })
  customer: Customer | Types.ObjectId; // relacion 1:1 referenciada
}

// order.service.ts

async ordersByCustomer(userId: string) {
    
    /*Nos traemos el usuario debido a que es quien contiene la referencia del customer.*/
    const user = await (await this.userService.getUser(userId)).toJSON();

/*Hacemos la consulta en base al customer ID*/
    return await this.orderModel
// como el id es un objeto debemos transformarlo a un string para poder comparar, sino da error.
      .find({ customer: user.customer._id.toString() }) 
      .populate('products') // populamos la consulta
      .exec();
  }

return this.orderRepo.find({
      where: {
        customer: {
          id: customerId,
        },
      },
      relations: ['customer'],
    });
```En vez de realizar la consulta por separado, espero les sirva

Creación de Endpoints Seguros con JWT en NestJS

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