Share
Sequelize es un ORM de Node.js basado en la promesa. Puede utilizarse con PostgreSQL, MySQL, MariaDB, SQLite y MSSQL. En este tutorial, implementaremos la autenticación para los usuarios de una aplicación web. Y utilizaremos Passport, el popular middleware de autenticación para Node, junto con Sequelize y MySQL para implementar el registro de usuarios y el inicio de sesión..
Asegúrese de tener instalado lo siguiente en su máquina:
Para este tutorial, usaremos Node.js junto con Express, así que seguimos adelante y comenzamos a instalar lo que necesitamos..
Crea un directorio para tu aplicación. Dentro de este directorio, ejecute esto desde su terminal o indicador de comando:
npm init
Esto inicializa el npm Dependency Manager. Esto presentará una serie de indicaciones que veremos rápidamente..
Las principales dependencias para este tutorial son:
Para instalarlos, desde su terminal o indicador de comando, ejecute el siguiente uno tras otro.
npm install express --save npm install sequelize --save npm install mysql --save npm install passport --save npm install passport-local --save npm install body-parser --save npm install express-session --save npm install bcrypt-nodejs --save npm install express-handlebars --save
Si estás usando Git para este proyecto:
En su carpeta de proyectos cree un archivo .gitignore.
Agrega esta línea al archivo .gitignore.
nodo_módulos
Ahora, creamos un archivo de servidor. Este será el archivo principal llamado cuando escriba lo siguiente:
npm start
Esto ejecuta la aplicación. También puede ejecutar la aplicación escribiendo node server.js.
nodo server.js
Luego, en nuestra carpeta de proyectos, creamos un nuevo archivo y nombramos este archivo server.js.
Dentro de server.js archivo, pegamos lo siguiente:
Accentsconagua
var express = require ('express'); var app = express (); app.get ('/', function (req, res) res.send ('Welcome to Passport with Sequelize');); app.listen (5000, function (err) if (! err) console.log ("El sitio está en vivo"); else console.log (err));La primera línea asigna el módulo express a una variable express. Luego inicializamos express y le damos un nombre a una variable: app.
Entonces hacemos la aplicación escuchar en el puerto 5000. Puede elegir cualquier número de puerto libre en su computadora.
A continuación, llamamos a la app.get () función de enrutamiento express para responder con "Bienvenido a Passport with Sequelize" cuando se realiza una solicitud GET a "/".
Para probar en su computadora, ejecute esto desde la carpeta de su proyecto:
nodo server.js
Si ve el texto "Bienvenido a Passport with Sequelize" cuando visita http: // localhost: 5000 / ¡entonces felicidades! De lo contrario, verifique que haya hecho todo exactamente como está escrito arriba.
A continuación, importamos algunos módulos que necesitamos, como el pasaporte, la sesión rápida y el analizador corporal..
Después var app = express () Añadimos las siguientes líneas:
var passport = require ('passport') var session = require ('express-session') var bodyParser = require ('body-parser')En las dos primeras líneas, importamos el módulo de pasaporte y la sesión rápida, ambos de los cuales necesitamos manejar la autenticación.
Luego, importamos el módulo body-parser. Esto extrae toda la parte del cuerpo de una solicitud entrante y la expone en un formato más fácil de trabajar. En este caso, utilizaremos el formato JSON..
Para permitir que nuestra aplicación use el analizador de cuerpo, agregamos estas líneas algunos espacios debajo de las líneas de importación:
// Para BodyParser app.use (bodyParser.urlencoded (extended: true)); app.use (bodyParser.json ());
A continuación, inicializamos el pasaporte y la sesión rápida y la sesión de pasaporte y los agregamos como middleware. Hacemos esto agregando estas líneas algunos espacios después de la línea de importación bodyParser.
// Para Passport app.use (session (secret: 'keyboard cat', resave: true, saveUninitialized: true)); // session secret app.use (passport.initialize ()); app.use (passport.session ()); // sesiones de inicio de sesión persistentes
Comenzaremos a trabajar en la autenticación actual ahora.
Lo haremos en cuatro pasos:
Primero, creamos una base de datos en MySQL. Dale tu nombre preferido. Por el bien de este tutorial, vamos a crear una base de datos llamada sequelize_passport en MySQL.
Luego configuramos la configuración para manejar los detalles de la base de datos..
Primero, importemos el módulo dot-env para manejar las variables de entorno.
Ejecuta esto en tu carpeta de proyecto raíz:
npm install --save dotenv
Luego lo importamos en el archivo del servidor principal, server.js, justo debajo de las otras importaciones.
var env = require ('dotenv'). load (); A continuación, creamos un archivo en nuestra carpeta de proyecto y lo nombramos .env.
El siguiente paso a seguir es opcional si no estás usando Git:
Agregaremos el archivo .env a su archivo .gitignore.
Tu archivo .gitignore debería verse así:
nodo_módulos .env
Después de esto, agregamos nuestro entorno al archivo .env agregando esta línea:
NODE_ENV = 'desarrollo'
Luego creamos un archivo config.json que será utilizado por Sequelize para administrar diferentes entornos.
Lo primero que debes hacer es crear una carpeta llamada configuración en nuestra carpeta de proyectos. Dentro de esta carpeta, creamos un configuración.json expediente. Este archivo debe ignorarse si está presionando a un repositorio. Para hacer esto, agrega el siguiente código a tu .gitignore:
config / config.json
Luego, pegamos el siguiente código en nuestro archivo config.json.
"development": "username": "root", "password": null, "database": "sequelize_passport", "host": "127.0.0.1", "dialect": "mysql", "test" : "username": "", "password": null, "database": "", "host": "," dialecto ":" mysql "," production ": " username ":" ", "contraseña": nulo, "base de datos": "", "host": "127.0.0.1", "dialecto": "mysql"
Recuerde reemplazar los valores en el bloque de desarrollo anterior con los detalles de autenticación de su base de datos.
A continuación, instalamos secuelas con npm. Para hacer esto, ejecute el siguiente comando en la carpeta raíz del proyecto:
npm install --save secuela
Ahora es el momento de crear el modelos carpeta.
Primero, hacemos un directorio llamado aplicación en nuestra carpeta de proyectos.
Dentro de aplicación carpeta, creamos una nueva carpeta llamada modelos y crea un nuevo archivo llamado index.js en el modelos carpeta.
Dentro del archivo index.js, pegamos el siguiente código.
"uso estricto"; var fs = require ("fs"); var ruta = requiere ("ruta"); var Sequelize = require ("sequelize"); var env = process.env.NODE_ENV || "desarrollo"; var config = require (path.join (__ dirname, '…', 'config', 'config.json')) [env]; var sequelize = new Sequelize (config.database, config.username, config.password, config); var db = ; fs .readdirSync (__ dirname) .filter (function (file) return (file.indexOf (".")! == 0) && (file! == "index.js");) .forEach (function (file ) var model = sequelize.import (path.join (__ dirname, file)); db [model.name] = model;); Object.keys (db) .forEach (function (modelName) if ("asociado" en db [modelName]) db [modelName] .associate (db);); db.sequelize = secuela; db.Sequelize = Sequelize; module.exports = db;Este archivo se utiliza para importar todos los modelos que colocamos en el modelos carpeta, y exportarlos.
Para probar que todo está bien, agregamos esto en nuestro archivo server.js.
// Modelos var models = require ("./ app / models"); // Sync Database models.sequelize.sync (). Then (function () console.log ('Nice! Database parece estar bien')). Catch (function (err) console.log (err, "Algo salió mal con la Actualización de la Base de Datos! "));Aquí, estamos importando los modelos, y luego llamando a la función de sincronización Sequelize.
Ejecuta esto para ver si todo está bien:
nodo server.js
Si aparece el mensaje "¡El sitio está en vivo, bien! La base de datos se ve bien", entonces ha configurado Sequelize correctamente.
Si no, repase los pasos anteriores e intente solucionar el problema con ayuda.
Lo siguiente que vamos a hacer es crear el modelo de usuario, que es básicamente la tabla de usuarios. Esto contendrá información básica del usuario.
En nuestro modelos carpeta, creamos un archivo y lo nombramos usuario.js. La ruta completa para este archivo debe ser aplicación / modelos / usuario.js.
Abra el archivo user.js y agregue el siguiente código:
module.exports = function (sequelize, Sequelize) var User = sequelize.define ('user', id: autoIncrement: true, primaryKey: true, type: Sequelize.INTEGER, firstname: type: Sequelize.STRING, notEmpty: true, apellido: type: Sequelize.STRING, notEmpty: true, username: type: Sequelize.TEXT, about: type: Sequelize.TEXT, email: type: Sequelize.STRING, validate: isEmail: true, contraseña: type: Sequelize.STRING, allowNull: false, last_login: type: Sequelize.DATE, status: type: Sequelize.ENUM ('active', 'inactivo'), defaultValue : 'activo'); Usuario de retorno; Ahora ejecuta:
nodo server.js
Deberías ver lo familiar "El sitio está en vivo. Bonito! Base de datos Se ve bien.". Esto significa que nuestros modelos de Sequelize se han sincronizado correctamente, y si verifica su base de datos debería ver una tabla de usuarios con las columnas especificadas presentes.
Primero, creemos la vista para el registro y la conectemos.
Lo primero que debe hacer es importar el módulo de manubrios expresos que usamos para las vistas en este tutorial..
Añade esta línea al archivo de inicio principal, server.js.
var exphbs = require ('express-handlebars')
Tu bloque de importación debería tener este aspecto en este punto.
var express = require ('express') var app = express () var passport = require ('passport') var session = require ('express-session') var bodyParser = require ('body-parser') var env = require ('dotenv'). load () var exphbs = require ('express-handlebars')A continuación, agregamos las siguientes líneas en nuestro archivo server.js.
// Para Handlebars app.set ('views', './app/views') app.engine ('hbs', exphbs (extname: '.hbs')); app.set ('motor de vista', '.hbs');Ahora, en nuestra carpeta de aplicaciones, creamos tres carpetas llamadas puntos de vista, controladores, y rutas.
En la carpeta de vistas, creamos un archivo llamado Regístrate.hbs y pega el siguiente código en él.
Entonces en nuestro controladores carpeta, creamos un nuevo archivo y lo nombramos authcontroller.js.
En este archivo, pegamos el siguiente controlador para la ruta de registro que crearemos en un momento.
var exports = module.exports = exports.signup = function (req, res) res.render ('signup'); A continuación, creamos una ruta para el registro. En la carpeta de rutas, creamos un nuevo archivo llamado auth.js y luego, en este archivo, importamos el controlador de autenticación y definimos la ruta de registro.
var authController = require ('… /controllers/authcontroller.js'); module.exports = function (app) app.get ('/ signup', authController.signup); Ahora, importaremos esta ruta en nuestro server.js y pasaremos la aplicación como un argumento.
En el servidor, después de importar los modelos, agregue estas líneas:
// Rutas var authRoute = require ('./ app / route / auth.js') (app);Ejecuta esto:
nodo server.js
Ahora, visite http: // localhost: 5000 / signup y verá el formulario de registro.
Repitamos los pasos para el formulario de inicio de sesión. Como antes, crearemos un archivo llamado signin.hbs en nuestra carpeta de vistas y pegue el siguiente código HTML en ella:
Luego, agregue un controlador para el inicio de sesión. app / controllers / authcontroller.js.
exports.signin = function (req, res) res.render ('signin'); Entonces en aplicación / rutas / auth.js, Añadimos una ruta para iniciar sesión como esta:
app.get ('/ signin', authController.signin);
Ahora cuando corres:
nodo server.js
y visite http: // localhost: 5000 / signin /, debería ver el formulario de inicio de sesión.
El paso final y principal es escribir nuestras estrategias de pasaporte..
En app / config, creamos una nueva carpeta llamada pasaporte.
Luego, en nuestra nueva carpeta app / config / passport, creamos un nuevo archivo y lo nombramos pasaporte.js. Este archivo contendrá nuestras estrategias de pasaporte..
En pasaporte.js, Usaremos el modelo de usuario y el pasaporte..
Primero importamos bcrypt que necesitamos para asegurar las contraseñas.
var bCrypt = require ('bcrypt-nodejs');
Luego, agregamos un bloque de módulo.exportaciones como esta:
module.exports = function (pasaporte, usuario)
Dentro de este bloque, inicializamos la estrategia de pasaporte local y el modelo de usuario, que se pasará como argumento. Así es como hacemos esto:
module.exports = function (pasaporte, usuario) var User = usuario; var LocalStrategy = require ('passport-local'). Strategy; Luego definimos nuestra estrategia personalizada con nuestra instancia de LocalStrategy como esta:
passport.use ('local-signup', nueva LocalStrategy (usernameField: 'email', passwordField: 'password', passReqToCallback: true // nos permite devolver la solicitud completa a la devolución de llamada,));Ahora hemos declarado qué petición (req) Los campos nuestro nombre de usuario Campo y contraseña Campo (variables de pasaporte) son.
La última variable passReqToCallback nos permite pasar la solicitud completa a la devolución de llamada, lo que es particularmente útil para inscribirse.
Después de la última coma, agregamos esta función de devolución de llamada..
función (req, correo electrónico, contraseña, hecho)
En esta función, manejaremos el almacenamiento de los datos de un usuario..
Primero, agregamos nuestra función de generación de contraseña con hash dentro de la función de devolución de llamada.
var generateHash = function (password) return bCrypt.hashSync (password, bCrypt.genSaltSync (8), null); ;
Luego, utilizando el modelo de usuario de Sequelize, inicializamos antes como Usuario, Verificamos si el usuario ya existe, y si no, lo agregamos..
User.findOne (donde: email: email). Then (función (user) if (user) return done (null, false, message: 'Ese correo electrónico ya está tomado'); else else var userPassword = generateHash (password); var data = email: email, password: userPassword, firstname: req.body.firstname, lastname: req.body.lastname; User.create (data) .then (function (newUser, creado) if (! newUser) return done (null, false); if (newUser) return done (null, newUser);););
User.create () es un método Sequelize para agregar nuevas entradas a la base de datos. Tenga en cuenta que los valores en el datos objeto se obtiene de la req.body Objeto que contiene la entrada de nuestro formulario de registro..
Tu pasaporte.js debería verse así:
// cargar bcrypt var bCrypt = require ('bcrypt-nodejs'); module.exports = function (pasaporte, usuario) var User = usuario; var LocalStrategy = require ('passport-local'). Strategy; passport.use ('local-signup', nueva LocalStrategy (usernameField: 'email', passwordField: 'password', passReqToCallback: true // nos permite devolver la solicitud completa a la devolución de llamada, función (req, email, contraseña, listo) var generateHash = function (password) return bCrypt.hashSync (password, bCrypt.genSaltSync (8), null);; User.findOne (donde: email: email). Luego (función (usuario) si (usuario) retorno hecho (nulo, falso, mensaje: 'Ese correo electrónico ya está tomado'); else var userPassword = generateHash (contraseña); var data = correo electrónico: correo electrónico, contraseña: userPassword, firstname: req.body.firstname, lastname: req.body.lastname; User.create (data) .then (function (newUser, created) if (! newUser) return done (null, false); if (newUser) return done (null, newUser);););)); Ahora importaremos la estrategia en server.js.
Para hacer esto, agregamos estas líneas debajo de las rutas importadas en server.js.
// cargar las estrategias de pasaporte requieren ('./ app / config / passport / passport.js') (pasaporte, modelos.usuario);Su server.js debería tener este aspecto en este momento:
var express = require ('express') var app = express () var passport = require ('passport') var session = require ('express-session') var bodyParser = require ('body-parser') var env = require ('dotenv'). load () var exphbs = require ('express-handlebars') // For BodyParser app.use (bodyParser.urlencoded (extended: true)); app.use (bodyParser.json ()); // Para Passport app.use (session (secret: 'keyboard cat', resave: true, saveUninitialized: true)); // session secret app.use (passport.initialize ()); app.use (passport.session ()); // sesiones de inicio de sesión persistentes // Para Handlebars app.set ('views', './app/views') app.engine ('hbs', exphbs (extname: '.hbs')); app.set ('motor de vista', '.hbs'); app.get ('/', function (req, res) res.send ('Welcome to Passport with Sequelize');); // Modelos var models = require ("./ app / models"); // Rutas var authRoute = require ('./ app / route / auth.js') (app); // cargar las estrategias de pasaporte requieren ('./ app / config / passport / passport.js') (pasaporte, modelos.usuario); // Sync Database models.sequelize.sync (). Then (function () console.log ('Nice! Database parece estar bien')). Catch (function (err) console.log (err, "Algo salió mal con la Actualización de la Base de Datos! ")); app.listen (5000, function (err) if (! err) console.log ("El sitio está en vivo"); else console.log (err));Ahora aplicaremos la estrategia a nuestro /Regístrate ruta.
Así es como lo hacemos:
Primero vamos a aplicación / rutas / auth.js, y agrega una ruta para publicar para registrarse como este.
app.post ('/ signup', passport.authenticate ('local-signup', successRedirect: '/ dashboard', failureRedirect: '/ signup'));Ya que necesitamos pasaporte, necesitamos pasarlo a este método. Podemos importar el pasaporte en este script o pasarlo desde server.js. Hagamos lo ultimo.
Modificar la función exportada en este archivo. aplicación / rutas / auth.js Tener pasaporte como parámetro. El codigo en aplicación / rutas / auth.js Debería verse así después de tu modificación..
var authController = require ('… /controllers/authcontroller.js'); module.exports = function (aplicación, pasaporte) app.get ('/ signup', authController.signup); app.get ('/ signin', authController.signin); app.post ('/ signup', passport.authenticate ('local-signup', successRedirect: '/ dashboard', failureRedirect: '/ signup')); Entonces en server.js, Modificamos las rutas de importación y agregamos el pasaporte como un argumento como este:
var authRoute = require ('./ app / route / auth.js') (aplicación, pasaporte);
Ahora, vaya a la URL de registro http: // localhost: 5000 / signup / e intente registrarse.
Cuando intentas registrarte, obtendrás un error "Error al serializar el usuario en la sesión". Esto se debe a que el pasaporte tiene que guardar un ID de usuario en la sesión y lo utiliza para administrar la recuperación de los detalles del usuario cuando sea necesario..
Para resolver esto, vamos a implementar las funciones de serialización y deserialización del pasaporte en nuestro app / config / passport / passport.js expediente.
Primero agregamos la función serializar. En esta función, estaremos guardando el ID de usuario a la sesion.
Para ello, agregamos las siguientes líneas debajo de la inicialización de la estrategia local..
// serialize passport.serializeUser (function (user, done) done (null, user.id););
A continuación, implementamos la función de deserialización. Agregue la función justo debajo de la función serializar.
// deserializar usuario passport.deserializeUser (function (id, done) User.findById (id) .then (function (user) if (user) done (null, user.get ()); else else user.errors, null);););
En la función de deserialización anterior, utilizamos la secuela findById Prometo obtener el usuario, y si tiene éxito, se devuelve una instancia del modelo Sequelize. Para obtener el objeto Usuario de esta instancia, usamos la función de obtención de Sequelize como esta: usuario.get ().
Ahora corre otra vez:
nodo server.js
Y tratar de inscribirse. ¡Hurra si tienes el "No se puede obtener / Dashboard"! Significa que nuestra autenticación fue exitosa. Recuerde que redirigimos a / dashboard en nuestro método passport.authenticate en rutas / auth.js.
Ahora sigamos adelante y agreguemos esa ruta. Luego, agregue un middleware para asegurarse de que solo se pueda acceder a la página cuando un usuario ha iniciado sesión en la sesión.
En nuestro aplicación / vistas carpeta, creamos un nuevo archivo llamado dashboard.hbs y agrega el siguiente código HTML en él.
Pasaporte con Sequelize Tablero
¡Hurra! estás conectado.
En rutas / auth.js, Añadimos esta línea dentro del módulo.exportaciones bloquear:
app.get ('/ dashboard', authController.dashboard);
A continuación, vamos a app / controllers / authController.js y agrega el controlador del tablero.
exports.dashboard = function (req, res) res.render ('dashboard'); Su AuthController.js debería verse así:
var exports = module.exports = exports.signup = function (req, res) res.render ('signup'); exports.signin = function (req, res) res.render ('signin'); exports.dashboard = function (req, res) res.render ('dashboard'); Ahora, vuelva a ejecutar la aplicación e intente registrarse con una dirección de correo electrónico diferente a la que usó anteriormente. Serás redirigido apropiadamente a la /tablero ruta.
Pero /tablero no es una ruta protegida, lo que significa que incluso si un usuario no ha iniciado sesión, puede verla. No queremos esto, así que agregaremos una /cerrar sesión Ruta para cerrar la sesión del usuario, y luego proteger la ruta y probar lo que hemos hecho.
Hagámoslo:
En rutas / auth.js Añadimos esta línea:
app.get ('/ logout', authController.logout);
Luego agregamos el controlador en app / controllers / authController.js.
exports.logout = function (req, res) req.session.destroy (function (err) res.redirect ('/');); Ahora ejecuta la aplicación de nuevo y regístrate con una dirección de correo electrónico diferente.
Después de eso, visite http: // localhost: 5000 / logout para cerrar la sesión del usuario. Ahora visite http: // localhost: 5000 / dashboard.
Te darás cuenta de que es bastante accesible. Añadamos un middleware personalizado para proteger esa ruta..
Para ello, abrimos aplicación / rutas / auth.js y añadir esta función en la módulo.exportaciones Bloque, debajo de todas las demás líneas de código..
function isLoggedIn (req, res, next) if (req.isAuthenticated ()) return next (); res.redirect ('/ signin'); Luego modificamos el controlador de ruta del panel de control para que se vea así:
app.get ('/ dashboard', isLoggedIn, authController.dashboard);
Ahora, cuando vuelva a ejecutar la aplicación e intente visitar la página del panel y no haya iniciado sesión, debe ser redirigido a la página de inicio de sesión..
¡Uf! Es hora de implementar la parte final: el inicio de sesión..
Primero, agregaremos una nueva estrategia local para iniciar sesión app / config / passport / passport.js.
// LOCAL SIGNIN passport.use ('local-signin', nueva LocalStrategy (// de manera predeterminada, la estrategia local usa el nombre de usuario y la contraseña; anularemos con el correo electrónico nombre de usuario Campo: 'correo electrónico', contraseña Campo: 'contraseña', paseReqToCallback: verdadero // nos permite devolver la solicitud completa a la devolución de llamada, función (req, correo electrónico, contraseña, hecho) var User = user; var isValidPassword = function (userpass, password) return bCrypt.compareSync (password, userpass) ; User.findOne (donde: email: email). Luego (función (usuario) si (! Usuario) retorno hecho (nulo, falso, mensaje: 'El correo electrónico no existe'); if (! isValidPassword (user.password, password)) return done (null, false, message: 'Password incorrecto.'); var userinfo = user.get (); return done (null, userinfo); ) .catch (function (err) console.log ("Error:", err); return done (null, false, message: 'Algo salió mal con tu Signin'););));En esta estrategia, laisValidPasswordLa función compara la contraseña ingresada con el método de comparación bCrypt ya que almacenamos nuestra contraseña con bcrypt.
Si los detalles son correctos, nuestro usuario iniciará sesión..
Ahora ve a rutas / auth.js y agregar la ruta para publicar en /registrarse.
app.post ('/ signin', passport.authenticate ('local-signin', successRedirect: '/ dashboard', failureRedirect: '/ signin'));Tus rutas / auth.js deberían tener este aspecto cuando hayas terminado.
var authController = require ('… /controllers/authcontroller.js'); module.exports = function (aplicación, pasaporte) app.get ('/ signup', authController.signup); app.get ('/ signin', authController.signin); app.post ('/ signup', passport.authenticate ('local-signup', successRedirect: '/ dashboard', failureRedirect: '/ signup')); app.get ('/ dashboard', isLoggedIn, authController.dashboard); app.get ('/ logout', authController.logout); app.post ('/ signin', passport.authenticate ('local-signin', successRedirect: '/ dashboard', failureRedirect: '/ signin')); function isLoggedIn (req, res, next) if (req.isAuthenticated ()) return next (); res.redirect ('/ signin'); Ahora ejecuta la aplicación e intenta iniciar sesión. Debes poder iniciar sesión con cualquiera de los detalles que usaste al registrarte, y se te dirigirá a http: // localhost: 5000 / dashboard /.
¡Felicidades si llegaste al final de este tutorial! Hemos utilizado con éxito Sequelize y Passport con una base de datos MySQL.
El código completo para este tutorial se puede encontrar en GitHub.
Con esto concluye nuestro tutorial sobre el uso de Passport para la autenticación de usuarios con Sequelize y MySQL. Sequelize es un ORM realmente útil para tratar con MySQL cuando se utiliza Node. Personalmente, he encontrado que es muy útil, y definitivamente debería considerar usarlo en su próxima aplicación Node-MySQL.
