Autenticación de Usuarios con JWT en GraphQL y Node.js

Contenido del curso

Introducción

Fundamentos de GraphQL

Tipado en GraphQL

GraphQL en la Tienda con Express.js

Autenticación con GraphQL y JSON Web Tokens

Bonus

22
Anidamiento dinámico en GraphQL: optimización de consultas SQL
18:07 min

Conclusiones

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0018:01

Autenticación de Usuarios con JWT en GraphQL y Node.js

Curso de GraphQL con Node.js

Clase 17 de 24

Clase 17 / 24

Recursos

¿Cómo implementar autenticación utilizando JWT en GraphQL?

GraphQL se ha convertido en la herramienta de gestión de API preferida por muchos desarrolladores debido a su flexibilidad y eficiencia. Cuando se trata de seguridad, una práctica común es el uso de JSON Web Tokens (JWT) para autenticación. Aquí exploraremos cómo implementar un sistema de autenticación con JWT en un entorno GraphQL, garantizando así un acceso seguro a las rutas y funcionalidades de nuestra API.

¿Cómo migrar la autenticación de REST API a GraphQL?

En una arquitectura tradicional de REST API, la autenticación se maneja mediante solicitudes a un endpoint específico, enviando usuario y contraseña, y recibiendo a cambio un token de acceso. Esta lógica se puede trasladar a GraphQL mediante la definición de mutaciones y el uso de resolvers.

Definición del esquema en GraphQL:

En GraphQL, el primer paso es crear una mutación específica para manejar el "login". No se requiere un input complejo si simplemente recibimos email y contraseña como parámetros. El esquema debe crear un "out response" con el token de acceso y la información del usuario.
```
type Mutation {
  login(email: String!, password: String!): AuthResponse
}

type AuthResponse {
  accessToken: String
  user: User
}

type User {
  id: ID!
  email: String!
  role: String
  createdAt: String
}
```
Creación del Resolver para el Login:

El resolver es el encargado de procesar las credenciales y generar el token de acceso. Inicialmente, se define una función con los argumentos necesarios y un retorno nulo.
```
const login = async (_, { email, password }) => {
  // Lógica para autenticar al usuario y generar token
  return null; // Se cambia posteriormente cuando se implemente el JWT
}
```

¿Cómo utilizar Passport para la autenticación?

Utilizar la biblioteca passport y su variante graphql-passport facilita la implementación de estrategias de autenticación con GraphQL de manera similar a REST.

Instalación y configuración de GraphQL Passport:

Primero, instalamos la biblioteca necesaria:
```
npm install graphql-passport
```

Definición de estrategia en GraphQL:

Creamos una nueva estrategia que se ajuste a las especificaciones de GraphQL.

const { GraphQLLocalStrategy } = require('graphql-passport');

const localGraphQLStrategy = new GraphQLLocalStrategy((email, password, done) => {
  // Lógica de autenticación
  done(null, user);
});

Configuración del servidor GraphQL:

Es fundamental adicionar un contexto que permita el uso de Passport en el manejo de peticiones dentro de GraphQL.

const { buildContext } = require('graphql-passport');
const { ApolloServer } = require('apollo-server');

const server = new ApolloServer({
  schema,
  context: ({ req, res }) => buildContext({ req, res }),
});

¿Cómo validar credenciales y generar tokens?

Uso del servicio de autenticación:

Implementar un servicio de autenticación que se encargue de verificar las credenciales y generar el JWT es el siguiente paso crítico.
```
const authenticateUser = async (email, password) => {
  // Lógica para verificar credenciales y generar token
  return { user, token };
};
```
Manejo de errores y respuestas desde el Resolver:

El manejo adecuado de errores permite responder correctamente a intentos de login fallidos, devolviendo códigos de error significativos.
```
if (!user) {
  throw new AuthenticationError('Invalid credentials');
}
```

Finalmente, al migrar la autenticación de un entorno REST a GraphQL, mantenemos la seguridad y control sobre las rutas de acceso a través del uso estratégico de JWT y Passport. El resultado es una API más segura y eficiente que facilita el control de sesiones y permisos en la aplicación.

¿Cómo se realiza el testing del sistema de autenticación?

A través del "Playground" de GraphQL, podemos realizar pruebas de las mutaciones de login enviando datos específicos de usuario y verificando las respuestas en las distintas situaciones: credenciales correctas, incorrectas y manejos esperados de token.

Geovanny Sneyder Paez Pabon

Hace 4 años

Resumen de esta clase acomodamos la consulta con una mutacion

type AuthResponse{
  access_token: String!
  user:User!
 }
 type User{
  id:ID!
  email:String!
  role:String!
  createdAt:String!
 }
 type Mutation {
  createPerson(name: String! lastname:String! phone:Int): Person!
  createProduct(dto:CreateProdutDto!):Product
  updateProduct(id:ID! dto:UpdateProduct!):Product
  deleteProduct(id:ID!):String
  # login auth
  login(email:String! password:String!):AuthResponse
 }

