Introducción a Passport y Autenticación con Google en Node.js

Contexto

• Se introduce passport, un middleware para Node.js simplificado y modular que facilita la autenticación.
• Se exploran algunas dependencias adicionales necesarias para la autenticación con Google usando OAuth 2.0.
• Se menciona la importancia de usar paquetes populares para la autenticación en lugar de soluciones caseras.

¿Qué es Passport?

• Middleware para Node.js que soporta diferentes estrategias de autenticación (Facebook, Twitter, Google, etc).
• Se pueden integrar más de 500 estrategias diferentes.
• Página web: PassportJS

Instalación y Configuración Inicial

1. Crear un nuevo proyecto en Node.js y configurar el entorno:

   npm init -y
   npm install express debug dotenv mongodb nodemon
   

2. Lun guardar configuraciones en .env.
3. Crear el archivo index.js para configurar el servidor Express básico.

Instalación de Paquetes Específicos de Passport

1. Instalación de Passport y estrategias de Google:

   npm install passport passport-google-oauth20 express-session
   

2. Importación e inicialización en index.js:

   import passport from 'passport';
   import { Strategy as GoogleStrategy } from 'passport-google-oauth20';
   import session from 'express-session';
   

Configuración de Estrategias en Passport

1. Configurar la estrategia de Google en Passport:

   passport.use(new GoogleStrategy({
     clientID: process.env.GOOGLE_CLIENT_ID,
     clientSecret: process.env.GOOGLE_CLIENT_SECRET,
     callbackURL: 'http://localhost:3000/auth/google/callback'
   }, (accessToken, refreshToken, profile, cb) => {
     return cb(null, profile);
   }));
   

2. Serializar y deserializar el usuario:

   passport.serializeUser((user, cb) => {
     cb(null, user);
   });
   passport.deserializeUser((obj, cb) => {
     cb(null, obj);
   });
   

Configuración de Middlewares de Sesión

1. Configurar express-session en el servidor:

   app.use(session({
     secret: process.env.SESSION_SECRET,
     resave: true,
     saveUninitialized: true,
     cookie: { maxAge: 3600000 } // 1 hora
   }));
   

2. Inicializar Passport y gestión de sesiones:

   app.use(passport.initialize());
   app.use(passport.session());
   

Rutas de Autenticación

1. Ruta para iniciar la autenticación con Google:

   app.get('/auth/google',
     passport.authenticate('google', { scope: ['profile'] })
   );
   

2. Ruta para manejar la callback de Google:

   app.get('/auth/google/callback',
     passport.authenticate('google', { failureRedirect: '/' }),
     (req, res) => {
       res.redirect('/profile');
     }
   );
   

3. Rutas adicionales para perfil y logout:

   app.get('/profile', (req, res) => {
     if (req.isAuthenticated()) {
       res.send('Logged in');
     } else {
       res.redirect('/');
     }
   });
   
   app.get('/logout', (req, res) => {
     req.logout((err) => {
       if (err) { return next(err); }
       res.redirect('/');
     });
   });
   

Administración de Usuarios

1. Creación de funciones para manejar usuarios en la base de datos (MongoDB).

   const createUser = async (profile) => {
     // Lógica para guardar usuario en la base de datos
   };
   
   const getUserById = async (id) => {
     // Lógica para obtener usuario por ID
   };
   

2. Guardar usuario autenticado a la base de datos:

   app.get('/auth/google/callback',
     passport.authenticate('google', { failureRedirect: '/' }),
     async (req, res) => {
       const user = await getUserById(req.user.id);
       if (!user) {
         await createUser(req.user);
       }
       res.redirect('/profile');
     }
   );
   

Beneficios y Consideraciones

• Ventajas: Delegar la autenticación a terceros mejora la seguridad y reduce riesgos.
• Desventajas: Limitación de los datos obtenidos del usuario.

Conclusión

• Se logra la autenticación con Google usando Passport en Node.js con un proyecto básico pero funcional.
• Hay espacio para expandir la solución, como guardar más datos del usuario en la base de datos.