Utilizzo di Passport con Sequelize e MySQL

Sequelize è un ORM Node.js basato su promesse. Può essere utilizzato con PostgreSQL, MySQL, MariaDB, SQLite e MSSQL. In questo tutorial implementeremo l'autenticazione per gli utenti di un'app Web. E utilizzeremo Passport, il famoso middleware di autenticazione per Node, insieme a Sequelize e MySQL per implementare la registrazione e l'accesso degli utenti.

Iniziare

Assicurati di aver installato quanto segue sulla tua macchina:

  • Nodo
  • MySQL

Per questo tutorial, utilizzeremo Node.js insieme a Express, quindi procediamo e iniziamo a installare ciò di cui abbiamo bisogno.

Passaggio 1: generare un file package.json

Crea una directory per la tua app. All'interno di questa directory, esegui questo dal tuo terminale o prompt dei comandi:

 npm init

Questo inizializza il manager delle dipendenze di npm. Questo presenterà una serie di prompt che passeremo rapidamente.

  • Digita il nome dell'app senza spazi e premi Invio per "nome".
  • Premi Invio per la 'versione'.
  • Per la 'descrizione', in questo tutorial, digitaremo "Uso di Passport con Sequelize e MySQL" come descrizione e premere Invio. Anche questo può essere vuoto.
  • Per "entry point (index.js)", digitare server.js e premere Invio.
  • Per "comando test", premere Invio. 
  • Per "repository git", puoi inserire il repository git in cui risiede la tua app se ne hai uno o premi INVIO per lasciare questo spazio vuoto.
  • Per "Parole chiave", premere Invio.
  • Per "autore", premi Invio o digita il tuo nome prima di farlo. 
  • Per "licenza", premere Invio. 
  • Per '(Va bene)', questo ti mostra come sarà il tuo pacchetto.json. Scrivi Sì e premi Invio.

Passaggio 2: installare le dipendenze

Le principali dipendenze per questo tutorial sono:

  • Esprimere
  • Sequelize
  • MySQL
  • Passaporto
  • Strategia locale del passaporto
  • Body Parser
  • Express Session
  • Bcrypt Nodejs
  • Manubri Express per le viste 

Per installarli, dal terminale o dal prompt dei comandi, eseguire i seguenti uno dopo l'altro.

npm install express --save npm install sequelize --save npm installa mysql --save npm installa passport --save npm installa passport-local --save npm installa body-parser --save npm installa express-session --save npm installa bcrypt-nodejs --save npm installa express-handlebar --save

Se stai usando Git per questo progetto:

Nella cartella del progetto creare un file .gitignore.

Aggiungi questa linea al file .gitignore.

node_modules 

Passaggio 3: impostare l'app

Ora creiamo un file server. Questo sarà il file principale chiamato quando si digita quanto segue:

inizio di npm

Questo esegue l'app. Puoi anche eseguire l'app digitando node server.js.

nodo server.js

Quindi, nella nostra cartella del progetto, creiamo un nuovo file e denominiamo questo file server.js.

Dentro il server.js file, incolliamo il seguente:

var express = require ('express'); var app = express (); app.get ('/', function (req, res) res.send ('Welcome to Passport with Sequelize');); app.listen (5000, function (err) if (! err) console.log ("Sito è live"); else console.log (err));

La prima riga assegna il modulo espresso a una variabile express. Inizializziamo quindi express e lo chiamiamo una variabile: app. 

Quindi eseguiamo l'ascolto delle app sulla porta 5000. Puoi scegliere qualsiasi numero di porta libera sul tuo computer. 

Successivamente, chiamiamo il app.get () funzione di routing espresso per rispondere con "Welcome to Passport with Sequelize" quando viene effettuata una richiesta GET su "/".

Per testare sul tuo computer, eseguilo dalla cartella del tuo progetto:

nodo server.js

Se vedi il messaggio "Welcome to Passport with Sequelize" quando visiti http: // localhost: 5000 / then congratats! Altrimenti, controlla di aver fatto tutto esattamente come è scritto sopra. 

Successivamente, importiamo alcuni moduli di cui abbiamo bisogno, come passaporto, express-session e body-parser.

Dopo var app = express () aggiungiamo le seguenti linee:

var passport = require ('passport') var session = require ('express-session') var bodyParser = require ('body-parser')

