Share
Sequelize er et løftebasert Node.js ORM. Den kan brukes med PostgreSQL, MySQL, MariaDB, SQLite og MSSQL. I denne opplæringen vil vi implementere godkjenning for brukere av en webapp. Og vi vil bruke Passport, den populære autentiseringsvarevaren for Node, sammen med Sequelize og MySQL for å implementere brukerregistrering og logg inn.
Pass på at du har installert følgende på maskinen:
For denne opplæringen bruker vi Node.js sammen med Express, så vi går videre og begynner å installere det vi trenger.
Opprett en katalog for appen din. I denne katalogen kjører du dette fra din terminal eller kommandoprompt:
npm init
Dette initialiserer npm Dependency Manager. Dette vil presentere en rekke spørsmål som vi raskt vil gå gjennom.
De store avhengighetene for denne opplæringen er:
For å installere dem, fra din terminal eller kommandoprompt, kjør følgende etter hverandre.
npm installere express - lagre npm installere fortsette - lagre npm installere mysql - save npm installere pass - lagre npm installere pass-lokal - lagre npm installere body-parser - lagre npm installere ekspress-session - lagre npm installere bcrypt-nodejs - save npm installere ekspedisjonshåndtak - lagre
Hvis du bruker Git for dette prosjektet:
Opprett en .gitignore-fil i prosjektmappen din.
Legg til denne linjen i .gitignore-filen.
node_modules
Nå lager vi en serverfil. Dette blir hovedfilen som kalles når du skriver inn følgende:
npm start
Dette kjører appen. Du kan også kjøre appen ved å skrive node server.js.
node server.js
Deretter lager vi i vår prosjektmappe en ny fil og heter denne filen server.js.
Inne i server.js fil, limer vi inn følgende:
Accentsconagua
var express = kreve ('express'); var app = express (); app.get ('/', funksjon (req, res) res.send ('Velkommen til Pass med Sequelize');); app.listen (5000, funksjon (err) hvis (! err) console.log ("Site er live"); annet console.log (err));Den første linjen tilordner ekspressmodulen til en variabel uttrykk. Vi initierer så ekspres og kaller det en variabel: app.
Deretter la vi app lytte på port 5000. Du kan velge et gratis portnummer på datamaskinen din.
Deretter kaller vi app.get () Express routing-funksjon for å svare med "Velkommen til Passport med Sequelize" når en GET-forespørsel blir gjort til "/".
For å teste på datamaskinen din, kjør dette fra innsiden av prosjektmappen din:
node server.js
Hvis du ser teksten "Velkommen til Pass med Sequelize" når du besøker http: // localhost: 5000 / så gratulerer! Ellers må du kontrollere at du har gjort alt akkurat som det er skrevet over.
Deretter importerer vi noen moduler vi trenger, for eksempel pass, express-økt og kroppsparser.
Etter var app = express () vi legger til følgende linjer:
var pass = krever ('pass') var session = krever ('express-session') var bodyParser = krever ('body-parser')I de to første linjene importerer vi passmodulen og ekspressperioden, som vi begge må håndtere godkjenning.
Deretter importerer vi kroppsparsermodulen. Dette trekker ut hele kroppsdelen av en innkommende forespørsel og avslører den i et format som er lettere å jobbe med. I dette tilfellet bruker vi JSON-formatet.
For å la appen bruke kroppsparseren, legger vi til disse linjene noen mellomrom under importlinjene:
// For BodyParser app.use (bodyParser.urlencoded (extended: true)); app.use (bodyParser.json ());
Deretter initialiserer vi pass og ekspress økt og pass økt og legger dem til som mellomvare. Vi gjør dette ved å legge til disse linjene noen mellomrom etter kroppenParser-importlinjen.
// For Pass app.use (økt (hemmelig: 'keyboard cat', resave: true, saveUnitialized: true)); // økt hemmelig app.use (passport.initialize ()); app.use (passport.session ()); // vedvarende påloggingsøkter
Vi vil begynne å jobbe med selve autentiseringen nå.
Vi gjør dette i fire trinn:
Først oppretter vi en database i MySQL. Gi det ditt foretrukne navn. For denne tutorials skyld, la oss lage en database som heter sequelize_passport i MySQL.
Da setter vi opp konfigurasjonen for å håndtere DB-detaljer.
Først, la oss importere dot-env-modulen for å håndtere miljøvariabler.
Kjør dette i din rotte prosjektmappe:
npm installere - lagre dotenv
Deretter importerer vi den i hovedserverfilen server.js, like under den andre importen.
var env = krever ('dotenv'). last (); Deretter lager vi en fil i vår prosjektmappe og heter den .env.
Dette neste trinnet som følger er valgfritt hvis du ikke bruker Git:
Vi legger til .env-filen i din .gitignore-fil.
Din .gitignore-fil skal se slik ut:
node_modules .env
Etter dette legger vi miljøet vårt til .env-filen ved å legge til denne linjen:
NODE_ENV = 'utvikling'
Deretter oppretter vi en config.json-fil som vil bli brukt av Sequelize for å administrere forskjellige miljøer.
Det første du må gjøre er å opprette en mappe som heter config i vår prosjektmappe. I denne mappen oppretter vi en config.json fil. Denne filen bør ignoreres hvis du skyver til et lager. For å gjøre dette, legg til følgende kode i din .gitignore:
config / config.json
Deretter limer vi inn følgende kode i vår config.json-fil.
"brukernavn": "root", "passord": null, "database": "sequelize_passport", "vert": "127.0.0.1", "dialekt": "mysql", "test" : "", "dialekt": "mysql", "produksjon": "brukernavn": "", "brukernavn": "", "passord" "passord": null, "database": "", "vert": "127.0.0.1", "dialekt": "mysql"
Husk å erstatte verdiene i utviklingsblokken ovenfor med databasegodkjenningsdetaljer.
Deretter installerer vi fortsetter med npm. For å gjøre dette, kjør følgende kommando i prosjektets rotmappe:
npm installere - lagre fortsette
Nå er det på tide å lage modeller mappe.
Først lager vi en katalog som heter app i vår prosjektmappe.
Inne i app mappe, oppretter vi en ny mappe som heter modeller og opprett en ny fil som heter index.js i modeller mappe.
Inne i index.js-filen limer vi inn koden nedenfor.
"bruk strenge"; var fs = krever ("fs"); var sti = krever ("sti"); var Sequelize = krever ("oppfølg"); var env = prosess.env.NODE_ENV || "utvikling"; var config = krever (path.join (__ dirname, '...', 'config', 'config.json')) [env]; var sequelize = ny Sequelize (config.database, config.username, config.password, config); var db = ; fs .readdirSync (__ dirname) .filter (funksjon (fil) return (file.indexOf ("."! == 0) && (fil! == "index.js");) .forEach (funksjon ) var model = sequelize.import (path.join (__ dirname, fil)); db [model.name] = model;); Object.keys (db) .forEach (funksjon (modellnavn) if ("associate" i db [modelName]) db [modelName] .associate (db);); db.sequelize = oppfølg; db.Sequelize = Sequelize; module.exports = db;Denne filen brukes til å importere alle modellene vi plasserer i modeller mappe og eksportere dem.
For å teste at alt er bra, legger vi til dette i vår server.js-fil.
// Modeller var modeller = krever ("./app / models"); // Synkroniser databaser.sequelize.sync (). Deretter (funksjon () console.log ('Nice! Database ser bra ut')). Catch (funksjon (err) console.log (feil, "Noe gikk galt med databaseoppdateringen! "));Her importerer vi modellene, og kaller deretter Sequelize sync-funksjonen.
Kjør dette for å se om alt er bra:
node server.js
Hvis du får meldingen "Site is live Nice! Database ser bra ut", så har du satt opp Sequelize successfully.
Hvis ikke, vennligst gå forsiktig over trinnene ovenfor og prøv å feilsøke problemet med hjelp.
Den neste tingen vi skal gjøre er å lage brukermodellen, som egentlig er brukertabellen. Dette vil inneholde grunnleggende brukerinformasjon.
I vår modeller mappe, lager vi en fil og heter den user.js. Den fullstendige banen for denne filen skal være app / modeller / user.js.
Åpne user.js-filen og legg til følgende kode:
module.exports = funksjon (fortsett, Sequelize) var Bruker = sequelize.define ('bruker', id: autoIncrement: true, primaryKey: true, type: Sequelize.INTEGER, fornavn: type: Sequelize.STRING, notEmpty: true, etternavn: type: Sequelize.STRING, ikkeEmpty: true, brukernavn: type: Sequelize.TEXT, om: type: Sequelize.TEXT, email: type: Sequelize.STRING, validere: isEmail: true, passord: type: Sequelize.STRING, allowNull: false, last_login: type: Sequelize.DATE, status: type: Sequelize.ENUM ('aktiv', 'inaktiv'), defaultValue : 'aktiv'); retur bruker; Kjør nå:
node server.js
Du bør se den kjente "Nettstedet er live. Hyggelig! database ser bra ut.". Dette betyr at våre Sequelize-modeller har blitt synkronisert med hell, og hvis du sjekker databasen, bør du se en brukertabell med de angitte kolonner.
Først, la oss lage visningen for registrering og koble den opp.
Det første du må gjøre er å importere ekspreshåndtaksmodulen som vi bruker til visning i denne opplæringen.
Legg til denne linjen i hovedstartfilen, server.js.
var exphbs = krever ("ekspresstyre")
Importblokken din skal se slik ut på dette punktet.
var ekspres = kreve (ekspres) var var app = ekspres () var pass = krever (pass) var økt = krever ('express-økt') var bodyParser = krever ('body-parser') var env = krever ('dotenv'). last () var exphbs = krever ('ekspresstyre')Deretter legger vi til følgende linjer i vår server.js-fil.
// For Handlebars app.set ('views', './app/views') app.engine ('hbs', exphbs (extname: '.hbs')); app.set ('view engine', '. hbs');Nå, i vår appmappe, oppretter vi tre mapper som heter visninger, kontrollere, og ruter.
I visningsmappen lager vi en fil som heter melde deg på.hbs og lim inn koden nedenfor i den.
Så i vår kontrollere mappe, lager vi en ny fil og heter den authcontroller.js.
I denne filen limer vi inn følgende kontroller for registreringsruten som vi vil opprette om et øyeblikk.
var exports = module.exports = exports.signup = funksjon (req, res) res.render ('signup'); Deretter oppretter vi en rute for registrering. I rutemappen lager vi en ny fil som heter auth.js og deretter, i denne filen, importerer vi auth-kontrolleren og definerer registreringsruten.
var authController = krever ('... /controllers/authcontroller.js'); module.exports = funksjon (app) app.get ('/ signup', authController.signup); Nå importerer vi denne ruten i server.js og sender appen som et argument.
I serveren, etter at modellene importerer, legger du til disse linjene:
// Ruter var authRoute = krever ('./app / routes / auth.js') (app);Kjør dette:
node server.js
Nå, besøk http: // localhost: 5000 / signup og du vil se påmeldingsskjemaet.
La oss gjenta trinnene for påmeldingsskjemaet. Som før skal vi opprette en fil som heter signin.hbs i vår visningsmappe og lim inn følgende HTML-kode i den:
Deretter legger du til en kontroller for påloggingen i app / kontrollere / authcontroller.js.
exports.signin = funksjon (req, res) res.render ('signin'); Så i app / ruter / auth.js, Vi legger til en rute for pålogging som denne:
app.get ('/ signin', authController.signin);
Nå når du kjører:
node server.js
og besøk http: // localhost: 5000 / signin /, du bør se påloggingsskjemaet.
Det endelige og store skrittet er å skrive våre passstrategier.
I app / config, vi oppretter en ny mappe som heter pass.
Deretter i vår nye mappe app / config / pass, oppretter vi en ny fil og navngir den passport.js. Denne filen inneholder våre passstrategier.
I passport.js, Vi bruker brukermodellen og passet.
Først importerer vi bcrypt som vi trenger for å sikre passord.
var bCrypt = krever ('bcrypt-nodejs');
Deretter legger vi til en module.exports-blokk slik:
module.exports = funksjon (pass, bruker)
Innenfor denne blokken, initierer vi passport-lokalstrategien, og brukermodellen, som blir bestått som et argument. Slik gjør vi dette:
module.exports = funksjon (pass, bruker) var Bruker = bruker; var LocalStrategy = krever ('pass-lokal'). Strategi; Deretter definerer vi vår tilpassede strategi med vår forekomst av LocalStrategy slik:
passport.use ('lokal registrering', ny LocalStrategy (brukernavnField: 'email', passwordField: 'passord', passReqToCallback: true // tillater oss å sende tilbake hele forespørselen til tilbakekallingen,));Nå har vi erklært hvilken forespørsel (req) Feltene våre brukernavnField og passordField (pass variabler) er.
Den siste variabelen passReqToCallback tillater oss å sende hele forespørselen til tilbakekallingen, noe som er spesielt nyttig for å registrere deg.
Etter siste komma, legger vi til denne tilbakeringingsfunksjonen.
funksjon (req, e-post, passord, ferdig)
I denne funksjonen vil vi håndtere lagring av brukerens detaljer.
Først legger vi til vår hashed-passordgenereringsfunksjon inne i tilbakeringingsfunksjonen.
var generateHash = funksjon (passord) return bCrypt.hashSync (passord, bCrypt.genSaltSync (8), null); ;
Deretter ble vi initialisert tidligere som bruker Sequelize brukermodellen Bruker, vi sjekker om brukeren allerede eksisterer, og hvis ikke legger vi til dem.
User ff (): da: (e-post: e-post)), deretter (funksjon (bruker) var userPassword = generateHash (passord); var data = email: email, passord: userPassword, fornavn: req.body.firstname, etternavn: req.body.lastname; User.create (data) .then (funksjon (newUser, opprettet) if (! newUser) return done (null, false); if (newUser) return done (null, newUser);););
User.create () er en Sequelize-metode for å legge til nye oppføringer i databasen. Legg merke til at verdiene i data objekt er hentet fra req.body objekt som inneholder innspillet fra vårt registreringsskjema.
Din passport.js skal se slik ut:
// load bcrypt var bCrypt = krever ('bcrypt-nodejs'); module.exports = funksjon (pass, bruker) var Bruker = bruker; var LocalStrategy = krever ('pass-lokal'). Strategi; passport.use ('lokal registrering', ny LocalStrategy (brukernavnField: 'email', passwordField: 'passord', passReqToCallback: true // tillater oss å sende tilbake hele forespørselen til tilbakeringingen, funksjon (req, e- passord, ferdig) var generateHash = funksjon (passord) return bCrypt.hashSync (passord, bCrypt.genSaltSync (8), null);; User.findOne (where: email: email). (bruker) if (bruker) return done (null, false, message: 'Denne e-posten er allerede tatt'; else var userPassword = generateHash (passord); var data = email: email, passord: userPassword, fornavn: req.body.firstname, etternavn: req.body.lastname; User.create (data) .then (funksjon (newUser, opprettet) if (! newUser) return done (null, false); hvis (newUser) return done (null, newUser);););)); Nå vil vi importere strategien i server.js.
For å gjøre dette legger vi til disse linjene under rutenes import i server.js.
// laste pass strategier krever ('. / app / config / passport / passport.js') (pass, models.user);Din server.js skal se slik ut på dette tidspunktet:
var ekspres = kreve (ekspres) var var app = ekspres () var pass = krever (pass) var økt = krever ('express-økt') var bodyParser = krever ('body-parser') var env = krever ('dotenv'). last () var exphbs = krever ('ekspresstyrefelt') // For BodyParser app.use (bodyParser.urlencoded (extended: true)); app.use (bodyParser.json ()); // For Pass app.use (økt (hemmelig: 'keyboard cat', resave: true, saveUnitialized: true)); // økt hemmelig app.use (passport.initialize ()); app.use (passport.session ()); // vedvarende innloggingssessioner // For Handlebars app.set ('views', './app/views') app.engine ('hbs', exphbs (extname: '.hbs')); app.set ('view engine', '. hbs'); app.get ('/', funksjon (req, res) res.send ('Velkommen til Pass med Sequelize');); // Modeller var modeller = krever ("./app / models"); // Ruter var authRoute = krever ('./app / routes / auth.js') (app); // laste pass strategier krever ('. / app / config / passport / passport.js') (pass, models.user); // Synkroniser databaser.sequelize.sync (). Deretter (funksjon () console.log ('Nice! Database ser bra ut')). Catch (funksjon (err) console.log (feil, "Noe gikk galt med databaseoppdateringen! ")); app.listen (5000, funksjon (err) hvis (! err) console.log ("Site er live"); annet console.log (err));Nå vil vi faktisk bruke strategien til vår /melde deg på rute.
Slik gjør vi det:
Først går vi til app / ruter / auth.js, og legg til en rute for innlegging for å registrere deg slik.
app.post ('/ signup', passport.authenticate ('local-signup', successRedirect: '/ dashboard', feilRedirect: '/ signup'));Siden vi trenger pass, må vi sende det til denne metoden. Vi kan importere pass i dette skriptet eller sende det fra server.js. La oss gjøre sistnevnte.
Endre funksjonen som er eksportert i denne filen app / ruter / auth.js å ha pass som parameter. Koden i app / ruter / auth.js bør se slik ut etter endringen.
var authController = krever ('... /controllers/authcontroller.js'); module.exports = funksjon (app, pass) app.get ('/ signup', authController.signup); app.get ('/ signin', authController.signin); app.post ('/ signup', passport.authenticate ('local-signup', successRedirect: '/ dashboard', feilRedirect: '/ signup')); Så i server.js, Vi modifiserer rutenes import og legger til pass som et argument som dette:
var authRoute = krever ('./app / routes / auth.js') (app, pass);
Gå nå til registreringsadressen http: // localhost: 5000 / signup / og prøv å registrere deg.
Når du prøver å registrere deg, vil du få en feil "Kunne ikke serialisere brukeren i økt". Dette skyldes at passet må lagre en bruker-ID i sesjonen, og den bruker dette til å administrere henting av brukerdetaljer når det trengs.
For å løse dette skal vi implementere både serialiserings- og deserialiseringsfunksjonene til passet i vår app / config / pass / passport.js fil.
Først legger vi til serialiseringsfunksjonen. I denne funksjonen lagrer vi bruker-ID til økten.
For å gjøre dette legger vi til følgende linjer under initialiseringen av den lokale strategien.
// serialiser passport.serializeUser (funksjon (bruker, ferdig) ferdig (null, user.id););
Deretter implementerer vi deserialiseringsfunksjonen. Legg til funksjonen like under serialiseringsfunksjonen.
// deserialiser bruker passport.deserializeUser (funksjon (id, ferdig) User.findById (id) .then (funksjon (bruker) hvis (bruker) ferdig (null, user.get ()); else done user.errors, null);););
I deserialiseringsfunksjonen ovenfor bruker vi Sequelize findById lover å få brukeren, og hvis vellykket, returneres en forekomst av Sequelize-modellen. For å få brukerobjektet fra denne forekomsten bruker vi Sequelize getter-funksjonen slik: user.get ().
Kjør nå igjen:
node server.js
Og prøv å registrere deg. Hurray hvis du fikk "Kan ikke få / dashbord"! Det betyr at vår godkjenning var vellykket. Husk vi omdirigert til / dashbord i vårt passport.autentiser metode i ruter / auth.js.
La oss nå gå videre og legge til den ruten. Deretter legger du til en mellomvare for å sikre at siden kun kan nås når en bruker er logget inn i sesjonen.
I vår app / visninger mappe, oppretter vi en ny fil som heter dashboard.hbs og legg til følgende HTML-kode i den.
Pass med Sequelize dashbord
Hurra! du er logget inn.
I ruter / auth.js, Vi legger til denne linjen inne i module.exports blokkere:
app.get ( '/ dashbord', authController.dashboard);
Deretter går vi til app / kontrollere / authController.js og legg til kontrollpanelet på dashbordet.
export.dashboard = funksjon (req, res) res.render ('dashboard'); Din AuthController.js skal se slik ut:
var exports = module.exports = exports.signup = funksjon (req, res) res.render ('signup'); exportss.signin = funksjon (req, res) res.render ('signin'); exports.dashboard = funksjon (req, res) res.render ('dashboard'); Kjør appen igjen, og prøv å registrere deg med en annen e-postadresse enn den du brukte tidligere. Du blir riktig omdirigert til / dashbord rute.
Men / dashbord er ikke en beskyttet rute, noe som betyr at selv om en bruker ikke er logget inn, kan de se den. Vi vil ikke ha dette, så vi legger til en /Logg ut rute for å logge brukeren ut, og deretter beskytte ruten og teste hva vi har gjort.
La oss gjøre dette:
I ruter / auth.js vi legger til denne linjen:
app.get ( '/ Logg', authController.logout);
Deretter legger vi til kontrolleren i app / controllers / authController.js.
exports.logout = funksjon (req, res) req.session.destroy (funksjon (feil) res.redirect ('/');); Kjør nå appen på nytt og registrer deg med en annen e-postadresse.
Etter det, besøk http: // localhost: 5000 / logout for å logge brukeren ut. Nå besøker http: // localhost: 5000 / dashboard.
Du vil legge merke til at det er ganske tilgjengelig. La oss legge til et tilpasset mellomvare for å beskytte den ruten.
For å gjøre dette åpner vi app / ruter / auth.js og legg til denne funksjonen i module.exports blokkere, under alle de andre kodelinjene.
funksjon isLoggedIn (req, res, next) hvis (req.isAuthenticated ()) returnerer neste (); res.redirect ( '/ pålogging');
Deretter endrer vi rutebryteren til dashbordet slik at det ser ut som dette:
app.get ('/ dashboard', isLoggedIn, authController.dashboard);
Nå når du kjører appen igjen og prøver å gå til oversikten og du ikke er logget inn, bør du bli omdirigert til påloggingssiden.
Puh! Det er på tide å gjennomføre den siste delen: påloggingen.
Først legger vi til en ny lokal strategi for pålogging i app / config / pass / passport.js.
// LOCAL SIGNIN passport.use ('local-signin', ny LocalStrategy (// som standard, bruker lokal brukernavn og passord, vi vil tilsidesette med e-post brukernavnField: 'email', passwordField: 'passord', passReqToCallback: true // lar oss sende hele forespørselen tilbake til tilbakekallingen, funksjon (req, email, passord, ferdig) var Bruker = bruker; var isValidPassword = funksjon (brukerpass, passord) return bCrypt.compareSync (passord, brukerpass) ; User.findOne (where: email: email). Da (funksjon (bruker) hvis (! Bruker) retur ferdig (null, falsk, melding: 'Email eksisterer ikke');; Hvis ! isValidPassword (user.password, passord)) return done (null, false, message: 'Feil passord.'); var userinfo = user.get (); returnert ferdig (null, userinfo); ) .catch (funksjon (err) console.log ("Feil:", feil); returnert ferdig (null, false, message: 'Noe gikk galt med Signin');;;));I denne strategien, denisValidPasswordfunksjonen sammenligner passordet som er oppgitt med bCrypt-sammenligningsmetoden siden vi lagret passordet vårt med bcrypt.
Hvis detaljer er korrekte, blir brukeren logget på.
Gå nå til ruter / auth.js og legg til ruten for postering til /Logg inn.
app.post ('/ signin', passport.authenticate ('local-signin', successRedirect: '/ dashboard', failureRedirect: '/ signin'));Ruter / auth.js bør se slik ut når du er ferdig.
var authController = krever ('... /controllers/authcontroller.js'); module.exports = funksjon (app, pass) app.get ('/ signup', authController.signup); app.get ('/ signin', authController.signin); app.post ('/ signup', passport.authenticate ('local-signup', successRedirect: '/ dashboard', feilRedirect: '/ signup')); app.get ('/ dashboard', isLoggedIn, authController.dashboard); app.get ('/ logout', authController.logout); app.post ('/ signin', passport.authenticate ('local-signin', successRedirect: '/ dashboard', failureRedirect: '/ signin')); funksjon isLoggedIn (req, res, next) hvis (req.isAuthenticated ()) returnerer neste (); res.redirect ( '/ pålogging'); Kjør nå appen og prøv å logge inn. Du bør kunne logge inn med noen av detaljene du brukte mens du registrerte deg, og du vil bli sendt til http: // localhost: 5000 / dashbord /.
Gratulerer hvis du gjorde det til slutten av denne opplæringen! Vi har vellykket brukt Sequelize og Passport med en MySQL database.
Den fulle koden for denne opplæringen finner du på GitHub.
Dette avslutter vår veiledning om bruk av Passport for godkjenning av brukere med Sequelize og MySQL. Sequelize er en veldig nyttig ORM for å håndtere MySQL når du bruker Node. Jeg har personlig funnet det å være veldig nyttig, og du bør definitivt vurdere å bruke den i din neste Node-MySQL-app.
