Sequelize er en løftebaseret Node.js ORM. Det kan bruges med PostgreSQL, MySQL, MariaDB, SQLite og MSSQL. I denne vejledning implementerer vi godkendelse for brugere af en webapp. Og vi vil bruge Passport, den populære autentificerings-middleware til Node, sammen med Sequelize og MySQL til at implementere brugerregistrering og login.
Kom godt i gang
Sørg for, at du har følgende installeret på din maskine:
- Node
- MySQL
Til denne vejledning vil vi bruge Node.js sammen med Express, så vi går videre og begynder at installere det, vi har brug for.
Trin 1:Generer en package.json-fil
Opret en mappe til din app. Inde i denne mappe skal du køre dette fra din terminal eller kommandoprompt:
npm init
Dette initialiserer npm Dependency Manager. Dette vil præsentere en række meddelelser, som vi hurtigt vil gennemgå.
- Skriv navnet på din app uden mellemrum, og tryk på Enter for 'navn'.
- Tryk på Enter for 'versionen'.
- Til 'beskrivelse' skriver vi i dette selvstudium "Brug af Passport med Sequelize og MySQL" som en beskrivelse og trykker på Enter. Dette kan også være tomt.
- For 'indgangspunkt (index.js)' skal du skrive server.js og trykke på Enter.
- Tryk på Enter for 'testkommando'.
- For 'git repository' kan du indtaste den git-repo, hvor din app ligger, hvis du har en eller bare trykke på Enter for at lade dette stå tomt.
- Tryk på Enter for 'Søgeord'.
- For 'forfatter' skal du trykke på Enter eller indtaste dit navn, før du gør det.
- Tryk på Enter for at få 'licens'.
- For '(Er dette okay )' viser dette dig, hvordan din package.json vil se ud. Skriv Ja, og tryk på Enter.
Trin 2:Installer afhængigheder
De største afhængigheder for denne øvelse er:
- Express
- Forfølgelse
- MySQL
- Pas
- Lokal strategi for pas
- Body Parser
- Express-session
- Bcrypt Nodejs
- Express-styr for visningerne
For at installere dem fra din terminal eller kommandoprompt, kør følgende en efter en.
npm install express --savenpm installer efterfølger --savenpm installer mysql --savenpm installer pas --savenpm installer passport-local --savenpm installer body-parser --savenpm installer express-session --savenpm installer bcrypt-nodejs - -savenpm installer express-styr --save
Hvis du bruger Git til dette projekt:
Opret en .gitignore-fil i din projektmappe.
Tilføj denne linje til .gitignore-filen.
node_modules
Trin 3:Konfigurer appen
Nu opretter vi en serverfil. Dette vil være hovedfilen, der kaldes, når du skriver følgende:
npm start
Dette kører appen. Du kan også køre appen ved at skrive node server.js.
node server.js
Derefter, i vores projektmappe, opretter vi en ny fil og navngiver denne fil server.js .
Inde i server.js fil, indsætter vi følgende:
var express =require('express');var app =express();app.get('/', function(req, res) { res.send('Velkommen til Passport with Sequelize');});app.listen(5000, function(err) { if (!err) console.log("Site er live"); else console.log(err)}); Den første linje tildeler express-modulet til en variabel express. Vi initialiserer derefter express og kalder det en variabel:app.
Så får vi app til at lytte på port 5000 . Du kan vælge et hvilket som helst ledigt portnummer på din computer.
Dernæst kalder vi app.get() Express routing-funktion til at svare med "Velkommen til Passport with Sequelize", når en GET-anmodning sendes til "/".
For at teste på din computer skal du køre dette inde fra din projektmappe:
node server.js
Hvis du ser teksten "Velkommen til Passport with Sequelize", når du besøger http://localhost:5000/, så tillykke! Ellers skal du kontrollere, at du har gjort alt præcis som det er skrevet ovenfor.
Dernæst importerer vi nogle moduler, vi har brug for, f.eks. pas, ekspres-session og body-parser.
Efter var app = express() vi tilføjer følgende linjer:
var passport =require('pas')var session =require('express-session')var bodyParser =require('body-parser') I de første to linjer importerer vi pasmodulet og ekspres-sessionen, som vi begge skal håndtere godkendelse.
Derefter importerer vi body-parser-modulet. Dette udtrækker hele kropsdelen af en indgående anmodning og eksponerer den i et format, der er lettere at arbejde med. I dette tilfælde vil vi bruge JSON-formatet.
For at lade vores app bruge body-parseren tilføjer vi disse linjer nogle mellemrum under importlinjerne:
//For BodyParserapp.use(bodyParser.urlencoded({ extended:true }));app.use(bodyParser.json()); Derefter initialiserer vi pas og ekspressessionen og passessionen og tilføjer dem begge som middleware. Vi gør dette ved at tilføje disse linjer nogle mellemrum efter bodyParser-importlinjen.
// For Passportapp.use(session({ secret:'keyboard cat',resave:true, saveUninitialized:true})); // session secretapp.use(passport.initialize());app.use(passport.session()); // vedvarende login-sessioner Vi vil begynde at arbejde på den faktiske godkendelse nu.
Vi gør dette i fire trin:
- Konfigurer Sequelize med MySQL.
- Opret brugermodellen.
- Konfigurer visninger.
- Skriv en passtrategi.
1. Konfigurer Sequelize med MySQL
Først opretter vi en database i MySQL. Giv det dit foretrukne navn. Af hensyn til denne vejledning, lad os oprette en database ved navn sequelize_passport i MySQL.
Derefter opsætter vi konfigurationen til at håndtere DB-detaljer.
Lad os først importere dot-env-modulet for at håndtere miljøvariabler.
Kør dette i din rodprojektmappe :
npm install --save dotenv
Så importerer vi den i hovedserverfilen, server.js, lige under de andre importer.
var env =require('dotenv').load(); Dernæst opretter vi en fil i vores projektmappe og navngiver den .env.
Dette næste trin at følge er valgfrit, hvis du ikke bruger Git:
Vi tilføjer .env-filen til din .gitignore-fil.
Din .gitignore-fil skulle se sådan ud:
node_modules.env
Herefter tilføjer vi vores miljø til .env-filen ved at tilføje denne linje:
NODE_ENV='development'
Derefter opretter vi en config.json-fil, som vil blive brugt af Sequelize til at administrere forskellige miljøer.
Den første ting at gøre er at oprette en mappe med navnet config i vores projektmappe. Inde i denne mappe opretter vi en config. json fil. Denne fil bør ignoreres, hvis du skubber til et lager. For at gøre dette skal du tilføje følgende kode til din .gitignore:
config/config.json
Derefter indsætter vi følgende kode i vores config.json-fil.
{ "development":{ "username":"root", "password":null, "database":"sequelize_passport", "host":"127.0.0.1", "dialect":"mysql" }, "test":{ "username":"", "password":null, "database":"", "host":"", "dialect":"mysql" }, "production":{ "brugernavn":"", "password":null, "database":"", "host":"127.0.0.1", "dialect":"mysql" }} Husk at erstatte værdierne i udviklingsblokken ovenfor med dine databasegodkendelsesdetaljer.
Dernæst installerer vi sequelize med npm. For at gøre dette skal du køre følgende kommando i projektets rodmappe:
npm install --save sequelize
Nu er det tid til at skabe modellerne folder.
Først laver vi en mappe med navnet app i vores projektmappe.
Inde i appen mappe, opretter vi en ny mappe med navnetmodeller og opret en ny fil med navnet index.js i modellerne mappe.
Inde i index.js-filen indsætter vi koden nedenfor.
"brug streng";var fs =require("fs");var path =require("sti");var Sequelize =require("sequelize");var env =process.env.NODE_ENV || "udvikling";var config =require(path.join(__dirnavn, '..', 'config', 'config.json'))[env];var sequelize =new Sequelize(config.database, config.username, config .password, config);var db ={};fs .readdirSync(__dirname) .filter(funktion(fil) { return (file.indexOf(".") !==0) &&(fil !=="indeks. js"); }) .forEach(function(file) { var model =sequelize.import(path.join(__dirname, file)); db[model.name] =model; });Object.keys(db). forEach(function(modelName) { if ("associere" i db[modelName]) { db[modelName].associate(db); }});db.sequelize =sequelize;db.Sequelize =Sequelize;module.exports =db; Denne fil bruges til at importere alle de modeller, vi placerer i modellerne mappe, og eksporter dem.
For at teste, at alt er godt, tilføjer vi dette i vores server.js-fil.
//Modelsvar models =require("./app/models");//Sync Databasemodels.sequelize.sync().then(function() { console.log('Dejligt! Databasen ser fin ud')}) .catch(function(err) { console.log(err, "Noget gik galt med databaseopdateringen!")}); Her importerer vi modellerne og kalder derefter funktionen Sequelize sync.
Kør dette for at se, om alt er godt:
node server.js
Hvis du får beskeden "Site er live Nice! Database ser fint ud", så har du opsat Sequelize.
Hvis ikke, så gå omhyggeligt igennem ovenstående trin og prøv at fejlfinde problemet med hjælp.
2. Opret brugermodellen
Det næste, vi skal gøre, er at oprette brugermodellen, som grundlæggende er brugertabellen. Dette vil indeholde grundlæggende brugeroplysninger.
I vores modeller mappe, opretter vi en fil og navngiver den user.js . Den fulde sti til denne fil skal være app/models/user.js.
Åbn filen user.js og tilføj følgende kode:
module.exports =function(sequelize, Sequelize) { var User =sequelize.define('user', { id:{ autoIncrement:true, primaryKey:true, type:Sequelize.INTEGER }, firstname:{ type:Sequelize .STRING, notEmpty:true }, efternavn:{ type:Sequelize.STRING, notEmpty:true }, brugernavn:{ type:Sequelize.TEXT }, om:{ type:Sequelize.TEXT }, e-mail:{ type:Sequelize.STRING , valider:{ isEmail:true } }, adgangskode:{ type:Sequelize.STRING, allowNull:false }, last_login:{ type:Sequelize.DATE }, status:{ type:Sequelize.ENUM('active', 'inactive' ), defaultValue:'aktiv' } }); returnere bruger;} Kør nu:
node server.js
Du bør se den velkendte "Site er live. Dejligt! Database ser fint ud. "-meddelelse. Dette betyder, at vores Sequelize-modeller er blevet synkroniseret med succes, og hvis du tjekker din database, skulle du se en brugertabel med de angivne kolonner til stede.
3:Konfigurer visninger
Lad os først oprette visningen til tilmelding og tilslutte den.
Den første ting at gøre er at importere ekspresstyrmodulet, som vi bruger til visninger i denne øvelse.
Føj denne linje til hovedstartfilen, server.js.
var exphbs = require('express-handlebars')
Din importblok skulle se sådan ud på dette tidspunkt.
var express =require('express')var app =express()var passport =require('pas')var session =require('express-session')var bodyParser =require('body-parser')var env =require('dotenv').load()var exphbs =require('express-styr') Dernæst tilføjer vi følgende linjer i vores server.js-fil.
//For Handlebarsapp.set('views', './app/views')app.engine('hbs', exphbs({ extname:'.hbs'}));app.set('view engine ', '.hbs'); Nu, i vores app-mappe, opretter vi tre mapper med navnet visninger, controllere, og ruter .
I visningsmappen opretter vi en fil med navnet tilmelding. hbs og indsæt koden nedenfor i den.
Derefter i vores controllere mappe, opretter vi en ny fil og navngiver den authcontroller.js.
I denne fil indsætter vi følgende controller til tilmeldingsruten, som vi vil oprette om et øjeblik.
var exports =modul.exports ={}exports.signup =function(req, res) { res.render('signup');} Dernæst opretter vi en rute for tilmelding. I rutemappen opretter vi en ny fil med navnet auth.js og i denne fil importerer vi godkendelsescontrolleren og definerer tilmeldingsruten.
var authController =require('../controllers/authcontroller.js');module.exports =function(app) { app.get('/signup', authController.signup);} Nu importerer vi denne rute i vores server.js og sender appen som et argument.
I serveren, efter at modellerne er importeret, skal du tilføje disse linjer:
//Routesvar authRoute =require('./app/routes/auth.js')(app); Kør dette:
node server.js
Besøg http://localhost:5000/signup og du vil se tilmeldingsformularen.
Lad os gentage trinene for loginformularen. Som før opretter vi en fil med navnet signin.hbs i vores visningsmappe og indsæt følgende HTML-kode i den:
Tilføj derefter en controller til login i app/controllers/authcontroller.js.
exports.signin =function(req, res) { res.render('signin');} Derefter i app/routes/auth.js , tilføjer vi en rute til login som denne:
app.get('/signin', authController.signin);
Nu når du kører:
node server.js
og besøg http://localhost:5000/signin/, bør du se login-formularen.
Det sidste og store skridt er at skrive vores passtrategier.
4. Skriv en passtrategi
I app/config , opretter vi en ny mappe med navnet pas.
Så i vores nye mappe app/config/passport opretter vi en ny fil og navngiver den passport.js . Denne fil vil indeholde vores passtrategier.
I passport.js , vil vi bruge brugermodellen og passet.
Først importerer vi bcrypt som vi har brug for for at sikre adgangskoder.
var bCrypt = require('bcrypt-nodejs');
Derefter tilføjer vi en module.exports-blok som denne:
module.exports =funktion(pas, bruger) {} Inde i denne blok initialiserer vi den pas-lokale strategi og brugermodellen, som vil blive videregivet som et argument. Sådan gør vi det:
module.exports =funktion(pas, bruger) { var Bruger =bruger; var LocalStrategy =require('passport-local').Strategy;} Derefter definerer vi vores tilpassede strategi med vores forekomst af LocalStrategy som denne:
passport.use('local-signup', new LocalStrategy( { usernameField:'email', passwordField:'password', passReqToCallback:true // tillader os at sende hele anmodningen tilbage til tilbagekaldet },)); Nu har vi erklæret hvilken anmodning (req ) felter, som vores brugernavnField og passwordField (pasvariabler) er.
Den sidste variabel passReqToCallback giver os mulighed for at videregive hele anmodningen til tilbagekaldet, hvilket er særligt nyttigt ved tilmelding.
Efter det sidste komma tilføjer vi denne tilbagekaldsfunktion.
funktion(req, email, password, done) { } I denne funktion håndterer vi lagring af en brugers detaljer.
Først tilføjer vi vores hashed adgangskodegenererende funktion i tilbagekaldsfunktionen.
var generHash =function(adgangskode) { return bCrypt.hashSync(adgangskode, bCrypt.genSaltSync(8), null); }; Brug derefter Sequelize-brugermodellen, som vi tidligere initialiserede som Bruger , tjekker vi om brugeren allerede eksisterer, og hvis ikke tilføjer vi dem.
User.findOne({ where:{ email:email }}).then(function(user) { if (user) { return done(null, false, { message:'Denne e-mail er allerede taget' }); } else { var userPassword =generHash(adgangskode); var data ={ e-mail:e-mail, adgangskode:brugerPassword, fornavn:req.body.firstname, efternavn:req.body.lastname }; User.create(data).then(funktion) (nyBruger, oprettet) { if (!nyBruger) { return done(null, false); } if (newUser) { return done(null, newUser); } }); }});
User.create() er en Sequelize-metode til at tilføje nye poster til databasen. Bemærk, at værdierne i data objekt er hentet fra req.body objekt, som indeholder input fra vores tilmeldingsformular.
Dit passport.js skal se sådan ud:
//load bcryptvar bCrypt =require('bcrypt-nodejs');module.exports =function(pas, bruger) { var User =user; var LocalStrategy =require('passport-local').Strategy; passport.use('local-signup', new LocalStrategy( { usernameField:'email', passwordField:'password', passReqToCallback:true // giver os mulighed for at sende hele anmodningen tilbage til tilbagekaldet }, function(req, email, adgangskode, udført) { var generHash =funktion(adgangskode) { return bCrypt.hashSync(adgangskode, bCrypt.genSaltSync(8), null); }; User.findOne({ hvor:{ email:email } }).then(funktion (bruger) { if (bruger) { return done(null, false, { message:'Denne e-mail er allerede taget' }); } else { var userPassword =generHash(adgangskode); var data ={ email:email, password:brugeradgangskode, fornavn:req.body.firstname, efternavn:req.body.lastname }; User.create(data).then(funktion(nyBruger, oprettet) { if (!nyBruger) { return done(null, false); } if (newUser) { return done(null, newUser); } }); } }); } ));} Nu vil vi importere strategien i server.js.
For at gøre dette tilføjer vi disse linjer under ruteimporten i server.js.
//load passport strategiesrequire('./app/config/passport/passport.js')(pas, models.user); Din server.js skulle se sådan ud på nuværende tidspunkt:
var express =require('express')var app =express()var passport =require('pas')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()); // vedvarende login-sessioner//For Handlebarsapp.set('views', './app/views')app.engine('hbs', exphbs({ extname:'.hbs'}));app.set(' view engine', '.hbs');app.get('/', function(req, res) { res.send('Velkommen til Passport with Sequelize');});//Modelsvar-modeller =require(". /app/models");//Routesvar authRoute =require('./app/routes/auth.js')(app);//load passport strategiesrequire('./app/config/passport/passport.js') (pas, models.user);//Sync Databasemodels.sequelize.sync().then(function() { console.log('Dejligt! Databasen ser fin ud')}).catch(function(err) { console.log (err, "Noget gik galt med databaseopdateringen!")});app.listen(5000, function(err) { if (!err) console.log("Site er live"); else console.log(err )}); Nu vil vi faktisk anvende strategien på vores /signup rute.
Sådan gør vi det:
Først går vi til app/routes/auth.js , og tilføj en rute for opslag til tilmelding som denne.
app.post('/signup', passport.authenticate('local-signup', { successRedirect:'/dashboard', failureRedirect:'/signup' })); Da vi har brug for pas, skal vi videregive det til denne metode. Vi kan importere pas i dette script eller videregive det fra server.js. Lad os gøre det sidste.
Rediger den funktion, der eksporteres i denne fil app/routes/auth.js at have pas som parameter. Koden i app/routes/auth.js skal se sådan ud efter din ændring.
var authController =require('../controllers/authcontroller.js');module.exports =function(app, pas) { app.get('/signup', authController.signup); app.get('/signin', authController.signin); app.post('/signup', passport.authenticate('local-signup', { successRedirect:'/dashboard', failureRedirect:'/signup' } ));} Derefter i server.js , vi ændrer ruteimporten og tilføjer pas som et argument som dette:
var authRoute = require('./app/routes/auth.js')(app,passport);
Gå nu til tilmeldingswebadressen http://localhost:5000/signup/ og prøv at tilmelde dig.
Når du prøver at tilmelde dig, får du fejlmeddelelsen "Kunne ikke serialisere brugeren til session ". Dette skyldes, at passet skal gemme et bruger-id i sessionen, og det bruger dette til at administrere hentning af brugeroplysningerne, når det er nødvendigt.
For at løse dette vil vi implementere både serialiserings- og deserialiseringsfunktionerne for pas i vores app/config/passport/passport.js fil.
Først tilføjer vi serialiseringsfunktionen. I denne funktion vil vi gemme bruger-id'et til sessionen.
For at gøre dette tilføjer vi følgende linjer under initialiseringen af den lokale strategi.
//serializepassport.serializeUser(function(user, done) { done(null, user.id);}); Dernæst implementerer vi deserialiseringsfunktionen. Tilføj funktionen lige under serialiseringsfunktionen.
// deserialize user passport.deserializeUser(function(id, done) { User.findById(id).then(function(user) { if (user) { done(null, user.get()); } else { done(bruger.fejl, null); } });});
I deserialiseringsfunktionen ovenfor bruger vi Sequelize findById lover at få brugeren, og hvis det lykkes, returneres en forekomst af Sequelize-modellen. For at hente brugerobjektet fra denne instans bruger vi Sequelize getter-funktionen som denne:user.get() .
Kør nu igen:
node server.js
Og prøv at tilmelde dig. Hurra hvis du fik "Kan ikke FÅ /dashboard"! Det betyder, at vores godkendelse var vellykket. Husk, at vi omdirigerede til /dashboard i vores passport.authenticate-metode i routes/auth.js .
Lad os nu gå videre og tilføje den rute. Tilføj derefter en middleware for at sikre, at siden kun kan tilgås, når en bruger er logget ind på sessionen.
I vores app/visninger mappe, opretter vi en ny fil med navnet dashboard.hbs og tilføj følgende HTML-kode i den.
Pas med Sequelize Dashboard
Hurra! du er logget ind.
I routes/auth.js , tilføjer vi denne linje i modul.exports blokere:
app.get('/dashboard',authController.dashboard);
Dernæst går vi til app/controllers/authController.js og tilføj dashboard-controlleren.
exports.dashboard =function(req, res) { res.render('dashboard');} Din AuthController.js skulle se sådan ud:
var exports =modul.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, og prøv at tilmelde dig med en anden e-mailadresse end den, du brugte tidligere. Du bliver korrekt omdirigeret til /dashboardet rute.
Men /dashboard er ikke en beskyttet rute, hvilket betyder, at selvom en bruger ikke er logget ind, kan de se den. Vi ønsker ikke dette, så vi tilføjer en /logout rute for at logge brugeren af, og derefter beskytte ruten og teste, hvad vi har gjort.
Lad os gøre dette:
I routes/auth.js vi tilføjer denne linje:
app.get('/logout',authController.logout);
Derefter tilføjer vi controlleren i app/controllers/authController.js.
exports.logout =function(req, res) { req.session.destroy(function(err) { res.redirect('/'); }); } Kør nu appen igen, og tilmeld dig med en anden e-mailadresse.
Besøg derefter http://localhost:5000/logout for at logge brugeren ud. Besøg nu http://localhost:5000/dashboard.
Du vil bemærke, at det er ret tilgængeligt. Lad os tilføje en tilpasset middleware for at beskytte den rute.
For at gøre dette åbner vi app/routes/auth.js og tilføje denne funktion i module.exports blok, under alle de andre kodelinjer.
function isLoggedIn(req, res, next) { if (req.isAuthenticated()) return next(); res.redirect('/signin');} Derefter ændrer vi dashboard-rutehandleren til at se sådan ud:
app.get('/dashboard',isLoggedIn, authController.dashboard);
Når du nu kører appen igen og prøver at besøge dashboard-siden, og du ikke er logget ind, skulle du blive omdirigeret til login-siden.
Puha! Det er tid til at implementere den sidste del:login.
Først tilføjer vi en ny lokal strategi for login i app/config/passport/passport.js .
//LOCAL SIGNINpassport.use('local-signin', new LocalStrategy( {// som standard bruger lokal strategi brugernavn og adgangskode, vi vil tilsidesætte med e-mail brugernavnField:'email', passwordField:'password', passReqToCallback :sand // giver os mulighed for at sende hele anmodningen tilbage til tilbagekaldet }, function(req, email, password, done) { var User =user; var isValidPassword =function(userpass, password) { return bCrypt.compareSync(password, userpass); } User.findOne({ where:{ email:email } }).then(function(user) { if (!user) { return done(null, false, { message:'Email exists not exist' }); } if (!isValidPassword(user.password, password)) { return done(null, false, { message:'Forkert adgangskode.' }); } var brugerinfo =bruger. få(); return done(null, brugerinfo); }).catch(function(err) { console.log("Fejl:", err); return done(null, false, { message:'Noget gik galt med dit login' }); }); }));
I denne strategi er isValidPassword funktion sammenligner adgangskoden, der er indtastet med bCrypt-sammenligningsmetoden, da vi gemte vores adgangskode med bcrypt .
Hvis detaljerne er korrekte, vil vores bruger blive logget ind.
Gå nu til routes/auth.js og tilføj ruten for indlæg til / log på.
app.post('/signin', passport.authenticate('local-signin', { successRedirect:'/dashboard', failureRedirect:'/signin' })); Dine routes/auth.js skulle se sådan ud, når du er færdig.
var authController =require('../controllers/authcontroller.js');module.exports =function(app, pas) { 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 og prøv at logge ind. Du burde kunne logge ind med alle de oplysninger, du brugte, da du tilmeldte dig, og du vil blive dirigeret til http ://localhost:5000/dashboard/.
Tillykke, hvis du nåede til slutningen af denne tutorial! Vi har med succes brugt Sequelize og Passport med en MySQL-database.
Den fulde kode til denne øvelse kan findes på GitHub.