creamos el resolver y lo injectamos en nuestros resolvers

const login = (root, {email,password})=>{
  return null
}

module.exports ={login}

resolveerss.js

const { login } = require("./auth/auth.resolver")
const { allCategories, categoryById } = require("./categories.resolver")
const { product, products ,createProduct,deleteProduct,updateProduct} = require("./product.resolver")
const { getPersons , findPerson, createPerson} = require("./resolver.person")

const resolvers= {
  Query:{
    saludo: ()=> 'hola mundillo de internet',
    persons:getPersons,
    findPerson,
    allCategories,
    categoryById,
    product,
    products
  },
  Mutation:{
    createPerson,
    createProduct,
    deleteProduct,
    updateProduct,
    login //login
  }
}

module.exports = resolvers

instalamos la libreria graphql-passport

npm i  graphql-passport

creamos nuestra estrategia de graphql y la implementamos en nuestras estategias

gql-local.strategy.js

const {GraphQLLocalStrategy } = require('graphql-passport')
const AuthService = require('../../../services/auth.service')
const service = new AuthService();

const GQLLocalStrategy = new GraphQLLocalStrategy(async(email,password,done)=>{
  try {
    const user = await service.getUser(email,password);
    done(null,user)
  } catch (error) {
    done(error, false)
  }
})

module.exports = GQLLocalStrategy

añadimos la estrategy

const passport = require('passport');

const LocalStrategy = require('./strategies/local.strategy');
const JwtStrategy = require('./strategies/jwt.strategy');
const GQLLocalStrategy = require('./strategies/local-gql.strategy');

passport.use(LocalStrategy);
passport.use(JwtStrategy);
passport.use(GQLLocalStrategy)

le envolvemos nuestra estrategy al momento de motar nuestro server de graphql

const {ApolloServer}= require('apollo-server-express');
const {ApolloServerPluginLandingPageLocalDefault} = require('apollo-server-core');
const {loadFiles} = require('@graphql-tools/load-files')
const {buildContext}= require('graphql-passport')
const resolvers = require('./resolvers')
// el ! significa un campo obligatorio

const  useGraphql= async (app)=>{
  const server = new ApolloServer({
    typeDefs: await loadFiles('./src/**/*.graphql'),
    resolvers,
    context:({req,res})=> buildContext({req,res}), //envolvemos context de graphql  para passport
    plugins: [ApolloServerPluginLandingPageLocalDefault]
  });
  await server.start();
  server.applyMiddleware({app})
}

module.exports = useGraphql;

y por ultimo en el resolver del login hacemos la autenticacion

const AuthService = require("../../../services/auth.service")
const service = new AuthService();// servicio de autenticacion
const login = async(root, {email,password},context)=>{
// recibimos el context de graphql-strategy o graphql-passport 
  const {user}= await context.authenticate('graphql-local',{email,password})
  console.log('service.signToken(user): ', service.signToken(user));
  return service.signToken(user) //utilizamos el servicio de auth para crear nuestro jwt
	// y enviar la info del login 
}

module.exports ={login}

Introducción

Integración de GraphQL con Node.js y Express

Integración de GradQL en API REST existente

Organización del Código para Implementar GraphQL

Fundamentos de GraphQL

Creación de tu primer servidor GradQL con Apollo Server Express

Consultar GraphQL desde Insomnia y Postman

Tipado en GraphQL

Sistema de Tipado en GradQL: Queries y Mutations

Tipos escalares de GraphQL y validación automática

Validación de Nullables y Listas en GradQL

Creación y Manejo de Tipos de Datos en GraphQL

Integración de Archivos GradQL y Live Reloading en Node.js

GraphQL en la Tienda con Express.js

Cómo separar resolvers GraphQL por entidad

Conexión de Base de Datos y Consultas en GraphQL con SQLite

Creación de productos con mutations e inputs en GraphQL

Uso de Variables y Alias en GradQL para Optimizar Consultas

Actualización y Eliminación de Productos con GraphQL

Anidamiento de Entidades con GradQL en APIs

Autenticación con GraphQL y JSON Web Tokens

Autenticación de Usuarios con JWT en GraphQL y Node.js

Creación de Mutación para Categorías con Validación de Roles

Autenticación de JSON Web Tokens en GraphQL con Passport

Validación de Roles y Sesiones con GradQL y Express

Validación de Datos en GradQL con Scalars Personalizados

Bonus

Anidamiento dinámico en GraphQL: optimización de consultas SQL

Conclusiones

Comparativa entre WPI y GradQL: Ventajas y Desventajas

Creación de Servidores GradQL con Node.js

Autenticación de Usuarios con JWT en GraphQL y Node.js