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

¿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.

1. 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
   }
   

2. 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.

1. Instalación y configuración de GraphQL Passport:

   Primero, instalamos la biblioteca necesaria:

   npm install graphql-passport
   

2. 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);
   });
   

3. 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?

1. 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 };
   };
   

2. 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.