Sequelize е базиран на обещания Node.js ORM. Може да се използва с PostgreSQL, MySQL, MariaDB, SQLite и MSSQL. В този урок ще внедрим удостоверяване за потребители на уеб приложение. И ще използваме Passport, популярния междинен софтуер за удостоверяване за Node, заедно със Sequelize и MySQL, за да приложим регистрация и влизане на потребител.
Първи стъпки
Уверете се, че на вашата машина е инсталирано следното:
- Възел
- MySQL
За този урок ще използваме Node.js заедно с Express, така че продължаваме и започваме да инсталираме това, от което се нуждаем.
Стъпка 1:Генерирайте файл package.json
Създайте директория за вашето приложение. Вътре в тази директория изпълнете това от терминала или командния ред:
npm init
Това инициализира npm Dependency Manager. Това ще представи серия от подкани, които бързо ще преминем.
- Въведете името на приложението си без интервали и натиснете Enter за „име“.
- Натиснете Enter за „версията“.
- За „описание“ в този урок ще напишем „Използване на паспорт със Sequelize и MySQL“ като описание и ще натиснете Enter. Това също може да е празно.
- За „входна точка (index.js)“ въведете server.js и натиснете Enter.
- За „тестова команда“ натиснете Enter.
- За „git repository“ можете да въведете git repo, където се намира приложението ви, ако имате такова, или просто натиснете Enter, за да оставите това празно.
- За „Ключови думи“ натиснете Enter.
- За „автор“ натиснете Enter или въведете името си, преди да го направите.
- За „лиценз“ натиснете Enter.
- За „(Добре ли е това)“ това ви показва как ще изглежда вашият package.json. Въведете Yes и натиснете Enter.
Стъпка 2:Инсталиране на зависимости
Основните зависимости за този урок са:
- Експресно
- Sequelize
- MySQL
- Паспорт
- Местна стратегия за паспорт
- Разбор на тялото
- Експресна сесия
- Bcrypt Nodejs
- Експресни дръжки за изгледите
За да ги инсталирате, от терминала или командния ред стартирайте следното едно след друго.
npm install express --savenpm install sequelize --savenpm install mysql --savenpm install passport --savenpm install passport-local --savenpm install body-parser --savenpm install express-session --savenpm install bcrypt-nodejs - -savenpm инсталирай express-handlebars --save
Ако използвате Git за този проект:
В папката на вашия проект създайте файл .gitignore.
Добавете този ред към файла .gitignore.
node_modules
Стъпка 3:Настройте приложението
Сега създаваме сървърен файл. Това ще бъде основният файл, извикан, когато въведете следното:
npm start
Това стартира приложението. Можете също да стартирате приложението, като напишете node server.js.
node server.js
След това в папката на нашия проект създаваме нов файл и именуваме този файл server.js .
Вътре в server.js файл, поставяме следното:
var express =require('express');var app =express();app.get('/', function(req, res) { res.send('Добре дошли в Passport with Sequelize');});app.listen(5000, function(err) { if (!err) console.log("Сайтът е на живо"); else console.log(err)}); Първият ред присвоява експресния модул на променлива експресна. След това инициализираме express и я именуваме променлива:app.
След това караме приложението да слуша на порт 5000 . Можете да изберете всеки безплатен номер на порт на вашия компютър.
След това извикваме app.get() функция за експресно маршрутизиране, за да отговори с „Добре дошли в Passport with Sequelize“, когато се направи заявка GET до „/“.
За да тествате на вашия компютър, изпълнете това от папката на вашия проект:
node server.js
Ако видите текста „Добре дошли в Passport with Sequelize“, когато посетите http://localhost:5000/, тогава поздравления! В противен случай проверете дали сте направили всичко точно както е написано по-горе.
След това импортираме някои модули, от които се нуждаем, като паспорт, експресна сесия и body-parser.
След var app = express() добавяме следните редове:
var passport =require('passport')var session =require('express-session')var bodyParser =require('body-parser') В първите два реда импортираме паспортния модул и експресната сесия, като и двете трябва да обработваме удостоверяването.
След това импортираме модула body-parser. Това извлича цялата част от тялото на входяща заявка и я излага във формат, с който е по-лесно да се работи. В този случай ще използваме формата JSON.
За да позволим на нашето приложение да използва анализатора на тялото, ние добавяме тези редове няколко интервала под редовете за импортиране:
//За BodyParserapp.use(bodyParser.urlencoded({ extended:true }));app.use(bodyParser.json()); След това инициализираме паспорта и експресната сесия и паспортната сесия и ги добавяме като междинен софтуер. Правим това, като добавяме тези редове няколко интервала след реда за импортиране на bodyParser.
// За Passportapp.use(session({ secret:'keyboard cat',resave:true, saveUninitialized:true})); // сесия secretapp.use(passport.initialize());app.use(passport.session()); // постоянни сесии за влизане Ще започнем да работим по действителното удостоверяване сега.
Ще направим това в четири стъпки:
- Настройте Sequelize с MySQL.
- Създайте потребителския модел.
- Настройте изгледи.
- Напишете паспортна стратегия.
1. Настройте Sequelize с MySQL
Първо, създаваме база данни в MySQL. Дайте му предпочитаното от вас име. В името на този урок, нека създадем база данни с име sequelize_passport в MySQL.
След това настроихме конфигурация за обработка на подробности за DB.
Първо, нека импортираме модула dot-env за обработка на променливи на средата.
Изпълнете това в основната папка на проекта:
npm install --save dotenv
След това го импортираме в главния сървърен файл, server.js, точно под другите импортирания.
var env =require('dotenv').load(); След това създаваме файл в папката на нашия проект и го именуваме .env.
Следващата стъпка, която трябва да следвате, е по избор, ако не използвате Git:
Ще добавим файла .env към вашия .gitignore файл.
Вашият .gitignore файл трябва да изглежда така:
node_modules.env
След това добавяме нашата среда към .env файла, като добавяме този ред:
NODE_ENV='development'
След това създаваме файл config.json, който ще се използва от Sequelize за управление на различни среди.
Първото нещо, което трябва да направите, е да създадете папка с име config в папката на нашия проект. В тази папка създаваме config. json файл. Този файл трябва да бъде игнориран, ако насочвате към хранилище. За да направите това, добавете следния код към вашия .gitignore:
config/config.json
След това поставяме следния код в нашия файл config.json.
{ "development":{ "username":"root", "password":null, "database":"sequelize_passport", "host":"127.0.0.1", "dialect":"mysql" }, "test":{ "username":"", "password":null, "database":"", "host":"", "dialect":"mysql" }, "production":{ "username":"", "парола":нула, "база данни":"", "хост":"127.0.0.1", "диалект":"mysql" }} Не забравяйте да замените стойностите в блока за разработка по-горе с подробности за удостоверяване на вашата база данни.
След това инсталираме sequelize с npm. За да направите това, изпълнете следната команда в основната папка на проекта:
npm install --save sequelize
Сега е време да създадете моделите папка.
Първо, създаваме директория с име app в папката на нашия проект.
Вътре в приложението папка, създаваме нова папка с име модели и създайте нов файл с име index.js в моделите папка.
Във файла index.js поставяме кода по-долу.
"use strict";var fs =require("fs");var path =require("path");var Sequelize =require("sequelize");var env =process.env.NODE_ENV || "development";var config =require(path.join(__dirname, '..', 'config', 'config.json'))[env];var sequelize =new Sequelize(config.database, config.username, config .password, config);var db ={};fs .readdirSync(__dirname) .filter(function(file) { return (file.indexOf(".") !==0) &&(file !=="index. js"); }) .forEach(function(file) { var model =sequelize.import(path.join(__dirname, file)); db[model.name] =model; });Object.keys(db). forEach(function(modelName) { if ("асоцииране" в db[modelName]) { db[modelName].associate(db); }});db.sequelize =sequelize;db.Sequelize =Sequelize;module.exports =db; Този файл се използва за импортиране на всички модели, които поставяме в моделите папка и ги експортирайте.
За да проверим дали всичко е наред, добавяме това в нашия файл server.js.
//Modelsvar models =require("./app/models");//Sync Databaseemodels.sequelize.sync().then(function() { console.log('Хубаво! Базата данни изглежда добре')}) .catch(function(err) { console.log(err, "Нещо се обърка с актуализацията на базата данни!")}); Тук импортираме моделите и след това извикваме функцията Sequelize sync.
Изпълнете това, за да видите дали всичко е наред:
node server.js
Ако получите съобщението „Сайтът работи добре! Базата данни изглежда добре“, значи сте настроили Sequelize успешно.
Ако не, моля, преминете внимателно стъпките по-горе и се опитайте да отстраните проблема с помощ.
2. Създайте потребителски модел
Следващото нещо, което ще направим, е да създадем потребителския модел, който по същество е потребителската таблица. Това ще съдържа основна информация за потребителя.
В нашите модели папка, създаваме файл и го именуваме user.js . Пълният път за този файл трябва да бъде app/models/user.js.
Отворете файла user.js и добавете следния код:
module.exports =function(sequelize, Sequelize) { var User =sequelize.define('user', { id:{ autoIncrement:true, primaryKey:true, type:Sequelize.INTEGER }, име:{ type:Sequelize .STRING, notEmpty:true }, фамилия:{ type:Sequelize.STRING, notEmpty:true }, потребителско име:{ type:Sequelize.TEXT }, about:{ type:Sequelize.TEXT }, имейл:{ type:Sequelize.STRING } , валидиране:{ isEmail:true } }, парола:{ тип:Sequelize.STRING, allowNull:false }, последно_вход:{ тип:Sequelize.DATE }, състояние:{ тип:Sequelize.ENUM('активен', 'неактивен' ), defaultValue:'active' } }); връщане на потребител;} Сега стартирайте:
node server.js
Трябва да видите познатото „Сайтът е на живо. Хубаво! База данни изглежда добре. " съобщение. Това означава, че нашите модели Sequelize са синхронизирани успешно и ако проверите базата си данни, трябва да видите потребителска таблица с посочените колони.
3:Настройка на изгледи
Първо, нека създадем изгледа за регистрация и да го свържем.
Първото нещо, което трябва да направите, е да импортирате модула Express handlebars, който използваме за изгледи в този урок.
Добавете този ред към основния начален файл server.js.
var exphbs = require('express-handlebars')
Вашият блок за импортиране трябва да изглежда така в този момент.
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') След това добавяме следните редове в нашия файл server.js.
//За Handlebarsapp.set('views', './app/views')app.engine('hbs', exphbs({ extname:'.hbs'}));app.set('view engine ', '.hbs'); Сега в папката на нашето приложение създаваме три папки с име views, контролери, и маршрути .
В папката изгледи създаваме файл с име signup. hbs и поставете кода по-долу в него.
След това в нашите контролери папка, създаваме нов файл и го именуваме authcontroller.js.
В този файл поставяме следния контролер за маршрута за регистрация, който ще създадем след малко.
var exports =module.exports ={}exports.signup =function(req, res) { res.render('signup');} След това създаваме маршрут за регистрация. В папката с маршрути създаваме нов файл с име auth.js и след това в този файл импортираме контролера за удостоверяване и дефинираме маршрута за регистрация.
var authController =require('../controllers/authcontroller.js');module.exports =function(app) { app.get('/signup', authController.signup);} Сега ще импортираме този маршрут в нашия server.js и ще предадем приложението като аргумент.
В сървъра, след импортирането на моделите, добавете тези редове:
//Routesvar authRoute =require('./app/routes/auth.js')(app); Изпълнете това:
node server.js
Сега посетете http://localhost:5000/signup и ще видите формуляра за регистрация.
Нека повторим стъпките за формуляра за вход. Както преди, ще създадем файл с име signin.hbs в папката ни изгледи и поставете в нея следния HTML код:
След това добавете контролер за влизане в app/controllers/authcontroller.js.
exports.signin =function(req, res) { res.render('signin');} След това в app/routes/auth.js , добавяме маршрут за влизане по следния начин:
app.get('/signin', authController.signin);
Сега, когато стартирате:
възел server.js
и посетете http://localhost:5000/signin/, трябва да видите формуляра за вход.
Последната и основна стъпка е написването на нашите паспортни стратегии.
4. Напишете стратегия за паспорт
В app/config , създаваме нова папка с име passport.
След това в новата ни папка app/config/passport създаваме нов файл и го именуваме passport.js . Този файл ще съдържа нашите паспортни стратегии.
В passport.js , ще използваме потребителския модел и паспорт.
Първо импортираме bcrypt което ни е необходимо, за да защитим паролите.
var bCrypt = require('bcrypt-nodejs');
След това добавяме блок module.exports като този:
module.exports =функция (паспорт, потребител) {} Вътре в този блок инициализираме локалната стратегия за паспорт и потребителския модел, които ще бъдат предадени като аргумент. Ето как правим това:
module.exports =функция (паспорт, потребител) { var User =потребител; var LocalStrategy =require('passport-local').Strategy;} След това дефинираме нашата персонализирана стратегия с нашия екземпляр на LocalStrategy по следния начин:
passport.use('local-signup', new LocalStrategy( { usernameField:'email', passwordField:'password', passReqToCallback:true // ни позволява да върнем цялата заявка към обратното извикване },)); Сега сме декларирали каква заявка (req ) полета, които са нашите usernameField и passwordField (паспортни променливи).
Последната променлива passReqToCallback ни позволява да предадем цялата заявка към обратното извикване, което е особено полезно за регистриране.
След последната запетая добавяме тази функция за обратно извикване.
функция (заявка, имейл, парола, готово) { } В тази функция ще се справим със съхраняването на данни за потребителя.
Първо, добавяме нашата хеширана функция за генериране на парола във функцията за обратно извикване.
var generateHash =function(password) { return bCrypt.hashSync(password, bCrypt.genSaltSync(8), null); }; След това, използвайки потребителския модел Sequelize, който инициализирахме по-рано като Потребител , проверяваме дали потребителят вече съществува и ако не го добавяме.
User.findOne({ където:{ имейл:имейл }}).then(function(user) { if (user) { return done(null, false, { message:'Този имейл вече е зает' }); } else { var userPassword =generateHash(парола); var data ={ имейл:имейл, парола:userPassword, първо име:req.body.firstname, фамилия:req.body.lastname }; User.create(data).then(function (newUser, created) { if (!newUser) { return done(null, false); } if (newUser) { return done(null, newUser); } }); }});
User.create() е метод Sequelize за добавяне на нови записи към базата данни. Забележете, че стойностите в данните обектът се получава от req.body обект, който съдържа входа от нашия формуляр за регистрация.
Вашият passport.js трябва да изглежда така:
//load bcryptvar bCrypt =require('bcrypt-nodejs');module.exports =function(passport, user) { var User =потребител; var LocalStrategy =require('passport-local').Strategy; passport.use('local-signup', new LocalStrategy( { usernameField:'email', passwordField:'password', passReqToCallback:true // ни позволява да върнем цялата заявка към обратното извикване }, function(req, email, парола, готово) { var generateHash =function(password) { return bCrypt.hashSync(password, bCrypt.genSaltSync(8), null); }; User.findOne({ където:{ имейл:имейл } }).then(function (user) { if (user) { return done(null, false, { message:'Този имейл вече е зает' }); } else { var userPassword =generateHash(password); var data ={ имейл:имейл, парола:потребителска парола, име:req.body.firstname, фамилия:req.body.lastname }; User.create(data).then(function(newUser, created) { if (!newUser) { return done(null, false); } if (newUser) { return done(null, newUser); } }); } }); } ));} Сега ще импортираме стратегията в server.js.
За да направите това, добавяме тези редове под импортирането на маршрути в server.js.
//load passport strategiesrequire('./app/config/passport/passport.js')(passport, models.user); Вашият server.js трябва да изглежда така:
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')//За BodyParserapp.use(bodyParser.urlencoded({ extended:true}));app.use(bodyParser.json( ));// За Passportapp.use(session({ secret:'keyboard cat', resave:true, saveUninitialized:true})); // сесия secretapp.use(passport.initialize());app.use(passport.session()); // постоянни сесии за влизане//За Handlebarsapp.set('views', './app/views')app.engine('hbs', exphbs({ extname:'.hbs'}));app.set(' view engine', '.hbs');app.get('/', function(req, res) { res.send('Добре дошли в Passport with Sequelize');});//Modelsvar models =require(". /app/models");//Routesvar authRoute =require('./app/routes/auth.js')(app);//load passport strategiesrequire('./app/config/passport/passport.js') (passport, models.user);//Sync Databaseemodels.sequelize.sync().then(function() { console.log('Хубаво! Базата данни изглежда добре')}).catch(function(err) { console.log (err, "Нещо се обърка с актуализацията на базата данни!")});app.listen(5000, function(err) { if (!err) console.log("Сайтът е на живо"); else console.log(err )}); Сега всъщност ще приложим стратегията към нашия /signup маршрут.
Ето как правим това:
Първо отиваме на app/routes/auth.js , и добавете маршрут за публикуване, за да се регистрирате по този начин.
app.post('/signup', passport.authenticate('local-signup', { successRedirect:'/dashboard', failRedirect:'/signup' })); Тъй като имаме нужда от паспорт, трябва да го предадем на този метод. Можем да импортираме паспорт в този скрипт или да го предадем от server.js. Нека направим последното.
Променете функцията, експортирана в този файл app/routes/auth.js да има паспорт като параметър. Кодът в app/routes/auth.js трябва да изглежда така след вашата модификация.
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', failRedirect:'/signup' } ));} След това в server.js , ние променяме импортирането на маршрути и добавяме паспорт като аргумент по следния начин:
var authRoute = require('./app/routes/auth.js')(app,passport);
Сега отидете на URL адреса за регистрация http://localhost:5000/signup/ и опитайте да се регистрирате.
Когато се опитате да се регистрирате, ще получите грешка „Неуспешно сериализиране на потребителя в сесия ". Това е така, защото паспортът трябва да запази потребителски идентификатор в сесията и го използва, за да управлява извличането на потребителските данни, когато е необходимо.
За да разрешим това, ще внедрим както функциите за сериализиране, така и за десериализиране на паспорта в нашия app/config/passport/passport.js файл.
Първо добавяме функцията за сериализиране. В тази функция ще запазим идентификатора на потребителя към сесията.
За да направите това, добавяме следните редове под инициализацията на локалната стратегия.
//serializepassport.serializeUser(function(user, done) { done(null, user.id);}); След това изпълняваме функцията десериализиране. Добавете функцията точно под функцията за сериализиране.
// десериализира потребителя passport.deserializeUser(function(id, done) { User.findById(id).then(function(user) { if (user) { done(null, user.get()); } else { done(user.errors, null); } });});
Във функцията за десериализиране по-горе ние използваме Sequelize findById обещаете да получите потребителя и ако е успешен, се връща екземпляр на модела Sequelize. За да получим обекта User от този екземпляр, ние използваме функцията Sequelize getter по следния начин:user.get() .
Сега стартирайте отново:
node server.js
И опитайте да се регистрирате. Ура, ако имате "Cannot GET /dashboard"! Това означава, че нашата автентификация е била успешна. Не забравяйте, че пренасочихме към /dashboard в нашия метод passport.authenticate в routes/auth.js .
Сега нека да продължим и да добавим този маршрут. След това добавете междинен софтуер, за да сте сигурни, че страницата може да бъде достъпна само когато потребител е влязъл в сесията.
В нашето приложение/изгледи папка, създаваме нов файл с име dashboard.hbs и добавете следния HTML код в него.
Паспорт със Sequelize Табло за управление
Ура! влезли сте.
В routes/auth.js , добавяме този ред вътре в module.exports блок:
app.get('/dashboard',authController.dashboard);
След това отиваме в app/controllers/authController.js и добавете контролера на таблото.
exports.dashboard =function(req, res) { res.render('dashboard');} Вашият AuthController.js трябва да изглежда така:
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');} Сега стартирайте приложението отново и се опитайте да се регистрирате с различен имейл адрес от този, който сте използвали по-рано. Ще бъдете подходящо пренасочени към /таблото за управление маршрут.
Но /табло за управление не е защитен маршрут, което означава, че дори ако потребителят не е влязъл, той може да го види. Не искаме това, така че ще добавим /logout маршрут, за да излезете от потребителя и след това да защитите маршрута и да тестваме какво сме направили.
Нека направим това:
В routes/auth.js добавяме този ред:
app.get('/logout',authController.logout);
След това добавяме контролера в app/controllers/authController.js.
exports.logout =function(req, res) { req.session.destroy(function(err) { res.redirect('/'); }); } Сега стартирайте приложението отново и се регистрирайте с друг имейл адрес.
След това посетете http://localhost:5000/logout, за да излезете от потребителя. Сега посетете http://localhost:5000/dashboard.
Ще забележите, че е доста достъпен. Нека добавим персонализиран междинен софтуер, за да защитим този маршрут.
За да направите това, отваряме app/routes/auth.js и добавете тази функция в module.exports блок, под всички останали редове код.
function isLoggedIn(req, res, next) { if (req.isAuthenticated()) return next(); res.redirect('/signin');} След това модифицираме манипулатора на маршрута на таблото, за да изглежда така:
app.get('/dashboard',isLoggedIn, authController.dashboard);
Сега, когато стартирате приложението отново и се опитате да посетите страницата на таблото за управление и не сте влезли, трябва да бъдете пренасочени към страницата за вход.
Уви! Време е да приложим последната част:влизането.
Първо, ще добавим нова локална стратегия за влизане в app/config/passport/passport.js .
//LOCAL SIGNINpassport.use('local-signin', new LocalStrategy( { // по подразбиране локалната стратегия използва потребителско име и парола, ние ще заменим с имейл usernameField:'email', passwordField:'password', passReqToCallback :true // ни позволява да върнем цялата заявка към обратното извикване }, function(req, email, password, done) { var User =user; var isValidPassword =function(userpass, password) { return bCrypt.compareSync(password, userpass); } User.findOne({ където:{ имейл:имейл } }).then(function(user) { if (!user) { return done(null, false, { message:'Email не съществува' }); } if (!isValidPassword(user.password, парола)) { return done(null, false, { message:'Неправилна парола.' }); } var userinfo =user. get(); върнете готово (нула, потребителска информация); }).catch(function(err) { console.log("Грешка:", err); return done(null, false, { message:'Нещо се обърка с вашето влизане' }); }); }));
В тази стратегия, isValidPassword функцията сравнява паролата, въведена с метода за сравнение bCrypt, тъй като ние съхранихме паролата си с bcrypt .
Ако данните са правилни, нашият потребител ще бъде влязъл.
Сега отидете на routes/auth.js и добавете маршрута за публикуване към / влизане.
app.post('/signin', passport.authenticate('local-signin', { successRedirect:'/dashboard', failRedirect:'/signin' })); Вашите routes/auth.js трябва да изглеждат така, когато сте готови.
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', failRedirect:'/signup' } )); app.get('/dashboard', isLoggedIn, authController.dashboard); app.get('/logout', authController.logout); app.post('/signin', passport.authenticate('local-signin', { successRedirect:'/dashboard', failRedirect:'/signin' } )); function isLoggedIn(req, res, next) { if (req.isAuthenticated()) return next(); res.redirect('/signin'); }} Сега стартирайте приложението и опитайте да влезете. Трябва да можете да влезете с която и да е от данните, които сте използвали при регистрацията, и ще бъдете насочени към http ://localhost:5000/dashboard/.
Поздравления, ако сте стигнали до края на този урок! Използвахме успешно Sequelize и Passport с MySQL база данни.
Пълният код за този урок може да бъде намерен на GitHub.
