Share
Sequelize is een op belofte gebaseerde Node.js ORM. Het kan worden gebruikt met PostgreSQL, MySQL, MariaDB, SQLite en MSSQL. In deze zelfstudie zullen we authenticatie implementeren voor gebruikers van een webapp. En we zullen Passport, de populaire authenticatie-middleware voor Node, samen met Sequelize en MySQL gebruiken om gebruikersregistratie en login te implementeren.
Zorg ervoor dat u het volgende op uw computer hebt geïnstalleerd:
Voor deze zelfstudie gebruiken we Node.js samen met Express, dus we gaan door met installeren wat we nodig hebben.
Maak een map voor uw app. In deze map voert u dit uit vanaf uw terminal of opdrachtprompt:
npm init
Dit initialiseert de npm Dependency Manager. Dit zal een reeks aanwijzingen bevatten die we snel zullen doornemen.
De belangrijkste afhankelijkheden voor deze zelfstudie zijn:
Om ze te installeren, voert u de volgende na elkaar uit vanaf uw terminal of opdrachtprompt.
npm installeren expresse --save npm install sequelize --save npm install mysql --save npm install passport --save npm install passport-local --save npm install body-parser - opslaan npm installeren express-sessie - opslaan npm installeren bcrypt-nodejs --save npm installeren expressturen - opslaan
Als je Git voor dit project gebruikt:
Maak een .gitignore-bestand in de projectmap.
Voeg deze regel toe aan het .gitignore-bestand.
node_modules
Nu maken we een serverbestand. Dit wordt het hoofdbestand genoemd wanneer u het volgende typt:
npm start
Hiermee wordt de app uitgevoerd. U kunt de app ook uitvoeren door knooppunt server.js te typen.
knooppunt server.js
Vervolgens maken we in onze projectmap een nieuw bestand en noemen we dit bestand server.js.
Binnen in de server.js bestand, plakken we het volgende:
Accentsconagua
var express = require ('express'); var app = express (); app.get ('/', functie (req, res) res.send ('Welcome to Passport with Sequelize');); app.listen (5000, functie (err) if (! err) console.log ("Site is live"); else console.log (err));De eerste regel wijst de expressmodule toe aan een variabele express. Vervolgens initialiseren we express en noemen het een variabele: app.
Vervolgens maken we de app naar de poort luisteren 5000. U kunt elk vrij poortnummer op uw computer kiezen.
Vervolgens noemen we de app.get () express routing-functie om te reageren met "Welcome to Passport with Sequelize" wanneer een GET-verzoek wordt gedaan naar "/".
Om dit op uw computer te testen, voert u dit vanuit uw projectmap uit:
knooppunt server.js
Als u de tekst "Welcome to Passport with Sequelize" ziet wanneer u http: // localhost: 5000 / bezoekt, dan wordt gefeliciteerd! Controleer anders of u alles precies hebt gedaan zoals het hierboven is beschreven.
Vervolgens importeren we enkele modules die we nodig hebben, zoals paspoort, express-sessie en body-parser.
Na var app = express () we voegen de volgende regels toe:
var passport = require ('passport') var session = require ('express-session') var bodyParser = require ('body-parser')In de eerste twee regels importeren we de paspoortmodule en de express-sessie, die we allebei moeten verwerken.
Vervolgens importeren we de body-parser-module. Hiermee wordt het gehele lichaamsdeel van een binnenkomend verzoek geëxtraheerd en weergegeven in een formaat dat gemakkelijker is om mee te werken. In dit geval zullen we het JSON-formaat gebruiken.
Om onze app de body-parser te laten gebruiken, voegen we deze regels enkele spaties toe onder de importregels:
// Voor BodyParser app.use (bodyParser.urlencoded (extended: true)); app.use (bodyParser.json ());
Vervolgens initialiseren we het paspoort en de sessie voor expresessies en paspoorten en voegen deze beide toe als middleware. We doen dit door deze regels enkele spaties toe te voegen na de bodyParser-importregel.
// Voor paspoort app.use (sessie (geheim: 'keyboard cat', resave: true, saveUninitialized: true)); // session secret app.use (passport.initialize ()); app.use (passport.session ()); // aanhoudende login-sessies
We gaan nu aan de daadwerkelijke authenticatie werken.
We doen dit in vier stappen:
Eerst maken we een database in MySQL. Geef het uw gewenste naam. Laten we omwille van deze tutorial een database maken met de naam sequelize_passport in MySQL.
Vervolgens stellen we de configuratie in voor het verwerken van DB-gegevens.
Laten we eerst de dot-env-module importeren om omgevingsvariabelen te verwerken.
Voer dit uit in uw root-projectmap:
npm install - sla dotenv op
Vervolgens importeren we het in het hoofdserverbestand, server.js, net onder de andere invoer.
var env = require ('dotenv'). load (); Vervolgens maken we een bestand in onze projectmap en noemen het .env.
De volgende te volgen stap is optioneel als je Git niet gebruikt:
We zullen het .env-bestand toevoegen aan uw .gitignore-bestand.
Uw .gitignore-bestand zou er als volgt uit moeten zien:
node_modules .env
Hierna voegen we onze omgeving toe aan het .env-bestand door deze regel toe te voegen:
NODE_ENV = 'ontwikkeling'
Vervolgens maken we een config.json-bestand dat door Sequelize wordt gebruikt om verschillende omgevingen te beheren.
Het eerste dat u moet doen is een map met de naam maken config in onze projectmap. In deze map maken we een config.json het dossier. Dit bestand zou genegeerd moeten worden als je naar een repository pusht. Om dit te doen, voeg de volgende code toe aan uw .gitignore:
config / config.json
Vervolgens plakken we de volgende code in ons config.json-bestand.
"ontwikkeling": "gebruikersnaam": "root", "wachtwoord": null, "database": "sequelize_passport", "host": "127.0.0.1", "dialect": "mysql", "test" : "gebruikersnaam": "", "wachtwoord": null, "database": "", "host": "", "dialect": "mysql", "productie": "gebruikersnaam": "", "wachtwoord": null, "database": "", "host": "127.0.0.1", "dialect": "mysql"
Vergeet niet om de waarden in het bovenstaande ontwikkelblok te vervangen door uw database-authenticatiegegevens.
Vervolgens installeren we sequelize met npm. Hiertoe voert u de volgende opdracht uit in de hoofdmap van het project:
npm installeren - opslaan opslaan
Nu is het tijd om het te maken modellen map.
Eerst maken we een map met de naam app in onze projectmap.
Binnen in de app map maken we een nieuwe map met de naam modellen en maak een nieuw bestand met de naam index.js in de modellen map.
In het bestand index.js plakken we de onderstaande code.
"gebruik strikt"; var fs = require ("fs"); var path = require ("path"); var Sequelize = require ("sequelize"); var env = process.env.NODE_ENV || "ontwikkeling"; 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 (functie (bestand) return (file.indexOf (".")! == 0) && (file! == "index.js");) .forElke (functie (bestand ) var model = sequelize.import (path.join (__ dirname, bestand)); db [model.name] = model;); Object.keys (db) .forElke (functie (modelnaam) if ("associate" in db [modelnaam]) db [modelnaam] .associate (db);); db.sequelize = sequelize; db.Sequelize = Sequelize; module.exports = db;Dit bestand wordt gebruikt om alle modellen te importeren die we in de modellen map en exporteer ze.
Om te testen of alles in orde is, voegen we dit toe aan ons server.js-bestand.
// Modellen var models = require ("./ app / models"); // Sync Database models.sequelize.sync (). Then (function () console.log ('Nice! -Database ziet er goed uit')). Catch (functie (err) console.log (err, "Er is iets misgegaan met de database-update! "));Hier importeren we de modellen en daarna de synchronisatiefunctie Sequelize.
Voer dit uit om te zien of alles in orde is:
knooppunt server.js
Als je het bericht krijgt "Site is live, Nice! Database ziet er goed uit", dan heb je Sequelize succesvol opgezet.
Als dit niet het geval is, gaat u zorgvuldig naar de bovenstaande stappen en probeert u het probleem met hulp te debuggen.
Het volgende dat we gaan doen, is het maken van het gebruikersmodel, dat in feite de gebruikerstabel is. Dit bevat elementaire gebruikersinformatie.
In onze modellen map, maken we een bestand en geven het een naam user.js. Het volledige pad voor dit bestand zou moeten zijn app / modellen / user.js.
Open het bestand user.js en voeg de volgende code toe:
module.exports = function (sequelize, Sequelize) var User = sequelize.define ('user', id: autoIncrement: true, primaryKey: true, type: Sequelize.INTEGER, voornaam: type: Sequelize.STRING, notEmpty: true, lastname: type: Sequelize.STRING, notEmpty: true, gebruikersnaam: type: Sequelize.TEXT, over: type: Sequelize.TEXT, email: type: Sequelize.STRING, valideren: isEmail: true, wachtwoord: type: Sequelize.STRING, allowNull: false, last_login: type: Sequelize.DATE, status: type: Sequelize.ENUM ('active', 'inactive'), defaultValue : 'actief' ); keer gebruiker terug; Nu uitvoeren:
knooppunt server.js
Je zou het bekende moeten zien "De site is live. Leuk! Database ziet er goed uit.Dit betekent dat onze Sequelize-modellen met succes zijn gesynchroniseerd en dat als u uw database controleert, u een gebruikers-tabel met de opgegeven kolommen zou moeten zien.
Laten we eerst de weergave maken voor aanmelding en deze aansluiten.
Het eerste dat u hoeft te doen, is het importeren van de express-stuurmodule die we gebruiken voor weergaven in deze zelfstudie.
Voeg deze regel toe aan het hoofdstartbestand, server.js.
var exphbs = vereisen ('express-stuur')
Uw importblok zou er op dit moment zo uit moeten zien.
var express = vereisen ('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')Vervolgens voegen we de volgende regels toe aan ons server.js-bestand.
// For Handlebars app.set ('views', './app/views') app.engine ('hbs', exphbs (extname: '.hbs')); app.set ('view engine', '.hbs');Nu maken we in onze app-map drie genoemde mappen keer bekeken, controllers, en routes.
In de weergavemap maken we een bestand met de naam inschrijven.hbs en plak de onderstaande code erin.
Dan in onze controllers map, maken we een nieuw bestand en geven het een naam authcontroller.js.
In dit bestand plakken we de volgende controller voor de aanmeldingsroute die we in een oogwenk maken.
var exports = module.exports = exports.signup = functie (req, res) res.render ('signup'); Vervolgens maken we een route voor aanmelding. In de map routes maken we een nieuw bestand met de naam auth.js en vervolgens importeren we in dit bestand de auth-controller en definiëren de aanmeldingsroute.
var authController = require ('... /controllers/authcontroller.js'); module.exports = functie (app) app.get ('/ signup', authController.signup); Nu importeren we deze route in onze server.js en geven we de app door als een argument.
Voeg in de server, na het importeren van de modellen, deze regels toe:
// Routes var authRoute = require ('./ app / routes / auth.js') (app);Voer dit uit:
knooppunt server.js
Ga nu naar http: // localhost: 5000 / signup en u ziet het aanmeldingsformulier.
Laten we de stappen voor het aanmeldingsformulier herhalen. Net als hiervoor maken we een bestand met de naam signin.hbs in onze views map en plak de volgende HTML-code erin:
Voeg vervolgens een controller toe voor de aanmelding app / controllers / authcontroller.js.
exports.signin = function (req, res) res.render ('signin'); Dan in app / routes / auth.js, we voegen een route toe om in te loggen als volgt:
app.get ('/ signin', authController.signin);
Nu als je loopt:
knooppunt server.js
en bezoek http: // localhost: 5000 / signin /, je zou het inlogformulier moeten zien.
De laatste en belangrijkste stap is het schrijven van onze paspoortstrategieën.
In app / config, we maken een nieuwe map met de naam paspoort.
Vervolgens maken we in onze nieuwe mapapp / config / paspoort een nieuw bestand en geven het een naam passport.js. Dit bestand bevat onze paspoortstrategieën.
In passport.js, we gebruiken het gebruikersmodel en het paspoort.
Eerst importeren we bcrypt welke we nodig hebben om wachtwoorden te beveiligen.
var bCrypt = require ('bcrypt-nodejs');
Vervolgens voegen we een blok blok.exports toe als volgt:
module.exports = functie (paspoort, gebruiker)
In dit blok initialiseren we de paspoort-lokale strategie en het gebruikersmodel, dat als een argument zal worden doorgegeven. Dit doen we als volgt:
module.exports = functie (paspoort, gebruiker) var Gebruiker = gebruiker; var LocalStrategy = require ('passport-local'). Strategie; Vervolgens definiëren we onze aangepaste strategie met onze instantie van LocalStrategy als volgt:
passport.use ('local-signup', new LocalStrategy (usernameField: 'email', passwordField: 'password', passReqToCallback: true // stelt ons in staat om het hele verzoek terug te sturen naar de callback,));Nu hebben we verklaard welk verzoek (req) Velden onze gebruikersnaam Veld en wachtwoord Veld (paspoortvariabelen) zijn.
Met de laatste variabele passReqToCallback kunnen we het hele verzoek doorgeven aan de callback, wat met name handig is bij het aanmelden.
Na de laatste komma voegen we deze callback-functie toe.
functie (verplicht, e-mail, wachtwoord, klaar)
In deze functie zullen we omgaan met het opslaan van de gegevens van een gebruiker.
Eerst voegen we onze gehashte wachtwoordgenererende functie toe aan de callback-functie.
var generateHash = function (wachtwoord) return bCrypt.hashSync (wachtwoord, bCrypt.genSaltSync (8), null); ;
Vervolgens gebruiken we het gebruikersmodel van Sequelize dat we eerder als geïnitialiseerd hebben geïnitialiseerd Gebruiker, we controleren om te zien of de gebruiker al bestaat, en zo niet, dan voegen we ze toe.
User.findOne (where: email: email). Then (function (user) if (user) return done (null, false, message: 'That email is already takes'); else var userPassword = generateHash (wachtwoord); var data = email: email, wachtwoord: userPassword, voornaam: req.body.firstname, lastname: req.body.lastname; User.create (data) .then (function (newUser, gemaakt) if (! newUser) return done (null, false); if (newUser) return done (null, newUser);););
User.create () is een Sequelize-methode voor het toevoegen van nieuwe items aan de database. Merk op dat de waarden in de gegevens object is verkregen van de req.body object dat de invoer van ons aanmeldingsformulier bevat.
Jouw passport.js zou er als volgt uit moeten zien:
// load bcrypt var bCrypt = require ('bcrypt-nodejs'); module.exports = functie (paspoort, gebruiker) var Gebruiker = gebruiker; var LocalStrategy = require ('passport-local'). Strategie; passport.use ('local-signup', new LocalStrategy (usernameField: 'email', passwordField: 'password', passReqToCallback: true // stelt ons in staat het volledige verzoek door te geven aan de callback, functie (aanvullen, e-mailen, wachtwoord, klaar) var generateHash = function (wachtwoord) return bCrypt.hashSync (wachtwoord, bCrypt.genSaltSync (8), null);; User.findOne (where: email: email) then (function (gebruiker) if (gebruiker) return done (null, false, message: 'Die e-mail is al in gebruik'); else var userPassword = generateHash (wachtwoord); var data = email: email, wachtwoord: userPassword, voornaam: req.body.firstname, achternaam: req.body.lastname; User.create (data) .then (function (newUser, created) if (! newUser) return done (null, false); if (newUser) return done (null, newUser);););)); Nu zullen we de strategie importeren server.js.
Om dit te doen, voegen we deze regels toe onder de routes die worden geïmporteerd server.js.
// laad paspoortstrategieën vereisen ('./ app / config / passport / passport.js') (paspoort, models.user);Uw server.js zou er op dit moment zo uit moeten zien:
var express = vereisen ('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') // Voor BodyParser app.use (bodyParser.urlencoded (extended: true)); app.use (bodyParser.json ()); // Voor paspoort app.use (sessie (geheim: 'keyboard cat', resave: true, saveUninitialized: true)); // session secret app.use (passport.initialize ()); app.use (passport.session ()); // aanhoudende login-sessies // Voor stuur app.set ('views', './app/views') app.engine ('hbs', exphbs (extname: '.hbs')); app.set ('view engine', '.hbs'); app.get ('/', functie (req, res) res.send ('Welcome to Passport with Sequelize');); // Modellen var models = require ("./ app / models"); // Routes var authRoute = require ('./ app / routes / auth.js') (app); // laad paspoortstrategieën vereisen ('./ app / config / passport / passport.js') (paspoort, models.user); // Sync Database models.sequelize.sync (). Then (function () console.log ('Nice! -Database ziet er goed uit')). Catch (functie (err) console.log (err, "Er is iets misgegaan met de database-update! ")); app.listen (5000, functie (err) if (! err) console.log ("Site is live"); else console.log (err));Nu zullen we de strategie daadwerkelijk toepassen op onze /inschrijven route.
Dit doen we als volgt:
Eerst gaan we naar app / routes / auth.js, en voeg op deze manier een route toe om te posten om in te loggen.
app.post ('/ signup', passport.authenticate ('local-signup', succesRedirect: '/ dashboard', failureRedirect: '/ signup'));Omdat we een paspoort nodig hebben, moeten we het doorgeven aan deze methode. We kunnen het paspoort importeren in dit script of doorgeven aan server.js. Laten we het laatste doen.
Wijzig de functie die in dit bestand is geëxporteerd app / routes / auth.js een paspoort als parameter hebben. De code in app / routes / auth.js zou er na uw aanpassing zo uit moeten zien.
var authController = require ('... /controllers/authcontroller.js'); module.exports = functie (app, paspoort) app.get ('/ signup', authController.signup); app.get ('/ signin', authController.signin); app.post ('/ signup', passport.authenticate ('local-signup', succesRedirect: '/ dashboard', failureRedirect: '/ signup')); Dan in server.js, we wijzigen de routesimport en voegen het paspoort toe als een argument als dit:
var authRoute = vereisen ('./ app / routes / auth.js') (app, paspoort);
Ga nu naar de aanmeldings-URL http: // localhost: 5000 / signup / en probeer u aan te melden.
Wanneer u zich probeert aan te melden, krijgt u een foutmelding "Kan gebruiker niet in sessie serialiserenDit komt omdat het paspoort een gebruikers-ID in de sessie moet opslaan en het gebruikt dit om het ophalen van de gebruikersgegevens te beheren wanneer dat nodig is.
Om dit op te lossen, gaan we zowel de serialize- als deserialize-functies van het paspoort implementeren in onze app / config / paspoort / passport.js het dossier.
Eerst voegen we de functie serialize toe. In deze functie bewaren we de gebruikersnaam naar de sessie.
Om dit te doen voegen we de volgende regels toe onder de initialisatie van de lokale strategie.
// serialize passport.serializeUser (function (user, done) done (null, user.id););
Vervolgens implementeren we de deserialize-functie. Voeg de functie toe net onder de serialize-functie.
// deserialize user passport.deserializeUser (function (id, done) User.findById (id) .then (function (user) if (user) done (null, user.get ()); else done ( user.errors, null);););
In de deserialize-functie hierboven gebruiken we de Sequelize findById beloven om de gebruiker te krijgen, en als dit lukt, wordt een exemplaar van het Sequelize-model geretourneerd. Om het User-object van dit exemplaar te krijgen, gebruiken we de Sequelize-getterfunctie als volgt: user.get ().
Ren nu opnieuw:
knooppunt server.js
En probeer je aan te melden. Hoera als je het "Can not GET / dashboard" niet hebt! Het betekent dat onze authenticatie succesvol was. Vergeet niet dat we doorgestuurd zijn naar / dashboard in onze paspoort.authenticatiemethode in routes / auth.js.
Laten we nu doorgaan en die route toevoegen. Voeg vervolgens een middleware toe om ervoor te zorgen dat de pagina alleen kan worden geopend wanneer een gebruiker is aangemeld bij de sessie.
In onze app / views map, maken we een nieuw bestand met de naam dashboard.hbs en voeg de volgende HTML-code erin toe.
Paspoort met Sequelize Dashboard
Hoera! je bent ingelogd.
In routes / auth.js, we voegen deze regel toe binnen de module.exports blok:
app.get ( '/ dashboard', authController.dashboard);
Vervolgens gaan we naar app / controllers / authController.js en voeg de dashboardcontroller toe.
exports.dashboard = function (req, res) res.render ('dashboard'); Uw AuthController.js zou er als volgt uit moeten zien:
var exports = module.exports = exports.signup = functie (req, res) res.render ('signup'); exports.signin = functie (req, res) res.render ('signin'); exports.dashboard = function (req, res) res.render ('dashboard'); Voer de app opnieuw uit en probeer u aan te melden met een ander e-mailadres dan het e-mailadres dat u eerder hebt gebruikt. Je wordt op de juiste manier doorgestuurd naar de /dashboard route.
Maar /dashboard is geen beschermde route, wat betekent dat zelfs als een gebruiker niet is aangemeld, deze deze kan zien. We willen dit niet, dus we voegen er een toe /uitloggen route om de gebruiker uit te loggen en vervolgens de route te beveiligen en te testen wat we hebben gedaan.
Laten we dit doen:
In routes / auth.js we voegen deze regel toe:
app.get ( '/ uitloggen', authController.logout);
Vervolgens voegen we de controller toe in app / controllers / authController.js.
exports.logout = function (req, res) req.session.destroy (function (err) res.redirect ('/');); Voer de app opnieuw uit en meld u aan met een ander e-mailadres.
Ga daarna naar http: // localhost: 5000 / logout om de gebruiker uit te loggen. Ga nu naar http: // localhost: 5000 / dashboard.
Je zult merken dat het vrij toegankelijk is. Laten we een aangepaste middleware toevoegen om die route te beschermen.
Om dit te doen, openen we app / routes / auth.js en voeg deze functie toe in de module.exports blokkeren, onder alle andere coderegels.
function isLoggedIn (req, res, next) if (req.isAuthenticated ()) return next (); res.redirect ( '/ signin);
Vervolgens wijzigen we de routleerder van het dashboard om er zo uit te zien:
app.get ('/ dashboard', isLoggedIn, authController.dashboard);
Wanneer u de app opnieuw uitvoert en probeert de dashboardpagina te bezoeken en u bent niet aangemeld, moet u worden omgeleid naar de inlogpagina.
Oef! Het is tijd om het laatste deel te implementeren: het inloggen.
Eerst voegen we een nieuwe lokale strategie toe om in te loggen app / config / paspoort / passport.js.
// LOCAL SIGNIN passport.use ('local signin', new LocalStrategy (// standaard, lokale strategie gebruikt gebruikersnaam en wachtwoord, we zullen overschrijven met email gebruikersnaam Field: 'email', passwordField: 'password', passReqToCallback: true // stelt ons in staat om het volledige verzoek door te geven aan de callback, functie (verplicht, e-mail, wachtwoord, gereed) var User = user; var isValidPassword = function (userpass, password) return bCrypt.compareSync (wachtwoord, userpass) ; User.findOne (where: email: email) then (function (user) if (! User) return done (null, false, message: 'Email does not exist'); if (! isValidPassword (user.password, password)) return done (null, false, message: 'Incorrect password.'); var userinfo = user.get (); return done (null, userinfo); ). catch (functie (err) console.log ("Fout:", err); return done (null, false, message: 'Er is iets misgegaan met uw aanmelding';);));In deze strategie, deisValidPasswordfunctie vergelijkt het wachtwoord dat is ingevoerd met de bCrypt vergelijkingsmethode sinds we ons wachtwoord hebben opgeslagen met bcrypt.
Als de gegevens juist zijn, wordt onze gebruiker ingelogd.
Ga nu naar routes / auth.js en voeg de route toe voor verzending naar /aanmelden.
app.post ('/ signin', passport.authenticate ('local-signin', succesRedirect: '/ dashboard', failureRedirect: '/ signin'));Uw routes / auth.js moeten er als volgt uitzien als u klaar bent.
var authController = require ('... /controllers/authcontroller.js'); module.exports = functie (app, paspoort) app.get ('/ signup', authController.signup); app.get ('/ signin', authController.signin); app.post ('/ signup', passport.authenticate ('local-signup', succesRedirect: '/ dashboard', failureRedirect: '/ signup')); app.get ('/ dashboard', isLoggedIn, authController.dashboard); app.get ('/ logout', authController.logout); app.post ('/ signin', passport.authenticate ('local-signin', succesRedirect: '/ dashboard', failureRedirect: '/ signin')); function isLoggedIn (req, res, next) if (req.isAuthenticated ()) return next (); res.redirect ( '/ signin); Start nu de app en probeer in te loggen. U moet zich kunnen aanmelden met de gegevens die u heeft gebruikt toen u zich aanmeldde, en u wordt doorgestuurd naar http: // localhost: 5000 / dashboard /.
Gefeliciteerd als je het einde van deze tutorial hebt gehaald! We hebben met succes Sequelize en Passport met een MySQL-database gebruikt.
De volledige code voor deze tutorial is te vinden op GitHub.
Dit concludeert onze tutorial over het gebruik van paspoort voor authenticatie van gebruikers met Sequelize en MySQL. Sequelize is een zeer nuttige ORM voor het omgaan met MySQL bij het gebruik van Node. Ik vond het persoonlijk erg nuttig, en je zou zeker moeten overwegen om het te gebruiken in je volgende Node-MySQL-app.