Nelle prime due righe, importiamo il modulo passaporto e la express-session, entrambe le quali devono essere gestite dall'autenticazione.

Quindi, importiamo il modulo body-parser. Questo estrae l'intera parte del corpo di una richiesta in arrivo e la espone in un formato con cui è più facile lavorare. In questo caso, useremo il formato JSON.

Per consentire alla nostra app di usare il parser del corpo, aggiungiamo queste linee alcuni spazi sotto le linee di importazione:

// For BodyParser app.use (bodyParser.urlencoded (extended: true)); app.use (bodyParser.json ());

Successivamente, inizializziamo il passaporto e la sessione express e la sessione del passaporto e li aggiungiamo entrambi come middleware. Lo facciamo aggiungendo queste righe alcuni spazi dopo la riga di importazione bodyParser.

// For Passport app.use (session (secret: 'keyboard cat', resave: true, saveUninitialized: true)); // session secret app.use (passport.initialize ()); app.use (passport.session ()); // sessioni di accesso persistenti

Inizieremo a lavorare sull'autentica attuale ora.

Lo faremo in quattro passaggi:

  • Configura Sequelize con MySQL.
  • Crea il modello utente.
  • Imposta viste.
  • Scrivi una strategia per i passaporti.

1. Impostare Sequelize con MySQL

Per prima cosa, creiamo un database in MySQL. Dagli il tuo nome preferito. Per il bene di questo tutorial, creiamo un database chiamato sequelize_passport in MySQL.

Quindi impostiamo la configurazione per gestire i dettagli del DB. 

Innanzitutto, importiamo il modulo dot-env per gestire le variabili di ambiente.

Esegui questo nella cartella del progetto root:

installazione npm --save dotenv

Quindi lo importiamo nel file server principale, server.js, appena sotto le altre importazioni.

var env = require ('dotenv'). load (); 

Successivamente, creiamo un file nella nostra cartella del progetto e lo chiamiamo .env. 

Il prossimo passo da seguire è facoltativo se non stai utilizzando Git:

Aggiungeremo il file .env al file .gitignore.

Il tuo file .gitignore dovrebbe apparire così:

node_modules .env

Dopo questo, aggiungiamo il nostro ambiente al file .env aggiungendo questa riga:

NODE_ENV = 'sviluppo'

Quindi creiamo un file config.json che verrà utilizzato da Sequelize per gestire ambienti diversi.

La prima cosa da fare è creare una cartella denominata config nella nostra cartella del progetto. All'interno di questa cartella, creiamo a config.jSON file. Questo file deve essere ignorato se si sta spingendo su un repository. Per fare ciò, aggiungi il seguente codice al tuo .gitignore:

config / config.json

Quindi, incolliamo il seguente codice nel nostro file config.json.

"sviluppo": "username": "root", "password": null, "database": "sequelize_passport", "host": "127.0.0.1", "dialect": "mysql", "test" : "username": "", "password": null, "database": "", "host": "", "dialect": "mysql", "production": "username": "", "password": null, "database": "", "host": "127.0.0.1", "dialect": "mysql"

Ricordarsi di sostituire i valori nel blocco di sviluppo sopra con i dettagli di autenticazione del database.

Successivamente, installiamo sequelize con npm. Per fare ciò, eseguire il seguente comando nella cartella principale del progetto:

installazione npm --save sequelize

Ora è il momento di creare il Modelli cartella. 

Per prima cosa, creiamo una directory chiamata App nella nostra cartella del progetto.

Dentro il App cartella, creiamo una nuova cartella chiamata Modelli e creare un nuovo file chiamato index.js nel Modelli cartella.

All'interno del file index.js, incolliamo il codice qui sotto.

"usare rigorosamente"; var fs = require ("fs"); var path = require ("percorso"); var Sequelize = require ("sequelize"); var env = process.env.NODE_ENV || "sviluppo"; var config = require (path.join (__ dirname, '...', 'config', 'config.json')) [env]; var sequelize = new Sequelize (config.database, config.username, config.password, config); var db = ; fs .readdirSync (__ dirname) .filter (function (file) return (file.indexOf (".")! == 0) && (file! == "index.js");). forEach (funzione (file ) var model = sequelize.import (path.join (__ dirname, file)); db [model.name] = model;); Object.keys (db) .forEach (function (modelName) if ("associate" in db [modelName]) db [modelName] .associate (db);); db.sequelize = sequelize; db.Sequelize = Sequelize; module.exports = db;

