Share
Sequelize este o promisiune bazată pe Node.js ORM. Poate fi folosit cu PostgreSQL, MySQL, MariaDB, SQLite și MSSQL. În acest tutorial, vom implementa autentificarea pentru utilizatorii unei aplicații web. Și vom folosi Passport, mijlocul de autentificare popular pentru Node, împreună cu Sequelize și MySQL pentru implementarea înregistrării utilizatorilor și autentificare.
Asigurați-vă că ați instalat pe aparat următoarele:
Pentru acest tutorial, vom folosi Node.js împreună cu Express, deci mergem mai departe și începem să instalăm ceea ce avem nevoie.
Creați un director pentru aplicația dvs. În acest director, executați acest lucru din terminalul sau din linia de comandă:
npm init
Aceasta inițiază Managerul de dependență npm. Aceasta va prezenta o serie de solicitări pe care le vom trece repede.
Principalele dependențe pentru acest tutorial sunt:
Pentru a le instala, din terminal sau din linia de comandă, executați una după alta.
npm instalare expres --save npm instalare continuă - salvează npm instalează mysql - salvează npm instalează pașaport - salvează npm instalează pașaport - local - salvează npm instalează parser - salvează npm instalează sesiunea de expediere --save npm instalează bcrypt-nodejs - salvați npm install express-handlebars - salvați
Dacă utilizați Git pentru acest proiect:
În dosarul proiectului creați un fișier .gitignore.
Adăugați această linie în fișierul .gitignore.
node_modules
Acum, creăm un fișier de server. Acesta va fi fișierul principal numit atunci când tastați următoarele:
npm start
Aceasta rulează aplicația. De asemenea, puteți rula aplicația introducând nodul server.js.
nod server.js
Apoi, în dosarul nostru de proiect, vom crea un nou fișier și vom numi acest fișier server.js.
În interiorul server.js fișier, vom lipi următoarele:
Accentsconagua
var express = necesită ("expres"); var app = expres (); app.get ('/', funcția (req, res) res.send ('Bine ați venit la pașaport cu secvență');); app.listen (5000, funcția (err) if (! err) console.log ("Site-ul este live"); altceva console.log (err));Prima linie atribuie modulul expres unei expresii variabile. Apoi inițializăm expres și numim o variabilă: app.
Apoi facem aplicația să asculte în port 5000. Puteți alege orice număr de port gratuit de pe computer.
Apoi, numim app.get () Explicați funcția de rutare pentru a răspunde cu "Bine ați venit la pașaport cu secvențe" atunci când se face o solicitare GET la "/".
Pentru a testa computerul, executați acest lucru din interiorul folderului proiectului:
nod server.js
Dacă vedeți textul "Bine ați venit la pașaport cu secvențe" atunci când vizitați http: // localhost: 5000 / apoi felicitări! În caz contrar, verificați dacă ați făcut totul exact așa cum este scris mai sus.
Apoi, importăm câteva module de care avem nevoie, cum ar fi pașaportul, sesiunea de expresie și parserul corporal.
După var app = expres () adăugăm următoarele rânduri:
var passport = necesită ('pașaport') var sesiune = necesită ('sesiune expres') var bodyParser = necesită ('body-parser')În primele două rânduri, importăm modulul de pașapoarte și sesiunea expresă, ambele cărora trebuie să ne ocupăm de autentificare.
Apoi, importăm modulul parser-corp. Aceasta extrage întreaga parte a corpului unei cereri de intrare și o expune într-un format cu care este mai ușor să lucrați. În acest caz, vom folosi formatul JSON.
Pentru a permite aplicației noastre să utilizeze parserul corporal, adăugăm aceste linii în câteva spații sub liniile de import:
// Pentru aplicația BodyParser app.use (bodyParser.urlencoded (extended: true)); app.use (bodyParser.json ());
Apoi, inițializăm pașaportul și sesiunea expresă și pașaportul și le adăugăm amândouă ca middleware. Facem acest lucru adăugând aceste linii în câteva spații după linia de import a corpului.
// Pentru aplicația Passport (sesiune (secret: 'keyboard cat', resave: true, saveUninitialized: true)); // secret app.use pentru sesiune (passport.initialize ()); app.use (passport.session ()); // sesiuni de conectare persistente
Vom începe să lucrăm la autentificarea reală acum.
O vom face în patru etape:
Mai întâi, vom crea o bază de date în MySQL. Dă-i numele preferat. De dragul acestui tutorial, să creăm o bază de date numită sequelize_passport în MySQL.
Apoi am setat configurația pentru a gestiona detaliile DB.
Mai întâi, să importăm modulul dot-env pentru a gestiona variabilele de mediu.
Rulați acest lucru în folderul de proiect rădăcină:
npm instalează - sune dotenv
Apoi îl importăm în fișierul server principal, server.js, chiar sub celelalte importuri.
var env = necesită ('dotenv') sarcină (); Apoi, vom crea un fișier în folderul nostru de proiect și îl vom numi .env.
Următorul pas de urmat este opțional dacă nu utilizați Git:
Vom adăuga fișierul .env în fișierul .gitignore.
Fișierul .gitignore ar trebui să arate astfel:
node_modules .env
După aceasta, adăugăm mediul nostru în fișierul .env adăugând această linie:
NODE_ENV = 'dezvoltare'
Apoi vom crea un fișier config.json care va fi folosit de Sequelize pentru a gestiona medii diferite.
Primul lucru pe care trebuie să-l faceți este să creați un folder numit config în dosarul nostru de proiect. În interiorul acestui dosar, creăm un config.JSON fişier. Acest fișier ar trebui ignorat dacă împingeți într-un depozit. Pentru a face acest lucru, adăugați următorul cod la .gitignore:
config / config.json
Apoi, inserăm următorul cod în fișierul nostru config.json.
"development": "nume de utilizator": "root", "parola": null, "database": "sequelize_passport", "host": "127.0.0.1" : "" nume de utilizator: "" nume utilizator ":" "nume de utilizator:" " "parola": null, "baza de date": "", "gazdă": "127.0.0.1", "dialect": "mysql"
Nu uitați să înlocuiți valorile din blocul de dezvoltare de mai sus cu detaliile de autentificare a bazei dvs. de date.
Apoi, vom instala sequelize cu npm. Pentru a face acest lucru, executați următoarea comandă în folderul rădăcină al proiectului:
npm install - salvează continuu
Acum este momentul să creați modele pliant.
Mai întâi, facem un director numit aplicaţia în dosarul nostru de proiect.
În interiorul aplicaţia folder, vom crea un nou folder numit modele și să creați un nou fișier numit index.js în modele pliant.
În fișierul index.js, inserăm codul de mai jos.
"folosiți stricte"; var fs = cer ("fs"); var path = necesită ("cale"); var Sequelize = necesită ("sequel"); var env = process.env.NODE_ENV || "dezvoltare"; var config = necesită (path.join (__ dirname, '...', 'config', 'config.json')) [env]; var sequelize = nou Sequelize (config.database, config.username, config.password, config); var db = ; fs .readdirSync (nume fișier) .filter (funcția (fișier)) return (fișier.indexOf (".")! == 0) && (fișier! == "index.js" ) var model = sequelize.import (path.join (__ dirname, fișier)); db [model.name] = model;); Object.keys (db) .forEach (funcția (modelName) if ("asociat" în db [modelName]) db [modelName] .associate (db);); db.sequelize = continuare; db.Sequelize = Sequelize; module.exports = db;Acest fișier este folosit pentru a importa toate modelele pe care le plasăm în modele și exportați-le.
Pentru a testa că totul este bine, adăugăm acest lucru în fișierul server.js.
// Modele var models = necesită ("./ app / models"); // Sincronizare baze de date models.sequelize.sync (), apoi (functie () console.log ('Nice! Database looks fine')) catch (function (err) console.log cu actualizarea bazei de date! "));Aici, importem modelele și apoi sunăm funcția de sincronizare Sequelize.
Rulați acest lucru pentru a vedea dacă totul este bine:
nod server.js
Dacă primiți mesajul "Site-ul este live Nisa! Baza de date pare bine", atunci ați configurat succes Sequelize.
Dacă nu, treceți cu atenție la pașii de mai sus și încercați să depanați problema cu ajutor.
Următorul lucru pe care îl vom face este să creăm modelul de utilizator, care este, în principiu, tabelul utilizatorilor. Aceasta va conține informații de bază despre utilizator.
În a noastră modele dosar, vom crea un fișier și îl vom numi user.js. Calea completă pentru acest fișier ar trebui să fie app / modele / user.js.
Deschideți fișierul user.js și adăugați următorul cod:
(id: autoIncrement: true, primaryKey: true, type: Sequelize.INTEGER, nume: type: Sequelize.STRING, notă: true: nume: type: Sequelize.STRING, notEmpty: true, username: type: Sequelize.TEXT, despre: type: Sequelize.TEXT, email: type: Sequelize.STRING, validate: isEmail: true, parola: type: Sequelize.STRING, allowNull: false, last_login: type: Sequelize.DATE, status: type: Sequelize.ENUM : "activ"); returnează Utilizatorul;
Acum rulați:
nod server.js
Ar trebui să vedeți familiarul "Site-ul este live. Frumos! Bază de date arată bine.", ceea ce înseamnă că modelele noastre Sequelize au fost sincronizate cu succes și dacă verificați baza de date ar trebui să vedeți un tabel de utilizatori cu coloanele specificate în prezent.
Mai întâi, să creăm vizualizarea pentru înscriere și să o conectăm.
Primul lucru pe care trebuie să-l importați este importul modulului express handlebars pe care îl folosim pentru vizualizări în acest tutorial.
Adăugați această linie în fișierul principal de pornire, server.js.
var exphbs = necesită ("ghidon expres")
Blocul dvs. de import ar trebui să arate așa în acest moment.
var express = necesită ('express') var var = necesită ('paragraf var') var env = ("dotenv") load () var exphbs = necesită ("ghidon expres")Apoi, adăugăm următoarele rânduri în fișierul server.js.
// Pentru aplicațiile de la Handlebars ('views', './app/views') app.engine ('hbs', exphbs (extname: '.hbs')); app.set ("motor de vizualizare", ".hbs");Acum, în dosarul nostru de aplicații, creăm trei dosare numite vizualizari, controlere, și rute.
În dosarul de vizualizări, creăm un fișier numit Inscrie-te.HBS și lipiți codul de mai jos.
Apoi, în nostru controlere , vom crea un fișier nou și îl vom numi authcontroller.js.
În acest fișier, inserăm următorul controler pentru ruta de înscriere pe care o vom crea într-un moment.
var export = modul.exports = exports.signup = funcția (req, res) res.render ('signup'); Apoi, vom crea o rută pentru înscriere. În directorul de rute, creăm un nou fișier numit auth.js și apoi, în acest fișier, importăm controlerul auth și definim traseul de înscriere.
var authController = cer ('... /controllers/authcontroller.js'); module.exports = funcție (aplicație) app.get ('/ signup', authController.signup); Acum, vom importa această rută în server.js și vom trece ca argument un argument.
În server, după importarea modelelor, adăugați următoarele linii:
// Routes var authRoute = necesită ('./ app / routes / auth.js') (app);Rulați acest lucru:
nod server.js
Acum, vizitați http: // localhost: 5000 / signup și veți vedea formularul de înscriere.
Să repetăm pașii pentru formularul de conectare. Ca și înainte, vom crea un fișier numit signin.hbs în dosarul nostru de vizualizări și inserați în el următorul cod HTML:
Apoi, adăugați un controler pentru conectare app / controlere / authcontroller.js.
exports.signin = funcția (req, res) res.render ('signin'); Apoi în app / rute / auth.js, adăugăm un traseu pentru conectare în felul următor:
app.get ('/ signin', authController.signin);
Acum când alergi:
nod server.js
și vizitați http: // localhost: 5000 / signin /, ar trebui să vedeți formularul de conectare.
Pasul final și major este scrierea strategiilor noastre privind pașapoartele.
În app / config, vom crea un nou dosar numit pașaport.
Apoi, în noul folder app / config / passport, vom crea un fișier nou și îl vom numi passport.js. Acest fișier va conține strategiile noastre privind pașapoartele.
În passport.js, vom folosi modelul de utilizator și pașaportul.
Mai întâi, importăm bcrypt care avem nevoie pentru a asigura parole.
var bCrypt = necesită ('bcrypt-nodejs');
Apoi, adăugăm un bloc modul.exports, astfel:
module.exports = funcție (pașaport, utilizator)
În interiorul acestui bloc, inițializăm strategia pașaport locală și modelul de utilizator, care va fi trecut ca argument. Iată cum facem acest lucru:
module.exports = funcție (pașaport, utilizator) var User = user; var LocalStrategy = necesită ("pașaport-local"). Strategie; Apoi definim strategia personalizată cu instanța noastră a LocalStrategy astfel:
passport.use ("local-signup", noul LocalStrategy (usernameField: 'email', passwordField: 'password', passReqToCallback: true // ne permite să transmitem întreaga solicitare apelului;));Acum am afirmat ce solicitare (req) Câmpurile noastre usernameField și passwordField (variabilele pașaportului) sunt.
Ultima variabilă passReqToCallback ne permite să transmitem întreaga solicitare apelului invers, ceea ce este deosebit de util pentru înregistrarea.
După ultima virgulă, adăugăm această funcție de apel invers.
(req, e-mail, parolă, terminat)
În această funcție, vom gestiona stocarea detaliilor unui utilizator.
Mai întâi, adăugăm funcția de generare a parolei rulate în interiorul funcției de apel invers.
var generateHash = funcția (parola) return bCrypt.hashSync (parola, bCrypt.genSaltSync (8), null); ;
Apoi, folosind modelul de utilizator Sequelize, am inițializat mai devreme Utilizator, verificăm dacă utilizatorul există deja și dacă nu îi adăugăm.
User.findOne (unde: e-mail: e-mail), apoi (funcția (utilizator) if (user) return (done, false, message: var userPassword = generateHash (parola); var data = email: email, parola: userPassword, nume: req.body.firstname, lastname: req.body.lastname; User.create (data) creat) if (! newUser) retur done (null, false); if (newUser) return done (null, newUser);););
User.create () este o metodă Sequelize pentru adăugarea de intrări noi în baza de date. Observați că valorile din date obiect sunt obținute de la req.body obiect care conține intrarea din formularul de înscriere.
Ta passport.js ar trebui să arate astfel:
// încărcați bcrypt var bCrypt = necesită ('bcrypt-nodejs'); module.exports = funcție (pașaport, utilizator) var User = user; var LocalStrategy = necesită ("pașaport-local"). Strategie; passport.use ('local-signup', noul LocalStrategy (usernameField: 'email', passwordField: 'password', passReqToCallback: true // ne permite sa transmitem intreaga cerere catre callback, parola, terminată) var generateHash = funcția (parola) return bCrypt.hashSync (parola, bCrypt.genSaltSync (8), null); User.findOne ( (utilizator) if (utilizator) retur făcut (null, false, message: 'E-mailul a fost deja luat'); else var userPassword = generateHash (password); var data = Nume utilizator: nume_req.body.lastname; User.create (data) .then (functie (newUser, creat) if (! newUser) retur done (null, false); dacă (newUser) retur done (null, newUser);););)); Acum vom importa strategia în server.js.
Pentru a face acest lucru, adăugăm aceste linii sub importul de rute în server.js.
// încărcați strategiile pașaportului solicitați ('./ap/config/passport/passport.js') (pașaport, models.user);Server.js ar trebui să arate astfel în acest moment:
var express = necesită ('express') var var = necesită ('paragraf var') var env = ('dotenv') load () var exphbs = necesită ('express-handlebars') // Pentru aplicația BodyParser app.use (bodyParser.urlencoded (extended: true)); app.use (bodyParser.json ()); // Pentru aplicația Passport (sesiune (secret: 'keyboard cat', resave: true, saveUninitialized: true)); // secret app.use pentru sesiune (passport.initialize ()); app.use (passport.session ()); // sesiuni persistente de conectare // Pentru applesetul Handlebars ('views', './app/views') app.engine ('hbs', exbbs (extname: '.hbs')); app.set ("motor de vizualizare", ".hbs"); app.get ('/', funcția (req, res) res.send ('Bine ați venit la pașaport cu secvență');); // Modele var models = necesită ("./ app / models"); // Routes var authRoute = necesită ('./ app / routes / auth.js') (app); // încărcați strategiile pașaportului solicitați ('./ap/config/passport/passport.js') (pașaport, models.user); // Sincronizare baze de date models.sequelize.sync (), apoi (functie () console.log ('Nice! Database looks fine')) catch (function (err) console.log cu actualizarea bazei de date! ")); app.listen (5000, funcția (err) if (! err) console.log ("Site-ul este live"); altceva console.log (err));Acum vom aplica strategia noastră /Inscrie-te traseu.
Iată cum facem acest lucru:
În primul rând, mergem la app / rute / auth.js, și adăugați un traseu pentru postarea la înscriere ca acesta.
app.post ('/ signup', passport.authenticate ('local-signup', successRedirect: '/ dashboard', failureRedirect: '/ signup'));Deoarece avem nevoie de pașaport, trebuie să-l transmitem acestei metode. Putem importa pașaport în acest script sau îl vom putea transfera de la server.js. Să o facem pe acesta din urmă.
Modificați funcția exportată în acest fișier app / rute / auth.js să aveți pașaport ca parametru. Codul din app / rute / auth.js ar trebui să arate așa după modificarea dvs..
var authController = cer ('... /controllers/authcontroller.js'); module.exports = funcție (aplicație, pașaport) app.get ('/ signup', authController.signup); app.get ('/ signin', authController.signin); app.post ('/ signup', passport.authenticate ('local-signup', successRedirect: '/ dashboard', failureRedirect: '/ signup')); Apoi în server.js, modificăm importul rutelor și adăugăm pașaportul ca un argument ca acesta:
var authRoute = necesită ('./ app / routes / auth.js') (aplicație, pașaport);
Acum, mergeți la URL-ul de înregistrare http: // localhost: 5000 / signup / și încercați să vă înscrieți.
Când încercați să vă înscrieți, veți primi o eroare "Nu sa reușit serializarea utilizatorului în sesiune"Acest lucru se datorează faptului că pașaportul trebuie să salveze un ID de utilizator în sesiune și utilizează acest lucru pentru a gestiona recuperarea detaliilor utilizatorului când este necesar.
Pentru a rezolva acest lucru, vom implementa atât serializarea, cât și deserializarea funcțiilor de pașaport în cadrul nostru app / config / pașaport / passport.js fişier.
Mai întâi adăugăm funcția de serializare. În această funcție, vom salva numele de utilizator la sesiune.
Pentru a face acest lucru, adăugăm următoarele linii sub inițializarea strategiei locale.
// serialize passport.serializeUser (funcția (user, done) done (null, user.id););
Apoi implementăm funcția de deserializare. Adăugați funcția chiar sub funcția de serializare.
// deserializeaza utilizator passport.deserializeUser (functie (id, done) User.findById (id) .then (functie (user) if (user) done (null, user.get user.errors, null);););
În funcția de deserializare de mai sus, folosim secvența Sequelize findById promite să primească utilizatorul și, dacă este reușit, se returnează o instanță a modelului Sequelize. Pentru a obține obiectul Utilizator din această instanță, folosim funcția Sequelize getter astfel: user.get ().
Acum rulați din nou:
nod server.js
Și încercați să vă înscrieți. Încearcă dacă ai primit "Nu poți / tabloul de bord"! Aceasta înseamnă că autentificarea noastră a avut succes. Amintiți-vă că am redirecționat în / tabloul de bord în pasaportul nostru de autentificare rute / auth.js.
Acum să mergem mai departe și să adăugăm acea cale. Apoi, adăugați un middleware pentru a vă asigura că pagina poate fi accesată numai când un utilizator este conectat la sesiune.
În a noastră app / vizualizări folder, vom crea un nou fișier numit dashboard.hbs și adăugați următorul cod HTML în el.
Pașaport cu Sequelize Tablou de bord
Ura! ești logat.
În rute / auth.js, adăugăm această linie în interiorul module.exports bloc:
app.get ( '/ tablou de bord', authController.dashboard);
Apoi, mergem la app / controlere / authController.js și adăugați controlerul de bord.
exports.dashboard = funcția (req, res) res.render ('dashboard'); AuthController.js dvs. ar trebui să arate astfel:
var export = modul.exports = exports.signup = funcția (req, res) res.render ('signup'); exports.signin = funcția (req, res) res.render ('signin'); exports.dashboard = funcția (req, res) res.render ('tabloul de bord'); Acum, rulați din nou aplicația și încercați să vă înscrieți cu o altă adresă de e-mail decât cea utilizată anterior. Veți fi redirecționat în mod corespunzător la /tablou de bord traseu.
Dar /tablou de bord nu este o rută protejată, ceea ce înseamnă că, chiar dacă un utilizator nu este conectat, îl poate vedea. Nu vrem asta, așa că vom adăuga a / logout pentru a loga utilizatorul afară, apoi pentru a proteja traseul și pentru a testa ceea ce am făcut.
Să o facem:
În rute / auth.js adăugăm această linie:
app.get ( '/ logout', authController.logout);
Apoi adăugăm controlerul în app / controllers / authController.js.
exports.logout = funcția (req, res) req.session.destroy (funcția (err) res.redirect ('/');); Acum rulați aplicația din nou și înregistrați-vă cu o altă adresă de e-mail.
După aceasta, accesați http: // localhost: 5000 / logout pentru a loga utilizatorul. Vizitați acum http: // localhost: 5000 / dashboard.
Veți observa că este destul de accesibil. Să adăugăm un middleware personalizat pentru a proteja acel traseu.
Pentru a face acest lucru, ne deschidem app / routes / auth.js și adăugați această funcție în module.exports bloc, sub toate celelalte linii de cod.
funcția isLoggedIn (req, res, următorul) if (req.isAuthenticated ()) return (); res.redirect ( '/ signin');
Apoi, modificăm modul de tratare a rutului de bord pentru a arăta astfel:
app.get ('/ tablou de bord', isLoggedIn, authController.dashboard);
Acum, când rulați din nou aplicația și încercați să vizitați pagina tabloului de bord și nu sunteți conectat (ă), ar trebui să fiți redirecționat (ă) la pagina de conectare.
Uau! Este timpul să punem în aplicare partea finală: conectarea.
Mai întâi, vom adăuga o nouă strategie locală pentru conectare app / config / pașaport / passport.js.
// LOCAL SIGNIN passport.use ("local-signin", noul LocalStrategy (// implicit, strategia locală folosește numele de utilizator și parola, vom suprascrie cu email usernameField: 'email', passwordField: 'password', passReqToCallback: true // permite utilizatorului să transmită întreaga solicitare la apelul de apel, funcția (req, e-mail, parola, terminată) var User = utilizator; var isValidPassword = funcția (userpass, password) return bCrypt.compareSync (password, userpass) ; User.findOne (unde: email: e-mail), apoi (funcția (user) if (! User) returned done (null, false, message: dacă isValidPassword (user.password, password)) retur făcut (null, false, message: 'parola incorectă'); var userinfo = user.get (); ) .catch (funcția (err) console.log ("Eroare:", err); returnat făcut (null, false, message: 'În această strategie,isValidPasswordfuncția compară parola introdusă cu metoda de comparare bCrypt, deoarece ne-am stocat parola bcrypt.
Dacă detaliile sunt corecte, utilizatorul nostru va fi conectat.
Acum du-te la rute / auth.js și adăugați ruta pentru afișare la /conectare.
app.post ('/ signin', passport.authenticate ('local-signin', successRedirect: '/ dashboard', failureRedirect: '/ signin'));Traseele dvs. / auth.js ar trebui să arate așa după ce ați terminat.
var authController = cer ('... /controllers/authcontroller.js'); module.exports = funcție (aplicație, pașaport) app.get ('/ signup', authController.signup); app.get ('/ signin', authController.signin); app.post ('/ signup', passport.authenticate ('local-signup', successRedirect: '/ dashboard', failureRedirect: '/ signup')); app.get ('/ tablou de bord', isLoggedIn, authController.dashboard); app.get ('/ logout', authController.logout); app.post ('/ signin', passport.authenticate ('local-signin', successRedirect: '/ dashboard', failureRedirect: '/ signin')); funcția isLoggedIn (req, res, următorul) if (req.isAuthenticated ()) return (); res.redirect ( '/ signin'); Acum rulați aplicația și încercați să vă conectați. Trebuie să vă puteți conecta cu oricare dintre detaliile pe care le-ați utilizat în timpul înscrierii și veți fi direcționat (ă) la http: // localhost: 5000 / tablou de bord /.
Felicitări dacă ați reușit până la sfârșitul acestui tutorial! Am folosit cu succes Sequelize și Passport cu o bază de date MySQL.
Codul complet pentru acest tutorial poate fi găsit pe GitHub.
Acest lucru încheie tutorialul nostru cu privire la utilizarea Passport pentru autentificarea utilizatorilor cu Sequelize și MySQL. Sequelize este un ORM cu adevărat util pentru a se ocupa de MySQL atunci când se utilizează Nodul. Am descoperit personal că este foarte util și ar trebui să luați în considerare utilizarea acestuia în aplicația Node-MySQL următoare.
