Configuración del server render

Clase 24 de 39 • Curso de Autenticación con Passport.js 2019

Contenido del curso

Aprender sobre autenticación y autorización

Conocer qué son los JSON Web Tokens

Entender cómo funcionan las cookies

Implementar autenticación en Express usando Passport.js

Entender qué es OAuth 2.0 y OpenID Connect

28
¿Qué es OAuth 2.0 y OpenID Connect?
04:25 min

Implementar autenticación con redes sociales

Asegurar tu aplicación de Express

Tomar examen

Resumen

En esta parte del curso vamos a explorar el proyecto de server side render, que trabajaremos en las siguientes clases.

Alex Abel Lerman

student•

No puedo avanzar hace horas y no se donde esta el problema la verdad. el codigo es exactamente el mismo que el del profesor

jwt.js

const passport = require('passport');
const { Strategy, ExtractJwt } = require('passport-jwt');
const boom = require('@hapi/boom');

const UsersService = require('../../../services/users');
const { config } = require('../../../config');

passport.use(
    new Strategy(
        {
            secretOrKey: config.authJwtToken,
            jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken()
        },
        async function(tokenPayload, cb) {
            const usersService = new UsersService();

            try {
                const user = await usersService.getUser({ email: tokenPayload.email });

                if (!user) {
                    return cb(boom.unauthorized(), false);
                }

                delete user.password;

                cb(null, { ...user, scopes: tokenPayload.scopes });
            } catch (error) {
                return cb(error);
            }
        }
    )
);

auth.js

const express = require('express');
const passport = require('passport');
const boom = require('@hapi/boom');
const jwt = require('jsonwebtoken');
const ApiKeysService = require('../services/apiKeys');
const UsersService = require('../services/users');
const { validationHandler } = require('../utils/middlewares/validationHandler');
const { createUserSchema } = require('../utils/schemas/userSchema');

const { config: authJwtSecret } = require('../config/index');
require('../utils/auth/strategies/basic');

// Basic Strategy
function authApi(app) {
  const router = express.Router();
  app.use('/api/auth', router);

  const apiKeysService = new ApiKeysService();
  const usersService = new UsersService();

  // On login
  router.post('/sign-in', async function (req, res, next) {
    const { apiKeyToken } = req.body;

    if (!apiKeyToken) {
      next(boom.unauthorized('Api token is required'));
    }

    passport.authenticate(
      'basic',
      function (error, user) {
        try {
          if (error || !user) {
            next(boom.unauthorized());
          }

          req.login(user, { session: false }, async function (err) {
            if (error) {
              next(err);
            }
            const apiKey = await apiKeysService.getApiKey({
              token: apiKeyToken,
            });

            if (!apiKeyToken) {
              next(boom.unauthorized());
            }
            const { _id: id, name, email } = user;
            const payload = {
              sub: id,
              name,
              email,
              scopes: apiKey.scopes,
            };
            const token = jwt.sign(payload, `${authJwtSecret}`, {
              expiresIn: '15m',
            });
            return res.status(200).json({
              token,
              user: { id, name, email },
            });
          });
        } catch (err) {
          next(err);
        }
      },
      () => console.log('Token obtained')
    )(req, res, next);
  });

  // On sign up
  router.post('/sign-up', validationHandler(createUserSchema), async function (
    req,
    res,
    next
  ) {
    const { body: user } = req;

    try {
      const createdUserId = await usersService.createUser({ user });
      return res.status(201).json({
        data: createdUserId,
        message: 'User created!',
      });
    } catch (err) {
      next(err);
    }
  });
}

module.exports = { authApi };

movies.js

const express = require('express');
const passport = require('passport');
const MoviesService = require('../services/movies');
const {
  movieIdSchema,
  createMovieSchema,
  updateMovieSchema,
} = require('../utils/schemas/movieSchema');
const { validationHandler } = require('../utils/middlewares/validationHandler');

// JWT Strategy to protect routes
require('../utils/auth/strategies/jwt');