Questo file viene utilizzato per importare tutti i modelli che inseriamo nel Modelli cartella ed esportarli. 

Per verificare se tutto va bene, aggiungiamo questo nel nostro file server.js.

// Models var models = require ("./ app / models"); // Sync Database models.sequelize.sync (). Then (function () console.log ('Nice! Database sembra corretto')). Catch (function (err) console.log (err, "Qualcosa è andato storto con l'aggiornamento del database! "));

Qui, stiamo importando i modelli e quindi chiamando la funzione di sincronizzazione Sequelize.

Esegui questo per vedere se tutto va bene:

nodo server.js

Se viene visualizzato il messaggio "Sito è attivo, il database è in ordine, quindi è stato impostato Sequenza.

In caso contrario, si prega di seguire attentamente i passaggi precedenti e provare a eseguire il debug del problema con l'aiuto.

2. Creare il modello utente

La prossima cosa che faremo è creare il modello utente, che è fondamentalmente la tabella utente. Questo conterrà informazioni utente di base.

Nel nostro Modelli cartella, creiamo un file e lo chiamiamo user.js. Il percorso completo per questo file dovrebbe essere app / models / user.js.

Apri il file user.js e aggiungi il seguente codice:

module.exports = function (sequelize, Sequelize) var User = sequelize.define ('user', id: autoIncrement: true, primaryKey: true, digita: Sequelize.INTEGER, firstname: type: Sequelize.STRING, notEmpty: true, lastname: type: Sequelize.STRING, notEmpty: true, username: type: Sequelize.TEXT, about: type: Sequelize.TEXT, email: type: Sequelize.STRING, convalida: isEmail: true, password: tipo: Sequelize.STRING, allowNull: false, last_login: tipo: Sequelize.DATE, stato: tipo: Sequelize.ENUM ('active', 'inactive'), defaultValue : 'attivo'  ); return User; 

Ora esegui:

nodo server.js

Dovresti vedere il familiare "Il sito è in diretta Bello! Banca dati sembra a posto.msgstr "Questo significa che i nostri modelli Sequelize sono stati sincronizzati con successo, e se controlli il tuo database dovresti vedere una tabella utenti con le colonne specificate presenti.

3: Impostare le viste

Per prima cosa, creiamo la vista per la registrazione e colleghiamo.

La prima cosa da fare è importare il modulo express manubs che usiamo per le viste in questo tutorial.

Aggiungi questa linea al file di avvio principale, server.js.

var exphbs = require ('express-handlebar')

Il tuo blocco di importazione dovrebbe apparire come questo a questo punto.

var express = require ('express') var app = express () var passport = require ('passport') var session = require ('express-session') var bodyParser = require ('body-parser') var env = require ('dotenv'). load () var exphbs = require ('express-handlebar')

Successivamente, aggiungiamo le seguenti righe nel nostro file server.js.

// Per Handlebars app.set ('views', './app/views') app.engine ('hbs', exphbs (extname: '.hbs')); app.set ('view engine', '.hbs');

Ora, nella nostra cartella app, creiamo tre cartelle nominate visualizzazioni, controllori, e itinerari.

Nella cartella views, creiamo un file chiamato Iscriviti.hbs e incolla il codice qui sotto.

      

Quindi nel nostro controllori cartella, creiamo un nuovo file e lo chiamiamo authcontroller.js.

In questo file, incolliamo il seguente controller per la rotta di registrazione che creeremo in un momento.

var exports = module.exports =  exports.signup = function (req, res) res.render ('signup'); 

Successivamente, creiamo un percorso per la registrazione. Nella cartella rotte, creiamo un nuovo file chiamato auth.js e quindi, in questo file, importiamo il controller auth e definiamo il percorso di registrazione.

var authController = require ('... /controllers/authcontroller.js'); module.exports = function (app) app.get ('/ signup', authController.signup); 

Ora, importeremo questo percorso nel nostro server.js e passeremo l'app come argomento.

Nel server, dopo l'importazione dei modelli, aggiungi queste righe:

// Routes var authRoute = require ('./ app / routes / auth.js') (app);

Esegui questo: 

nodo server.js

Ora, visita http: // localhost: 5000 / registrazione e vedrai il modulo di registrazione.

