Sequelize är en löftesbaserad Node.js ORM. Den kan användas med PostgreSQL, MySQL, MariaDB, SQLite och MSSQL. I den här handledningen kommer vi att implementera autentisering för användare av en webbapp. Och vi kommer att använda Passport, den populära autentiseringsmellanvaran för Node, tillsammans med Sequelize och MySQL för att implementera användarregistrering och inloggning.
Komma igång
Se till att du har följande installerat på din maskin:
- Nod
- MySQL
För den här handledningen kommer vi att använda Node.js tillsammans med Express, så vi går vidare och börjar installera det vi behöver.
Steg 1:Skapa en package.json-fil
Skapa en katalog för din app. Inuti den här katalogen, kör detta från din terminal eller kommandotolk:
npm init
Detta initierar npm Dependency Manager. Detta kommer att presentera en rad uppmaningar som vi snabbt kommer att gå igenom.
- Skriv namnet på din app utan mellanslag och tryck på Retur för "namn".
- Tryck på Retur för "versionen".
- För 'beskrivning', i den här handledningen, skriver vi "Använda Passport med Sequelize och MySQL" som en beskrivning och trycker på Retur. Detta kan också vara tomt.
- För 'entry point (index.js)' skriver du server.js och trycker på Retur.
- För 'testkommando', tryck på Retur.
- För 'git repository' kan du ange git-repo där din app finns om du har en eller bara trycka på Retur för att lämna detta tomt.
- För "Sökord", tryck på Retur.
- För "författare", tryck på Retur eller skriv ditt namn innan du gör det.
- För "licens", tryck på Retur.
- För '(Är det här okej )' visar detta hur din package.json kommer att se ut. Skriv Ja och tryck på Retur.
Steg 2:Installera beroenden
De största beroenden för denna handledning är:
- Express
- Uppföljare
- MySQL
- Pass
- Lokal strategi för pass
- Body Parser
- Express-session
- Bcrypt Nodejs
- Express-styre för vyerna
För att installera dem, från din terminal eller kommandotolk, kör följande en efter en.
npm installera express --savenpm installera uppföljning --savenpm installera mysql --savenpm installera pass --savenpm installera passport-local --savenpm installera body-parser --savenpm installera express-session --savenpm installera bcrypt-nodejs - -savenpm installera express-styre --save
Om du använder Git för det här projektet:
Skapa en .gitignore-fil i din projektmapp.
Lägg till den här raden i .gitignore-filen.
node_modules
Steg 3:Konfigurera appen
Nu skapar vi en serverfil. Detta kommer att vara huvudfilen som kallas när du skriver följande:
npm start
Detta kör appen. Du kan också köra appen genom att skriva node server.js.
node server.js
Sedan, i vår projektmapp, skapar vi en ny fil och namnger den här filen server.js .
Inuti server.js fil klistrar vi in följande:
var express =require('express');var app =express();app.get('/', function(req, res) { res.send('Välkommen till Passport with Sequelize');});app.listen(5000, function(err) { if (!err) console.log("Webbplatsen är live"); else console.log(err)}); Den första raden tilldelar expressmodulen till en variabel express. Vi initierar sedan express och namnger den en variabel:app.
Sedan får vi applyssna på port 5000 . Du kan välja vilket ledigt portnummer som helst på din dator.
Därefter anropar vi app.get() express routingfunktion för att svara med "Välkommen till Passport with Sequelize" när en GET-begäran görs till "/".
För att testa på din dator, kör detta från projektmappen:
node server.js
Om du ser texten "Välkommen till Passport with Sequelize" när du besöker http://localhost:5000/ så grattis! Kontrollera annars att du har gjort allt precis som det står ovan.
Därefter importerar vi några moduler som vi behöver, som pass, express-session och body-parser.
Efter var app = express() vi lägger till följande rader:
var passport =require('passport')var session =require('express-session')var bodyParser =require('body-parser') På de två första raderna importerar vi passmodulen och express-sessionen, som vi båda behöver för att hantera autentisering.
Sedan importerar vi body-parser-modulen. Detta extraherar hela kroppsdelen av en inkommande förfrågan och exponerar den i ett format som är lättare att arbeta med. I det här fallet kommer vi att använda JSON-formatet.
För att låta vår app använda body-parsern lägger vi till dessa rader några mellanslag under importraderna:
//For BodyParserapp.use(bodyParser.urlencoded({ extended:true }));app.use(bodyParser.json()); Därefter initierar vi pass och expresssessionen och passsessionen och lägger till dem båda som mellanprogram. Vi gör detta genom att lägga till dessa rader några mellanslag efter bodyParser-importraden.
// For Passportapp.use(session({ secret:'keyboard cat',resave:true, saveUninitialized:true})); // session secretapp.use(passport.initialize());app.use(passport.session()); // ihållande inloggningssessioner Vi kommer att börja arbeta med själva autentiseringen nu.
Vi gör detta i fyra steg:
- Konfigurera Sequelize med MySQL.
- Skapa användarmodellen.
- Konfigurera vyer.
- Skriv en passstrategi.
1. Ställ in Sequelize med MySQL
Först skapar vi en databas i MySQL. Ge det ditt föredragna namn. För den här handledningens skull, låt oss skapa en databas med namnet sequelize_passport i MySQL.
Sedan ställer vi in konfigurationen för att hantera DB-detaljer.
Låt oss först importera dot-env-modulen för att hantera miljövariabler.
Kör detta i din rotprojektmapp :
npm install --save dotenv
Sedan importerar vi den i huvudserverfilen, server.js, precis under de andra importerna.
var env =require('dotenv').load(); Därefter skapar vi en fil i vår projektmapp och döper den till .env.
Detta nästa steg att följa är valfritt om du inte använder Git:
Vi lägger till .env-filen till din .gitignore-fil.
Din .gitignore-fil bör se ut så här:
node_modules.env
Efter detta lägger vi till vår miljö i .env-filen genom att lägga till denna rad:
NODE_ENV='development'
Sedan skapar vi en config.json-fil som kommer att användas av Sequelize för att hantera olika miljöer.
Det första du ska göra är att skapa en mapp med namnet config i vår projektmapp. Inuti den här mappen skapar vi en config. json fil. Den här filen bör ignoreras om du trycker till ett arkiv. För att göra detta, lägg till följande kod i din .gitignore:
config/config.json
Sedan klistrar vi in följande kod i vår config.json-fil.
{ "development":{ "username":"root", "password":null, "database":"sequelize_passport", "host":"127.0.0.1", "dialect":"mysql" }, "test":{ "username":"", "lösenord":null, "database":"", "host":"", "dialect":"mysql" }, "production":{ "användarnamn":"", "lösenord":null, "database":"", "host":"127.0.0.1", "dialect":"mysql" }} Kom ihåg att ersätta värdena i utvecklingsblocket ovan med dina databasautentiseringsdetaljer.
Därefter installerar vi sequelize med npm. För att göra detta, kör följande kommando i projektets rotmapp:
npm install --save sequelize
Nu är det dags att skapa modellerna mapp.
Först skapar vi en katalog som heter app i vår projektmapp.
Inuti appen mapp skapar vi en ny mapp med namnetmodeller och skapa en ny fil med namnet index.js i modellerna mapp.
Inuti filen index.js klistrar vi in koden nedan.
"use strict";var fs =require("fs");var path =require("sökväg");var Sequelize =require("sequelize");var env =process.env.NODE_ENV || "development";var config =require(path.join(__dirname, '..', 'config', 'config.json'))[env];var sequelize =new Sequelize(config.database, config.username, config .lösenord, config);var db ={};fs .readdirSync(__katalognamn) .filter(funktion(fil) { return (file.indexOf(".") !==0) &&(fil !=="index. js"); }) .forEach(function(file) { var model =sequelize.import(path.join(__dirname, file)); db[model.name] =model; });Object.keys(db). forEach(function(modelName) { if ("associera" i db[modellnamn]) { db[modellnamn].associate(db); }});db.sequelize =sequelize;db.Sequelize =Sequelize;module.exports =db; Den här filen används för att importera alla modeller vi placerar i modellerna mapp och exportera dem.
För att testa att allt är bra lägger vi till detta i vår server.js-fil.
//Modelsvar models =require("./app/models");//Sync Databasemodels.sequelize.sync().then(function() { console.log('Snyggt! Databasen ser bra ut')}) .catch(function(err) { console.log(err, "Något gick fel med databasuppdateringen!")}); Här importerar vi modellerna och anropar sedan funktionen Sequelize sync.
Kör detta för att se om allt är bra:
node server.js
Om du får meddelandet "Webbplatsen är bra! Databasen ser bra ut", har du konfigurerat Sequelize framgångsrikt.
Om inte, gå noga igenom stegen ovan och försök att felsöka problemet med hjälp.
2. Skapa användarmodellen
Nästa sak vi ska göra är att skapa användarmodellen, som i princip är användartabellen. Detta kommer att innehålla grundläggande användarinformation.
I våra modeller mapp skapar vi en fil och namnger den user.js . Den fullständiga sökvägen för den här filen bör vara app/models/user.js.
Öppna filen user.js och lägg till följande kod:
module.exports =function(sequelize, Sequelize) { var User =sequelize.define('user', { id:{ autoIncrement:true, primaryKey:true, type:Sequelize.INTEGER }, firstname:{ type:Sequelize .STRING, notEmpty:true }, efternamn:{ typ:Sequelize.STRING, notEmpty:true }, användarnamn:{ typ:Sequelize.TEXT }, om:{ typ:Sequelize.TEXT }, e-post:{ typ:Sequelize.STRING , validera:{ isEmail:true } }, lösenord:{ typ:Sequelize.STRING, allowNull:false }, last_login:{ typ:Sequelize.DATE }, status:{ typ:Sequelize.ENUM('active', 'inactive' ), defaultValue:'aktiv' } }); returnera användare;} Kör nu:
node server.js
Du bör se det välbekanta "Webbplatsen är live. Bra! Databas ser bra ut. " meddelande. Detta betyder att våra Sequelize-modeller har synkroniserats framgångsrikt, och om du kontrollerar din databas bör du se en användartabell med de angivna kolumnerna närvarande.
3:Konfigurera vyer
Låt oss först skapa vyn för registrering och koppla upp den.
Det första du ska göra är att importera expressstyrmodulen som vi använder för vyer i den här handledningen.
Lägg till den här raden i huvudstartfilen, server.js.
var exphbs = require('express-handlebars')
Ditt importblock bör se ut så här vid det här laget.
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-styre') Därefter lägger vi till följande rader i vår server.js-fil.
//For Handlebarsapp.set('views', './app/views')app.engine('hbs', exphbs({ extname:'.hbs'}));app.set('view engine ', '.hbs'); Nu, i vår app-mapp, skapar vi tre mappar som heter views, kontroller, och rutter .
I mappen vyer skapar vi en fil med namnet registrering. hbs och klistra in koden nedan i den.
Sedan i våra kontroller mapp skapar vi en ny fil och döper den till authcontroller.js.
I den här filen klistrar vi in följande kontroller för registreringsvägen som vi kommer att skapa om ett ögonblick.
var exports =module.exports ={}exports.signup =function(req, res) { res.render('signup');} Därefter skapar vi en rutt för registrering. I mappen rutter skapar vi en ny fil med namnet auth.js och sedan, i den här filen, importerar vi autentiseringskontrollern och definierar registreringsvägen.
var authController =require('../controllers/authcontroller.js');module.exports =function(app) { app.get('/signup', authController.signup);} Nu kommer vi att importera den här rutten i vår server.js och skicka appen som ett argument.
I servern, efter att modellerna har importerats, lägg till dessa rader:
//Routesvar authRoute =require('./app/routes/auth.js')(app); Kör detta:
node server.js
Besök nu http://localhost:5000/signup så ser du registreringsformuläret.
Låt oss upprepa stegen för inloggningsformuläret. Som tidigare skapar vi en fil med namnet signin.hbs i vår vy-mapp och klistra in följande HTML-kod i den:
Lägg sedan till en kontroller för inloggningen i app/controllers/authcontroller.js.
exports.signin =function(req, res) { res.render('signin');} Sedan i app/routes/auth.js , lägger vi till en rutt för inloggning så här:
app.get('/signin', authController.signin);
Nu när du kör:
nod server.js
och besök http://localhost:5000/signin/, bör du se inloggningsformuläret.
Det sista och stora steget är att skriva våra passstrategier.
4. Skriv en passstrategi
I app/config , skapar vi en ny mapp som heter pass.
Sedan skapar vi en ny fil i vår nya mapp app/config/passport och ger den namnet passport.js . Den här filen kommer att innehålla våra passstrategier.
I passport.js , kommer vi att använda användarmodellen och passet.
Först importerar vi bcrypt som vi behöver för att säkra lösenord.
var bCrypt = require('bcrypt-nodejs');
Sedan lägger vi till ett module.exports-block så här:
module.exports =funktion(pass, användare) {} Inuti detta block initierar vi den pass-lokala strategin och användarmodellen, som kommer att skickas som ett argument. Så här gör vi:
module.exports =funktion(pass, användare) { var Användare =användare; var LocalStrategy =require('passport-local').Strategy;} Sedan definierar vi vår anpassade strategi med vår instans av LocalStrategy så här:
passport.use('local-signup', new LocalStrategy( { usernameField:'email', passwordField:'password', passReqToCallback:true // tillåter oss att skicka tillbaka hela begäran till återuppringningen },)); Nu har vi deklarerat vilken begäran (req ) fälten som vårt användarnamnField och passwordField (passvariabler) är.
Den sista variabeln passReqToCallback tillåter oss att skicka hela begäran till återuppringningen, vilket är särskilt användbart för att registrera dig.
Efter det sista kommatecken lägger vi till denna återuppringningsfunktion.
-funktion(req, email, password, done) { } I den här funktionen kommer vi att hantera att lagra en användares uppgifter.
Först lägger vi till vår hashade lösenordsgenererande funktion i återuppringningsfunktionen.
var generHash =function(lösenord) { return bCrypt.hashSync(lösenord, bCrypt.genSaltSync(8), null); }; Använd sedan Sequelize-användarmodellen som vi initierade tidigare som Användare , kontrollerar vi om användaren redan finns, och om inte lägger vi till dem.
User.findOne({ where:{ email:email }}).then(function(user) { if (user) { return done(null, false, { message:'Det e-postmeddelandet har redan tagits' }); } else { var userPassword =genereraHash(lösenord); var data ={ e-post:e-post, lösenord:användarLösenord, förnamn:req.body.firstname, efternamn:req.body.lastname }; User.create(data).then(funktion) (nyanvändare, skapad) { if (!newUser) { return done(null, false); } if (newUser) { return done(null, newUser); } }); }});
User.create() är en Sequelize-metod för att lägga till nya poster i databasen. Lägg märke till att värdena i data objekt hämtas från req.body objekt som innehåller indata från vårt registreringsformulär.
Ditt passport.js ska se ut så här:
//load bcryptvar bCrypt =require('bcrypt-nodejs');module.exports =function(pass, användare) { var User =user; var LocalStrategy =require('passport-local').Strategy; passport.use('local-signup', new LocalStrategy( { usernameField:'email', passwordField:'password', passReqToCallback:true // tillåter oss att skicka tillbaka hela begäran till återuppringningen }, function(req, email, lösenord, klar) { var generHash =function(lösenord) { return bCrypt.hashSync(lösenord, bCrypt.genSaltSync(8), null); }; User.findOne({ där:{ email:email } }).then(function (användare) { if (användare) { return done(null, false, { message:'Det e-postmeddelandet är redan tagit' }); } else { var userPassword =generHash(lösenord); var data ={ email:email, password:användarlösenord, förnamn:req.body.firstname, efternamn:req.body.lastname }; User.create(data).then(function(newUser, created) { if (!newUser) { return done(null, false); } if (newUser) { return done(null, newUser); } }); } }); } ));} Nu kommer vi att importera strategin i server.js.
För att göra detta lägger vi till dessa rader under ruttimporten i server.js.
//load passport strategiesrequire('./app/config/passport/passport.js')(passport, models.user); Din server.js bör se ut så här vid det här laget:
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 BodyParserapp.use(bodyParser.urlencoded({ extended:true}));app.use(bodyParser.json( ));// For Passportapp.use(session({ secret:'keyboard cat', resave:true, saveUninitialized:true})); // session secretapp.use(passport.initialize());app.use(passport.session()); // ihållande inloggningssessioner//For Handlebarsapp.set('views', './app/views')app.engine('hbs', exphbs({ extname:'.hbs'}));app.set(' view engine', '.hbs');app.get('/', function(req, res) { res.send('Välkommen till Passport with Sequelize');});//Modelsvar models =require(". /app/models");//Routesvar authRoute =require('./app/routes/auth.js')(app);//load passport strategiesrequire('./app/config/passport/passport.js') (pass, models.user);//Sync Databasemodels.sequelize.sync().then(function() { console.log('Skönt! Databasen ser bra ut')}).catch(function(err) { console.log (fel, "Något gick fel med databasuppdateringen!")});app.listen(5000, function(err) { if (!err) console.log("Webbplatsen är live"); else console.log(err )}); Nu kommer vi faktiskt att tillämpa strategin på vår /signup rutt.
Så här gör vi det:
Först går vi till app/routes/auth.js , och lägg till en rutt för inlägg för att registrera dig så här.
app.post('/signup', passport.authenticate('local-signup', { successRedirect:'/dashboard', failureRedirect:'/signup' })); Eftersom vi behöver pass måste vi skicka det till den här metoden. Vi kan importera pass i detta skript eller skicka det från server.js. Låt oss göra det senare.
Ändra funktionen som exporteras i den här filen app/routes/auth.js att ha pass som parameter. Koden i app/routes/auth.js ska se ut så här efter din modifiering.
var authController =require('../controllers/authcontroller.js');module.exports =function(app, passport) { app.get('/signup', authController.signup); app.get('/signin', authController.signin); app.post('/signup', passport.authenticate('local-signup', { successRedirect:'/dashboard', failureRedirect:'/signup' } ));} Sedan i server.js , vi ändrar ruttimporten och lägger till pass som ett argument så här:
var authRoute = require('./app/routes/auth.js')(app,passport);
Gå nu till registreringsadressen http://localhost:5000/signup/ och försök registrera dig.
När du försöker registrera dig får du felmeddelandet "Det gick inte att serialisera användaren till session ". Detta beror på att pass måste spara ett användar-ID i sessionen, och det använder detta för att hantera att hämta användarinformationen vid behov.
För att lösa detta kommer vi att implementera både serialiserings- och deserialiseringsfunktionerna för pass i vår app/config/passport/passport.js fil.
Först lägger vi till serialiseringsfunktionen. I den här funktionen kommer vi att spara användar-id till sessionen.
För att göra detta lägger vi till följande rader under initieringen av den lokala strategin.
//serializepassport.serializeUser(function(user, done) { done(null, user.id);}); Därefter implementerar vi deserialiseringsfunktionen. Lägg till funktionen precis under serialiseringsfunktionen.
// deserialize user passport.deserializeUser(function(id, done) { User.findById(id).then(function(user) { if (user) { done(null, user.get()); } else { done(user.errors, null); } });});
I deserialiseringsfunktionen ovan använder vi Sequelize findById lovar att få användaren, och om det lyckas returneras en instans av Sequelize-modellen. För att hämta User-objektet från den här instansen använder vi Sequelize getter-funktionen så här:user.get() .
Kör nu igen:
node server.js
Och försök att registrera dig. Hurra om du fick "Cannot GET /dashboard"! Det betyder att vår autentisering lyckades. Kom ihåg att vi omdirigerade till /dashboard i vår passport.authenticate-metod i routes/auth.js .
Låt oss nu gå vidare och lägga till den rutten. Lägg sedan till en mellanprogramvara för att se till att sidan endast kan nås när en användare är inloggad i sessionen.
I vår app/vyer mappen skapar vi en ny fil med namnet dashboard.hbs och lägg till följande HTML-kod i den.
Pass med Sequelize Dashboard
Hurra! du är inloggad.
I routes/auth.js lägger vi till den här raden i module.exports blockera:
app.get('/dashboard',authController.dashboard);
Därefter går vi till app/controllers/authController.js och lägg till kontrollpanelen för instrumentbrädan.
exports.dashboard =function(req, res) { res.render('dashboard');} Din AuthController.js bör se ut så här:
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');} Kör nu appen igen och försök registrera dig med en annan e-postadress än den du använde tidigare. Du omdirigeras på lämpligt sätt till /dashboard rutt.
Men /dashboard är inte en skyddad rutt, vilket innebär att även om en användare inte är inloggad kan de se den. Vi vill inte ha detta, så vi lägger till en /logout rutten för att logga ut användaren och sedan skydda rutten och testa vad vi har gjort.
Låt oss göra så här:
I routes/auth.js vi lägger till den här raden:
app.get('/logout',authController.logout);
Sedan lägger vi till kontrollern i app/controllers/authController.js.
exports.logout =function(req, res) { req.session.destroy(function(err) { res.redirect('/'); }); } Kör nu appen igen och registrera dig med en annan e-postadress.
Efter det, besök http://localhost:5000/logout för att logga ut användaren. Besök nu http://localhost:5000/dashboard.
Du kommer att märka att det är ganska lättillgängligt. Låt oss lägga till en anpassad mellanprogramvara för att skydda den vägen.
För att göra detta öppnar vi app/routes/auth.js och lägg till den här funktionen i module.exports block, under alla andra kodrader.
function isLoggedIn(req, res, next) { if (req.isAuthenticated()) return next(); res.redirect('/signin');} Sedan ändrar vi instrumentpanelens rutthanterare så att den ser ut så här:
app.get('/dashboard',isLoggedIn, authController.dashboard);
Nu när du kör appen igen och försöker besöka instrumentpanelssidan och du inte är inloggad, bör du omdirigeras till inloggningssidan.
Wow! Det är dags att implementera den sista delen:inloggningen.
Först lägger vi till en ny lokal strategi för inloggning i app/config/passport/passport.js .
//LOCAL SIGNINpassport.use('local-signin', new LocalStrategy( {// som standard använder lokal strategi användarnamn och lösenord, vi kommer att åsidosätta med e-post användarnamnFält:'email', passwordField:'lösenord', passReqToCallback :true // tillåter oss att skicka tillbaka hela begäran till återuppringningen }, function(req, email, password, done) { var User =user; var isValidPassword =function(userpass, password) { return bCrypt.compareSync(lösenord, userpass); } User.findOne({ where:{ email:email } }).then(function(user) { if (!user) { return done(null, false, { message:'Email exists not exist' }); } if (!isValidPassword(användare.lösenord, lösenord)) { return done(null, false, { meddelande:'Felaktigt lösenord.' }); } var användarinfo =användare. skaffa sig(); return done(null, användarinfo); }).catch(function(err) { console.log("Fel:", err); return done(null, false, { meddelande:'Något gick fel med din inloggning' }); }); }));
I den här strategin är isValidPassword funktion jämför lösenordet som angetts med jämförelsemetoden bCrypt eftersom vi lagrade vårt lösenord med bcrypt .
Om uppgifterna är korrekta kommer vår användare att loggas in.
Gå nu till routes/auth.js och lägg till rutten för inlägg till / logga in.
app.post('/signin', passport.authenticate('local-signin', { successRedirect:'/dashboard', failureRedirect:'/signin' })); Dina routes/auth.js bör se ut så här när du är klar.
var authController =require('../controllers/authcontroller.js');module.exports =function(app, passport) { 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'); }} Kör nu appen och försök logga in. Du bör kunna logga in med alla uppgifter du använde när du registrerade dig, och du kommer att dirigeras till http ://localhost:5000/dashboard/.
Grattis om du kom till slutet av denna handledning! Vi har framgångsrikt använt Sequelize och Passport med en MySQL-databas.
Den fullständiga koden för denna handledning finns på GitHub.