const moviesApi = (app) => {
  const router = express.Router();
  app.use('/api/movies', router);

  // Instantiation of service
  const moviesService = new MoviesService();

  // Routing Section
  router.get(
    '/',
      passport.authenticate('jwt', { session: false }),
    async (req, res, next) => {
      const { tags } = req.query;
      try {
        const movies = await moviesService.getMovies({ tags });

        return res.status(200).json({
          data: movies,
          message: 'Movies listed!',
        });
      } catch (err) {
        next(err);
      }
    }
  );

  router.get(
    '/:movieId',
    passport.authenticate('jwt', { session: false }),
    validationHandler({ movieId: movieIdSchema }, 'params'),
    async (req, res, next) => {
      const { movieId } = req.params;
      try {
        const movies = await moviesService.getMovie({ movieId });
        return res.status(200).json({
          data: movies,
          message: 'Movie retrieved!',
        });
      } catch (err) {
        next(err);
      }
    }
  );

  router.post(
    '/',
    passport.authenticate('jwt', { session: false }),
    validationHandler(createMovieSchema),
    async (req, res, next) => {
      const { body: movie } = req;
      try {
        const createMovieId = await moviesService.createMovie({ movie });
        return res.status(201).json({
          data: createMovieId,
          message: 'Movies created!',
        });
      } catch (err) {
        next(err);
      }
    }
  );

  router.put(
    '/:movieId',
    passport.authenticate('jwt', { session: false }),
    validationHandler({ movieId: movieIdSchema }, 'params'),
    validationHandler(updateMovieSchema),
    async (req, res, next) => {
      const { movieId } = req.params;
      const { body: movie } = req;
      try {
        const updatedMovieId = await moviesService.updateMovie({
          movieId,
          movie,
        });
        return res.status(200).json({
          data: updatedMovieId,
          message: 'Movie updated!',
        });
      } catch (err) {
        next(err);
      }
    }
  );

  router.delete(
    '/:movieId',
    passport.authenticate('jwt', { session: false }),
    validationHandler({ movieId: movieIdSchema }, 'params'),
    async (req, res, next) => {
      const { movieId } = req.params;
      try {
        const deletedMovie = await moviesService.deleteMovie({ movieId });
        return res.status(200).json({
          data: deletedMovie,
          message: 'Movie deleted!',
        });
      } catch (err) {
        next(err);
      }
    }
  );
};

module.exports = { moviesApi };

Enrique Devars

student•

Hola ¿qué error te saca?

Alex Abel Lerman

student•

Me dice Unauthorized nada mas. Solo eso. Como si el token no concidiera en Postman pero intente de todo. Yo veo lo mismo que el profe en codigo

Miguel Segura

Jose Anibal Garcia Giraldo

Juanse Calviño

Luis Lazcano

Jair Celis

JuanFe Peralta

Team Platzi•

Israel Yance

Didier Zúñiga

Maria Elizabeth Minero Alvarenga

Wilson Fernando Antury Torres

José Alejandro Muñoz Ruiz

David Alberto

Naldo Duran

Juan Sebastian Tello Quinteros

Carlos Alfonso Garcia Rivera

Nicolas Esteban Manograsso

Karen Paola Diaz Duarte

Configuración del server render

Aprender sobre autenticación y autorización

Lo que aprenderás sobre Passport.js

Stack de seguridad moderno

¿Qué es la autenticación y la autorización ?

Introducción a las sesiones

Conocer qué son los JSON Web Tokens

Anatomía de un JWT

Autenticación tradicional vs JWT

Firmando y Verificando nuestro JWT

Server-side vs Client-side sessions

Buenas prácticas con JWT

Entender cómo funcionan las cookies

¿Qué son las cookies y cómo implementar el manejo de sesión?

Cookies vs Session Storage vs Local Storage

Implementar autenticación en Express usando Passport.js

Arquitectura del proyecto Platzi Video

Agregando la colección de usuarios

Agregando la colección de películas de usuario

Implementando el POST y DELETE de las películas de usuario

Cómo conectarnos a la base de datos

Configuración de Passport.js

Implementación de BasicStrategy con Passport.js

Implementación de Strategy y ExtractJwt con Passport.js

Implementación de nuestro Sign-in

Implementación de nuestro Sign-up

Protegiendo nuestras rutas con Passport.js

Middleware para el manejo de scopes