Ripetiamo i passaggi per il modulo di accesso. Come prima, creeremo un file chiamato signin.hbs nella nostra cartella visualizzazioni e incolla il seguente codice HTML al suo interno:

      

Quindi, aggiungi un controller per l'accesso in app / controller / authcontroller.js.

exports.signin = function (req, res) res.render ('signin'); 

Quindi in app / rotte / auth.js, aggiungiamo un percorso per l'accesso in questo modo:

app.get ('/ signin', authController.signin);

Ora quando corri:

 nodo server.js 

e visita http: // localhost: 5000 / signin /, dovresti vedere il modulo di accesso.

Il passo finale e principale è scrivere le nostre strategie per i passaporti.

4. Scrivi una strategia per i passaporti

Nel app / config, creiamo una nuova cartella chiamata passaporto.

Quindi nella nostra nuova cartella app / config / passport, creiamo un nuovo file e lo chiamiamo passport.js. Questo file conterrà le nostre strategie per i passaporti.

Nel passport.js, useremo il modello utente e il passaporto.

Per prima cosa, importiamo bcrypt di cui abbiamo bisogno per proteggere le password.

var bCrypt = require ('bcrypt-nodejs');

Quindi, aggiungiamo un blocco module.exports in questo modo:

module.exports = function (passport, user) 

All'interno di questo blocco inizializziamo la strategia locale passaporto e il modello utente, che verrà passato come argomento. Ecco come lo facciamo:

module.exports = function (passport, user) var Utente = utente; var LocalStrategy = require ('passport-local'). Strategia; 

Quindi definiamo la nostra strategia personalizzata con la nostra istanza di LocalStrategy in questo modo:

passport.use ('local-signup', new LocalStrategy (usernameField: 'email', passwordField: 'password', passReqToCallback: true // ci consente di passare l'intera richiesta al callback,));

Ora abbiamo dichiarato quale richiesta (req) Campi il nostro nome utente Campo e password Campo (variabili del passaporto) sono. 

L'ultima variabile passReqToCallback ci consente di passare l'intera richiesta al callback, che è particolarmente utile per la registrazione.

Dopo l'ultima virgola, aggiungiamo questa funzione di callback.

 funzione (req, email, password, fatto) 

In questa funzione, gestiremo la memorizzazione dei dettagli di un utente.

Innanzitutto, aggiungiamo la nostra funzione di generazione di password con hash all'interno della funzione di callback.

 var generateHash = function (password) return bCrypt.hashSync (password, bCrypt.genSaltSync (8), null); ;

Quindi, utilizzando il modello utente Sequelize, inizializzato in precedenza come Utente, controlliamo per vedere se l'utente esiste già, e se non li aggiungiamo.

User.findOne (where: email: email). Then (function (user) if (user) return done (null, false, message: 'L'email è già stata presa'); else  var userPassword = generateHash (password); var data = email: email, password: userPassword, firstname: req.body.firstname, lastname: req.body.lastname; User.create (data) .then (function (newUser, creato) if (! newUser) return done (null, false); if (newUser) return done (null, newUser);););

User.create () è un metodo Sequelize per aggiungere nuove voci al database. Si noti che i valori nel file dati oggetto sono ottenuti dal req.body oggetto che contiene l'input dal nostro modulo di registrazione. 

Il tuo passport.js dovrebbe assomigliare a questo:

// carica bcrypt var bCrypt = require ('bcrypt-nodejs'); module.exports = function (passport, user) var Utente = utente; var LocalStrategy = require ('passport-local'). Strategia; passport.use ('local-signup', new LocalStrategy (usernameField: 'email', passwordField: 'password', passReqToCallback: true // ci consente di restituire l'intera richiesta al callback, funzione (req, email, password, done) var generateHash = function (password) return bCrypt.hashSync (password, bCrypt.genSaltSync (8), null);; User.findOne (where: email: email). then (function (utente) if (utente) return done (null, false, message: 'Quell'email è già stata presa'); else var userPassword = generateHash (password); var data = email: email, password: userPassword, firstname: req.body.firstname, lastname: req.body.lastname; User.create (data) .then (function (newUser, created) if (! newUser) return done (null, false); if (newUser) return done (null, newUser);););)); 

Ora importeremo la strategia in server.js.

Per fare ciò, aggiungiamo queste linee sotto l'importazione dei percorsi in server.js.

// caricare le strategie del passaporto richiedono ('./ app / config / passport / passport.js') (passport, models.user);

Il tuo server.js dovrebbe apparire così in questo momento:

var express = require ('express') var app = express () var passport = require ('passport') var session = require ('express-session') var bodyParser = require ('body-parser') var env = require ('dotenv'). load () var exphbs = require ('express-handlebars') // Per BodyParser app.use (bodyParser.urlencoded (extended: true)); app.use (bodyParser.json ()); // For Passport app.use (session (secret: 'keyboard cat', resave: true, saveUninitialized: true)); // session secret app.use (passport.initialize ()); app.use (passport.session ()); // sessioni di login persistenti // Per Handlebars app.set ('views', './app/views') app.engine ('hbs', exphbs (extname: '.hbs')); app.set ('view engine', '.hbs'); app.get ('/', function (req, res) res.send ('Welcome to Passport with Sequelize');); // Models var models = require ("./ app / models"); // Routes var authRoute = require ('./ app / routes / auth.js') (app); // caricare le strategie del passaporto richiedono ('./ app / config / passport / passport.js') (passport, models.user); // Sync Database models.sequelize.sync (). Then (function () console.log ('Nice! Database sembra corretto')). Catch (function (err) console.log (err, "Qualcosa è andato storto con l'aggiornamento del database! ")); app.listen (5000, function (err) if (! err) console.log ("Sito è live"); else console.log (err));

Ora applicheremo la strategia al nostro /Iscriviti itinerario.

Ecco come lo facciamo:

Per prima cosa, andiamo a app / rotte / auth.js, e aggiungi una rotta per la pubblicazione alla registrazione in questo modo.

app.post ('/ signup', passport.authenticate ('local-signup', successRedirect: '/ dashboard', failureRedirect: '/ signup'));

Poiché abbiamo bisogno del passaporto, dobbiamo passarlo a questo metodo. Possiamo importare il passaporto in questo script o passarlo da server.js. Facciamo il secondo.

Modifica la funzione esportata in questo file app / rotte / auth.js avere il passaporto come parametro. Il codice in app / rotte / auth.js dovrebbe apparire così dopo la tua modifica.

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')); 

Quindi in server.js, modifichiamo i percorsi importati e aggiungiamo passaporto come argomento come questo:

var authRoute = require ('./ app / routes / auth.js') (app, passport);

Ora vai all'URL di registrazione http: // localhost: 5000 / signup / e prova ad iscriverti.

Quando provi ad iscriverti, riceverai un errore "Impossibile serializzare l'utente in sessioneQuesto perché il passaporto deve salvare un ID utente nella sessione e lo utilizza per gestire il recupero dei dettagli dell'utente quando necessario.

Per risolvere questo, implementeremo sia le funzioni serialize che deserializzate del passaporto nel nostro app / config / passaporto / passport.js file.

Per prima cosa aggiungiamo la funzione serialize. In questa funzione, salveremo il ID utente alla sessione.

Per fare ciò, aggiungiamo le seguenti linee sotto l'inizializzazione della strategia locale.

// serializza passport.serializeUser (function (user, done) done (null, user.id););

Successivamente, implementiamo la funzione di deserializzazione. Aggiungi la funzione appena sotto la funzione serializza.

// deserialize user passport.deserializeUser (function (id, done) User.findById (id) .then (function (user) if (utente) done (null, user.get ()); else done ( user.errors, null);););

Nella funzione di deserializzazione sopra, usiamo il Sequelize findById promette di ottenere l'utente e, in caso di esito positivo, viene restituita un'istanza del modello Sequelize. Per ottenere l'oggetto User da questa istanza, usiamo la funzione getter Sequelize come questa: user.get ().

Ora esegui di nuovo:

nodo server.js

E prova ad iscriverti. Evviva se hai ottenuto il messaggio "Can not GET / dashboard"! Significa che la nostra autenticazione ha avuto successo. Ricorda che abbiamo reindirizzato a / dashboard nel nostro metodo passport.authenticate in Percorsi / auth.js.

Ora andiamo avanti e aggiungere quella rotta. Quindi, aggiungi un middleware per assicurarti che la pagina sia accessibile solo quando un utente accede alla sessione.

Nel nostro app / views cartella, creiamo un nuovo file chiamato dashboard.hbs e aggiungi il seguente codice HTML.

   Passaporto con Sequelize   

Cruscotto

Evviva! ti sei autenticato.

Nel Percorsi / auth.js, aggiungiamo questa linea all'interno del module.exports bloccare:

app.get ( '/ cruscotto', authController.dashboard);

Successivamente, andiamo a app / controller / authController.js e aggiungere il controller della dashboard.

exports.dashboard = function (req, res) res.render ('dashboard'); 

Il tuo AuthController.js dovrebbe assomigliare a questo:

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'); 

Ora esegui di nuovo l'app e prova a registrarti con un indirizzo email diverso da quello che hai usato in precedenza. Sarai opportunamente reindirizzato al /cruscotto itinerario. 

Ma /cruscotto non è un percorso protetto, il che significa che anche se un utente non ha effettuato l'accesso, può vederlo. Non vogliamo questo, quindi aggiungeremo un /disconnettersi percorso per registrare l'utente, quindi proteggere il percorso e testare ciò che abbiamo fatto.

Facciamolo:

Nel Percorsi / auth.js aggiungiamo questa riga:

app.get ( '/ logout', authController.logout);

Quindi aggiungiamo il controller in app / controller / authController.js.

 exports.logout = function (req, res) req.session.destroy (function (err) res.redirect ('/');); 

Ora esegui nuovamente l'app e registrati con un indirizzo email diverso.

Successivamente, visitare http: // localhost: 5000 / logout per disconnettere l'utente. Ora visita http: // localhost: 5000 / dashboard.

Noterai che è abbastanza accessibile. Aggiungiamo un middleware personalizzato per proteggere quella rotta.

Per fare questo, apriamo app / routes / auth.js e aggiungi questa funzione nel module.exports blocco, sotto tutte le altre linee di codice.

function isLoggedIn (req, res, next) if (req.isAuthenticated ()) return next (); res.redirect ( '/ signin'); 

Quindi modifichiamo il gestore del percorso del dashboard in modo che assomigli a questo:

app.get ('/ dashboard', isLoggedIn, authController.dashboard);

Ora quando esegui nuovamente l'app e provi a visitare la pagina del dashboard e non hai effettuato l'accesso, dovresti essere reindirizzato alla pagina di accesso.

Meno male! È giunto il momento di implementare la parte finale: l'accesso. 

Innanzitutto, aggiungeremo una nuova strategia locale per l'accesso in app / config / passaporto / passport.js

// LOCIN LOCIN passport.use ('local-signin', nuova LocalStrategy (// di default, la strategia locale usa username e password, sostituiremo con email usernameField: 'email', passwordField: 'password', passReqToCallback: true // ci consente di restituire l'intera richiesta al callback, 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 non esiste'); if (! isValidPassword (user.password, password)) return done (null, false, message: 'Password errata.'); var userinfo = user.get (); return done (null, userinfo); ) .catch (function (err) console.log ("Errore:", err); return done (null, false, message: 'Qualcosa è andato storto con il tuo Signin'););));

In questa strategia, ilisValidPasswordfunzione confronta la password inserita con il metodo di confronto bCrypt poiché abbiamo memorizzato la nostra password con bcrypt.

Se i dettagli sono corretti, il nostro utente sarà registrato.

Ora vai a Percorsi / auth.js e aggiungi la rotta per la pubblicazione su /registrati.

app.post ('/ signin', passport.authenticate ('local-signin', successRedirect: '/ dashboard', failureRedirect: '/ signin'));

I tuoi percorsi / auth.js dovrebbero assomigliare a questo quando hai finito.

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'); 

Ora esegui l'app e prova ad accedere. Dovresti essere in grado di accedere con i dettagli utilizzati durante la registrazione e verrai indirizzato a http: // localhost: 5000 / cruscotto /.

Complimenti se sei arrivato alla fine di questo tutorial! Abbiamo usato Sequelize e Passport con successo con un database MySQL.

Il codice completo per questo tutorial è disponibile su GitHub.

Conclusione

Questo conclude il nostro tutorial sull'uso di Passport per l'autenticazione degli utenti con Sequelize e MySQL. Sequelize è un ORM molto utile per gestire MySQL quando si utilizza Node. L'ho trovato personalmente molto utile, e dovresti sicuramente considerare di usarlo nella tua prossima app Node-MySQL.

Riferimenti

  • Sequela i documenti
  • Passaporto