Menggunakan Passport dengan Sequelize dan MySQL

Sequelize adalah ORM Node.js yang berbasis promise. Ini bisa digunakan dengan PostgreSQL, MySQL, MariaDB, SQLite, dan MSSQL. Dalam tutorial ini, kita akan mengimplementasikan otentikasi untuk pengguna dengan aplikasi situs. Dan kita akan menggunakan Passport, otentikasi yang populer dengan node, bersama dengan Sequelize dan MySQL untuk mengimplementasikan registrasi dan login pengguna.

Memulai

Pastikan kamu telah memiliki hal di bawah ini terpasang:

• Node
• MySQL

Di tutorial ini, kita akan menggunakan Node.js bersama dengan Express, mari lanjut ke memasang yang kita butuhkan.

Tahap 1: Membuat berkas package.json

Membuat direktori untuk aplikasimu. Di dalam direktori tersebut, jalankanlah memalui terminal atau command prompt:

1

 npm init

Ini akan memunculkan npm Dependency Manager. Ini akan menghadirkan serangkain perinta yang bisa digunakan secara cepat.

• Tulis dari nama aplikasimu tanpa spasi dan tekan Enter untuk 'name'
• Tekan Enter untuk 'version'
• Untuk 'description', di tutorial ini kita akan menulis "menggunakan passport dengan Sequelize and MySQL" sebagai deskripsi dan tekan Enter. Ini juga bisa dibiarkan kosong.
• Untuk 'entry point (index.js)' ketik server.js dan tekan Enter.
• Untuk 'text commnad', tekan Enter
• Untuk 'git repository', kamu bisa memasukkan git repo di mana aplikasimu berada. Jika kamu hanya memiliki satu maka biarkan saja kosong dan tekan Enter.
• Untuk 'keywords', tekan Enter.
• Untuk 'author', tekan Enter atau ketik nama.
• Untuk 'license' tekan Enter.
• Untuk '(Is this okay)', dia menampilkan paket jsonmu akan terlihat seperti apa. Ketik Yes dan tekan Enter.

Tahap 2: Memasang Dependensi.

Dependensi utama dari tutorial ini adalah:

• Express
• Sequelize
• MySQL
• Passport
• Passport Local Strategy
• Body Parser
• Express Session
• Bcrypt Nodejs
• Express Handlebars for the views

Untuk memasangnya, dari terminal atau command prompt jalan kode di bawah ini satu persatu.

1

npm install express --save

2

3

npm install sequelize --save

4

5

npm install mysql --save

6

7

npm install passport --save

8

9

npm install passport-local --save

10

11

npm install body-parser --save

12

13

npm install express-session --save

14

15

npm install bcrypt-nodejs --save

16

17

npm install express-handlebars --save

Jika kamu menggunakan Git di proyek ini:

Di dalam folder proyek buat sebuah berkas .gitignore

Tambahkan baris berikut ke berkas .gitignore.

node_modules

Tahap 3: Mempersiapkan Aplikasi

Sekarang, kita akan membuat berkas server. Ini akan menjadi berkas utama yang dipanggil ketika kamu mengetik berikut:

1

npm start

Akan menjalankan aplikasinya. Kamu juga bisa menjalankan aplikasi dengan mengetik node server.js.

1

node server.js

Lalu, dalam folder proyek, kita membuat berkas baru dan dinamai server.js

Di dalam berkas server.js, kita akan memasukkan berikut:

1

var express = require('express');

2

var app = express();

3

4

5

app.get('/', function(req, res) {

6

7

    res.send('Welcome to Passport with Sequelize');

8

9

});

10

11

12

app.listen(5000, function(err) {

13

14

    if (!err)

15

        console.log("Site is live");

16

    else console.log(err)

17

18

});

Baris pertama memasukkan modul ekspres ke variabel ekspres. Lalu kita memunculkan expres dan memberi nama variabel: app.

Lalu, buat aplikasi mendengarkan port 5000. Kamu bisa memilih nomor port manapun di komputermu.

Sekarang panggil app.get() express routing function yang akan memberi respon dengan "Welcome to Passport With Sequelize" ketika permintaan GET dbuat ke "/".

Untuk mengetesnya di komputermu, jalankan ini dari dalam folder proyekmu:

1

node server.js

Jika kamu melihat teks "Welcome to Passport with Sequelize" saat mengunjungi https://localhost:5000/ maka selamat. Jika tidak, pastikan kamu telah menyelesaikan semua sesuai yang tertulis di atas.

Lalu, impor modul yang ktia perlukan seperti passport, express-session dan body-parser.

Setelah var app = express() kita tambahkan baris berikut:

1

var passport   = require('passport')

2

var session    = require('express-session')

3

var bodyParser = require('body-parser')

Di dua baris pertama, kita mengimpor modul passport dan express-session, keduanya kita butuh untuk mengurus otentikasi.

Lalu, kita impor modul body-parser. Ini mengambil seluruh bagian dari permintaan yang datang dan mengeksposnya dalam format yang lebih mudah untuk dikerjakan. Dalam kasus ini, kita menggunakan format JSON.

Untuk membuat aplikasi kita memiliki body parser, kita menambahkan baris beberapa spasi di bawah baris impor:

1

//For BodyParser

2

app.use(bodyParser.urlencoded({ extended: true }));

3

app.use(bodyParser.json());

Lalu, kita menjalankan passport dan express session dan menambahkan mereka sebagai middleware. kita melakukannya dengan menambah beberapa baris setelah baris impor body parser.

1

// For Passport

2

3

app.use(session({ secret: 'keyboard cat',resave: true, saveUninitialized:true})); // session secret

4

5

app.use(passport.initialize());

6

7

app.use(passport.session()); // persistent login sessions

Kita akan mulai bekerja pada otentikasi yang sebenarnya sekarang.

Kita akan melakukannya dalam empat langkah:

• Menyiapkan Sequelize dengan MySQL
• Membuat model user.
• Menyiapkan views.
• Menulis passport strategy.

1. Menyiapkan Sequelize dengan MySQL

Pertama, buat sebuah database di MySQL. Beri nama yang diinginkan. Untuk tutorial ini, mari buat database dengan nama sequelize_passport di MySQL.

Lalu atur konfigurasi to menghandle detil dari DB

Pertama, impor modul dot-env untuk mengatur envrionment variable.

Jalankan ini dari root folder proyekmu:

1

npm install --save dotenv

Lalu, impor ke berkas server utama, sever.js, di bawah impor-impor yang lain.

1

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

Lalu, buat sebuah berkas di folder proyek dengan nama .env.

Langkah berikut opsional jika kamu tidak menggunakan Git:

Kita akan menambahkan berkas .env ke berkas .gitignore mu.

Berkas .gitignore mu harusnya tampak seperti berikut:

1

node_modules

2

.env

Lalu, kita menambahkah environment ke berkas .env dengan menambahkan baris berikut:

NODE_ENV='development'

Lalu kita membuat berkas config.json yang akan digunakan Sequelize to mengatur environments yang berbeda-beda.

Hal pertama yang harus dilakukan adalah membuat sebuah folder bernama config di folder proyek. Di dalam folder, kita membuat sebuah berkas config.json. Berkas ini harus ditolak jika kamu mendorong ke repositori. Untuk melakukannya, kita menambahkan kode berikut ke .gitignore:

config/config.json

Lalu, salin kode berikut ke berkasconfig.json:

1

{

2

3

    "development": {

4

5

        "username": "root",

6

7

        "password": null,

8

9

        "database": "sequelize_passport",

10

11

        "host": "127.0.0.1",

12

13

        "dialect": "mysql"

14

15

    },

16

17

    "test": {

18

19

        "username": "",

20

21

        "password": null,

22

23

        "database": "",

24

25

        "host": "",

26

27

        "dialect": "mysql"

28

29

    },

30

31

    "production": {

32

33

        "username": "",

34

35

        "password": null,

36

37

        "database": "",

38

39

        "host": "127.0.0.1",

40

41

        "dialect": "mysql"

42

43

    }

44

45

}

Jangan lupa mengganti nilai di blok development dengan detil otentikasi database.

Lalu, pasang sequelize dengan npm. Untuk melakukannya jalan kode berikut di folder proyek:

1

npm install --save sequelize

Sekarang waktunya untuk membuat folder models.

Pertama, kita membuat direktori bernama app di folder proyek.

Di dalam folder app, kita membuat sebuah folder baru bernama models dan membuat sebuah berkas baru bernama index.js di dalam folder models.

Di dalam berkas index.js, salin kode berikut.

1

"use strict";

2

3

var fs = require("fs");

4

var path = require("path");

5

var Sequelize = require("sequelize");

6

var env = process.env.NODE_ENV || "development";

7

var config = require(path.join(__dirname, '..', 'config', 'config.json'))[env];

8

var sequelize = new Sequelize(config.database, config.username, config.password, config);

9

var db = {};

10

11

12

fs

13

    .readdirSync(__dirname)

14

    .filter(function(file) {

15

        return (file.indexOf(".") !== 0) && (file !== "index.js");

16

    })

17

    .forEach(function(file) {

18

        var model = sequelize.import(path.join(__dirname, file));

19

        db[model.name] = model;

20

    });

21

22

Object.keys(db).forEach(function(modelName) {

23

    if ("associate" in db[modelName]) {

24

        db[modelName].associate(db);

25

    }

26

});

27

28

29

db.sequelize = sequelize;

30

db.Sequelize = Sequelize;

31

32

module.exports = db;

Berkas ini digunakan untuk mengimpor semua models yang ditempatkan di folder models dan mengekspornya.

Untuk mengetesnya, kita memasukkan ini ke berkas server.js.

1

//Models

2

var models = require("./app/models");

3

4

//Sync Database

5

models.sequelize.sync().then(function() {

6

7

    console.log('Nice! Database looks fine')

8

9

}).catch(function(err) {

10

11

    console.log(err, "Something went wrong with the Database Update!")

12

13

});

Di sini, kita mengimpor models, dan memanggil fungsi sinkronisasi Sequelize.

Jalankan ini untuk melihat apakah berjalan lancar.]:

1

node server.js

Jika kamu mendapat pesan "Site is live Nice! Database looks fine", maka kamu telah menyiapkan Sequelize dengan benar.

Jika tidak, kembali dengan hati-hati dan coba debug isu dengan help.

2. Membuat user model.

Hal selanjutnya yang akan kita buat adalah user model, yang pada dasarnmya adalah user table. INi akan berisi data dasar pengguna.

Di dalam folder models, buat berkas bernama user.js. Path lengkapnya harus seperti app/models/user.js.

Buka berkas user.js dan masukkan kdoe berikut:

1

module.exports = function(sequelize, Sequelize) {

2

3

    var User = sequelize.define('user', {

4

5

        id: {

6

            autoIncrement: true,

7

            primaryKey: true,

8

            type: Sequelize.INTEGER

9

        },

10

11

        firstname: {

12

            type: Sequelize.STRING,

13

            notEmpty: true

14

        },

15

16

        lastname: {

17

            type: Sequelize.STRING,

18

            notEmpty: true

19

        },

20

21

        username: {

22

            type: Sequelize.TEXT

23

        },

24

25

        about: {

26

            type: Sequelize.TEXT

27

        },

28

29

        email: {

30

            type: Sequelize.STRING,

31

            validate: {

32

                isEmail: true

33

            }

34

        },

35

36

        password: {

37

            type: Sequelize.STRING,

38

            allowNull: false

39

        },

40

41

        last_login: {

42

            type: Sequelize.DATE

43

        },

44

45

        status: {

46

            type: Sequelize.ENUM('active', 'inactive'),

47

            defaultValue: 'active'

48

        }

49

50

51

    });

52

53

    return User;

54

55

}

Sekarang jalankan:

1

node server.js

Harusnya kamu melihat pesan "Site is live. Nice! Database looks fine". Ini berarti model Sequelize telah disinkronisasikan dengan sempurna, dan jika kamu cek database kamu bisa melihat user table dengan kolom yang telah hadir.

3. Menyiapkan Views

Pertama mari buat view untuk mendaftar.

Ha; pertama yang dilakukan adalah mengimpor modul express handlebars yang digunakan untuk view di tutorial ini.

Tambahkan baris berijut ke berkas server.js.

var exphbs = require('express-handlebars')

Pada titik ini harusnya blok impormu tampak seperti ini.

1

var express = require('express')

2

var app = express()

3

var passport = require('passport')

4

var session = require('express-session')

5

var bodyParser = require('body-parser')

6

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

7

var exphbs = require('express-handlebars')

Lalu, kita tambahkan baris berikut ke berkas server.js.

1

//For Handlebars

2

app.set('views', './app/views')

3

app.engine('hbs', exphbs({

4

    extname: '.hbs'

5

}));

6

app.set('view engine', '.hbs');

Sekarang, di folder aplikasi, kita buat tiga folder bernama views, controllers, dan routes.

Dalam folder views, kita buat sebuah folder bernama signup.hbs dan salin kode berikut.

1

<!DOCTYPE html>

2

<html>

3

4

<head>

5

    <title></title>

6

</head>

7

8

<body>

9

    <form id="signup" name="signup" method="post" action="/signup">

10

        <label for="email">Email Address</label>

11

        <input class="text" name="email" type="email" />

12

        <label for="firstname">Firstname</label>

13

        <input name="firstname" type="text" />

14

        <label for="lastname">Lastname</label>

15

        <input name="lastname" type="text" />

16

        <label for="password">Password</label>

17

        <input name="password" type="password" />

18

        <input class="btn" type="submit" value="Sign Up" />

19

    </form>

20

21

</body>

22

23

</html>

Lalu di folder controllers, buat sebuah berkas baru dan beri nama authcontroller.js.

Dalam berkas ini, kita salin controller berikut untuk route signup yang akan kita buat nanti.

1

var exports = module.exports = {}

2

3

exports.signup = function(req, res) {

4

5

    res.render('signup');

6

7

}

Lalu, kita buat sebuah route untuk signup. Dalam folder routes, kita buat sebuah berkas dengan nama auth.js dan dalam berkas tersebut kita impor auth controller dan menentuka signup route nya.

1

var authController = require('../controllers/authcontroller.js');

2

3

module.exports = function(app) {

4

5

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

6

7

}

Sekarang, kita akan mengimpor route ke server.js dan melewatkan aplikasi sebagai argumen.

Di server, setelah impor models, tambahkan baris berikut:

1

//Routes

2

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

Jalankan ini:

1

node server.js

Sekarang kunjugi http://localhost:5000/signup dan kamu akan melihat form pendaftaran.

Ulangi tahapan untuk formulir sign in. Kita akan membuat berkas signin,hbs di dalam folder views dan menyalin kode berikut ke dalamnya.

1

<!DOCTYPE html>

2

<html>

3

4

<head>

5

    <title></title>

6

</head>

7

8

<body>

9

    <form id="signin" name="signin" method="post" action="signin">

10

        <label for="email">Email Address</label>

11

        <input class="text" name="email" type="text" />

12

        <label for="password">Password</label>

13

        <input name="password" type="password" />

14

        <input class="btn" type="submit" value="Sign In" />

15

    </form>

16

17

</body>

18

19

</html>

Lalu, tambahkan controller untuk sign in di app/controllers/authcontroller.js.

1

exports.signin = function(req, res) {

2

3

    res.render('signin');

4

5

}

Lalu, dalam app/routes/auth.js, tambahkan route sign in seperti berikut

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

Sekarang saat kamu jalankan:

1

 node server.js 

Dan mengunjungi http://localhost:5000/signin/, kamu harusnya melihat formulir sign in.

Tahap final dan utama adalah menulis passport strategy.

4. Menulis Passport Strategy

Di app/config, buat sebuah folder baru bernama passport.

Lalu, di dalam folder baru app/config/passport, buat sebuah berkas baru bernama passport.js. Berkas ini akan berisi passport strategy.

Di dalam passport.js, kita akan menggunakan user model dan passport.

Pertama, impor bcrypt yang kita butuh untuk menjaga password:

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

Lalu, tambahkan module.exports seperti berikut:

1

module.exports = function(passport, user) {

2

3

}

Dalam blok ini, kita memulai passport local strategy, dan user model, yang akan dillewati sebgai argumen. Ini cara melakukannya:

1

module.exports = function(passport, user) {

2

3

    var User = user;

4

    var LocalStrategy = require('passport-local').Strategy;

5

6

}

Lalu kita tentukan strategi dengan contoh kita dengan berkas LocalStrategy seperti ini:

1

passport.use('local-signup', new LocalStrategy(

2

3

    {

4

        usernameField: 'email',

5

        passwordField: 'password',

6

        passReqToCallback: true // allows us to pass back the entire request to the callback

7

8

    },

9

10

));

Sekarang kita telah menyatakan request fields kita yaitu dan usernameField dan passwordField.

Variabel terakhir, passReqToCallback, mengizinkan kita untuk melewati seluruh permintaan panggilan kembali, yang sangat berguna untuk sign up.

Setelah koma terakhir, kita tambahkan fungsi callback.

1

  function(req, email, password, done) {

2

3

  }

Di fungsi ini, kita menghandle penyimpanan detil pengguna.

Pertama, kita menambahkan fungsi pembuat hashed password di dalam fungsi callback.

1

 var generateHash = function(password) {

2

3

     return bCrypt.hashSync(password, bCrypt.genSaltSync(8), null);

4

5

 };

Lalu, gunakan Sequelize user model yang kita mulai sebelumnya sebagai User, kita cek untuk melihat apakah user benar-benar ada, dan jika tidak kita tambahkan.

1

User.findOne({

2

    where: {

3

        email: email

4

    }

5

}).then(function(user) {

6

7

    if (user)

8

9

    {

10

11

        return done(null, false, {

12

            message: 'That email is already taken'

13

        });

14

15

    } else

16

17

    {

18

19

        var userPassword = generateHash(password);

20

21

        var data =

22

23

            {

24

                email: email,

25

26

                password: userPassword,

27

28

                firstname: req.body.firstname,

29

30

                lastname: req.body.lastname

31

32

            };

33

34

35

        User.create(data).then(function(newUser, created) {

36

37

            if (!newUser) {

38

39

                return done(null, false);

40

41

            }

42

43

            if (newUser) {

44

45

                return done(null, newUser);

46

47

            }

48

49

        });

50

51

    }

52

53

});

User.create() adalah metode Sequelize untuk menambahkan entri baru ke database. Perhatikan bahwa nilai di data object didapat dari req.body yang mengandung masukkan dari formulir pendaftaran.

passport.js mu harusnya terlihat seperti berikut:

1

//load bcrypt

2

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

3

4

5

module.exports = function(passport, user) {

6

7

8

    var User = user;

9

10

    var LocalStrategy = require('passport-local').Strategy;

11

12

13

    passport.use('local-signup', new LocalStrategy(

14

15

        {

16

17

            usernameField: 'email',

18

19

            passwordField: 'password',

20

21

            passReqToCallback: true // allows us to pass back the entire request to the callback

22

23

        },

24

25

26

27

        function(req, email, password, done) {

28

29

            var generateHash = function(password) {

30

31

                return bCrypt.hashSync(password, bCrypt.genSaltSync(8), null);

32

33

            };

34

35

36

37

            User.findOne({

38

                where: {

39

                    email: email

40

                }

41

            }).then(function(user) {

42

43

                if (user)

44

45

                {

46

47

                    return done(null, false, {

48

                        message: 'That email is already taken'

49

                    });

50

51

                } else

52

53

                {

54

55

                    var userPassword = generateHash(password);

56

57

                    var data =

58

59

                        {

60

                            email: email,

61

62

                            password: userPassword,

63

64

                            firstname: req.body.firstname,

65

66

                            lastname: req.body.lastname

67

68

                        };

69

70

                    User.create(data).then(function(newUser, created) {

71

72

                        if (!newUser) {

73

74

                            return done(null, false);

75

76

                        }

77

78

                        if (newUser) {

79

80

                            return done(null, newUser);

81

82

                        }

83

84

                    });

85

86

                }

87

88

            });

89

90

        }

91

92

    ));

93

94

}

Sekarang kita akan mengimpor strategy di server.js.

Untuk melakukannya, kita tambahkan baris berikut di bawah impor routes di server.js.

1

//load passport strategies

2

require('./app/config/passport/passport.js')(passport, models.user);

server.js mu harusnya terlihat seperti ini sekarang:

1

var express = require('express')

2

var app = express()

3

var passport = require('passport')

4

var session = require('express-session')

5

var bodyParser = require('body-parser')

6

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

7

var exphbs = require('express-handlebars')

8

9

10

//For BodyParser

11

app.use(bodyParser.urlencoded({

12

    extended: true

13

}));

14

app.use(bodyParser.json());

15

16

17

// For Passport

18

app.use(session({

19

    secret: 'keyboard cat',

20

    resave: true,

21

    saveUninitialized: true

22

})); // session secret

23

app.use(passport.initialize());

24

app.use(passport.session()); // persistent login sessions

25

26

27

//For Handlebars

28

app.set('views', './app/views')

29

app.engine('hbs', exphbs({

30

    extname: '.hbs'

31

}));

32

app.set('view engine', '.hbs');

33

34

35

36

app.get('/', function(req, res) {

37

38

    res.send('Welcome to Passport with Sequelize');

39

40

});

41

42

//Models

43

var models = require("./app/models");

44

45

//Routes

46

47

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

48

49

50

//load passport strategies

51

52

require('./app/config/passport/passport.js')(passport, models.user);

53

54

55

//Sync Database

56

57

models.sequelize.sync().then(function() {

58

59

    console.log('Nice! Database looks fine')

60

61

62

}).catch(function(err) {

63

64

    console.log(err, "Something went wrong with the Database Update!")

65

66

});

67

68

69

app.listen(5000, function(err) {

70

71

    if (!err)

72

73

        console.log("Site is live");

74

75

    else console.log(err)

76

77

});

Sekarang kita akan menerapkan strategy untuk /signup route.

Cara nya adalah:

Pertama, ke app/routes/auth,js tambahkan route untuk memosting ke signup seperti ini:

1

app.post('/signup', passport.authenticate('local-signup', {

2

        successRedirect: '/dashboard',

3

4

        failureRedirect: '/signup'

5

    }

6

7

));

Karena kita butuh passport, kita harus melewatkannya ke metode ini. Kita bisa mengimpor passport di skrip ini atau melewatinya ke server.js. Mari lakukan yang kedua.

Ubah fungsi yang diekspor di app/routes/auth.js untuk memiliki passport sebagai parameter. Kode di app/routes/auth.js harus terlihat seperti ini sekarang:

1

var authController = require('../controllers/authcontroller.js');

2

3

4

module.exports = function(app, passport) {

5

6

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

7

8

9

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

10

11

12

    app.post('/signup', passport.authenticate('local-signup', {

13

            successRedirect: '/dashboard',

14

15

            failureRedirect: '/signup'

16

        }

17

18

    ));

19

20

21

22

}

Lalu di server.js kita ubah routes import dan tambahkan passport sebagai argumen seperti ini:

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

Lalu pergi ke  http://localhost:5000/signup/ dan coba untuk mendaftar.

Saat kamu mendaftar kamu akan mendapat error "Failed to serialize user into session". Ini karena passport menyimpan user ID di sesi dan menggunakannya untuk mengatur data pengguna ketika dibutuhkan

Untuk memperbaikinya, kita akan mengimplementasikan baik serialize dan deserialize di passport dalam app/config/passport/passport.js.

Pertama, kita tambahkan fungsi serialize. Fungsi ini akan menyimpan user id ke sesi.

Untuk melakukannya, ktia tambahkan baris berikut ke inisialisasi di local strategy.

1

//serialize

2

passport.serializeUser(function(user, done) {

3

4

    done(null, user.id);

5

6

});

Lalu, kita implementasikan fungsi deserialisasi. Tambahkan fungsi ini dibawah fungsi serialisasi.

1

// deserialize user 

2

passport.deserializeUser(function(id, done) {

3

4

    User.findById(id).then(function(user) {

5

6

        if (user) {

7

8

            done(null, user.get());

9

10

        } else {

11

12

            done(user.errors, null);

13

14

        }

15

16

    });

17

18

});

Dalam fungsi deserialisasi di atas kita menggunakan premis findById Sequelize untuk mendapatkan pengguna dan berhasil. Sebuah contoh dari Sequelize dikembalikan. Untuk mendapatkan USer object dari contoh ini, kita akan menggunakan fungsi getter Sequelize sepertiL: user.get()

Lalu, jalankan lagi:

1

node server.js

Setelah berusaha mendaftar. Jika kamu mendpat pesan "Cannot Get /dashboard" itu artinya otentikasi berhasil. Ingat, kita dialihkan ke /dashboard di passport.authenticate di routes/auth.js

Sekarang maju dan tambahkan route. Lalu, tambahkan middleware sehingga laman hanya bisa diakses ketika pengguna masuk ke sesi.

Di folder app/folder, buat sebuah berkas bernama dashboard.hbs dan tambah kode berikut.

1

<!DOCTYPE html>

2

<html>

3

4

<head>

5

    <title>Passport with Sequelize</title>

6

</head>

7

8

<body>

9

    <h2>Dashboard</h2>

10

    <h5>Hurray! you are logged in.</h5>

11

12

</body>

13

14

</html>

Di routes/auth.js, tambahkan baris di dalam block module.exports:

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

Lalu ke app/controllers/authController.js dan tambahkan dashboard cotroller.

1

exports.dashboard = function(req, res) {

2

3

    res.render('dashboard');

4

5

}

AuthController.js harusnya terlihat seperti berikut:

1

var exports = module.exports = {}

2

3

4

exports.signup = function(req, res) {

5

6

    res.render('signup');

7

8

}

9

10

exports.signin = function(req, res) {

11

12

    res.render('signin');

13

14

}

15

16

17

exports.dashboard = function(req, res) {

18

19

    res.render('dashboard');

20

21

}

Jalankan aplikasi lagi, dan daftar dengan email yang berbeda. Kamu akan dialihkan ke route /dashboard.

Tapi /dashboard bukanlah route yang terlindungi, yang berarti bahkan yang tidak masuk bisa melihatnya. Kita tidak ingin ini sehingga kita menambahkan /logout route untuk mengeluarkan pengguna, lalu melindungi route dan tes yang telah kita kerjakan.

Mari kita lakukan:

Dalam routes/auth.js tambahkan baris berikut:

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

Lalu tambahkan controller di app/controllers/authControllers.js.

1

 exports.logout = function(req, res) {

2

3

     req.session.destroy(function(err) {

4

5

         res.redirect('/');

6

7

     });

8

9

 }

Jalankan aplikasi kembalu dan daftar dengan email yang berbeda.

Lalu kunjungi untuk  http://localhost:5000/logout log out pengguna dan sekarang kunjungi http://localhost:5000/dashboard.

Kamu akan lihat itu bisa terakses sedikit. Mari tambahkan middleware untuk melindunginya.

Caranya, buka app/routes/auth.js dan tambahkan fungsi ini ke module.exports, di bawah semua kode.

1

function isLoggedIn(req, res, next) {

2

3

    if (req.isAuthenticated())

4

5

        return next();

6

7

    res.redirect('/signin');

8

9

}

Lalu ubah handler route dashboard menjadi seperti ini:

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

Sekarang saat kamu mengunjungi aplikasi lagi untuk mengunjungi dashboard dan kamu tidak masuk, kamu kan diarahkan ke halaman login.

Ini waktunya untuk menerapkan bagian akhir: sign-in

Pertama, buat sebuah local strategy baru untuk sign-in di app/config/passport/passport.js.

1

//LOCAL SIGNIN

2

passport.use('local-signin', new LocalStrategy(

3

4

    {

5

6

        // by default, local strategy uses username and password, we will override with email

7

8

        usernameField: 'email',

9

10

        passwordField: 'password',

11

12

        passReqToCallback: true // allows us to pass back the entire request to the callback

13

14

    },

15

16

17

    function(req, email, password, done) {

18

19

        var User = user;

20

21

        var isValidPassword = function(userpass, password) {

22

23

            return bCrypt.compareSync(password, userpass);

24

25

        }

26

27

        User.findOne({

28

            where: {

29

                email: email

30

            }

31

        }).then(function(user) {

32

33

            if (!user) {

34

35

                return done(null, false, {

36

                    message: 'Email does not exist'

37

                });

38

39

            }

40

41

            if (!isValidPassword(user.password, password)) {

42

43

                return done(null, false, {

44

                    message: 'Incorrect password.'

45

                });

46

47

            }

48

49

50

            var userinfo = user.get();

51

            return done(null, userinfo);

52

53

54

        }).catch(function(err) {

55

56

            console.log("Error:", err);

57

58

            return done(null, false, {

59

                message: 'Something went wrong with your Signin'

60

            });

61

62

        });

63

64

65

    }

66

67

));

Dalam strategi ini, isValidPassword adalah fungsi pembanding password yang dimasukka dengan metode perbandingan bCrypt karena password disimpan dalam bCrypt.

Jika detilnya benar, pengguna akan masuk.

Sekarang ke routes/auth.js tambahkan route untuk posting di /signin

1

app.post('/signin', passport.authenticate('local-signin', {

2

        successRedirect: '/dashboard',

3

4

        failureRedirect: '/signin'

5

    }

6

7

));

Routes/auth,js harus terlihat seperti ini:

1

var authController = require('../controllers/authcontroller.js');

2

3

4

module.exports = function(app, passport) {

5

6

7

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

8

9

10

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

11

12

13

    app.post('/signup', passport.authenticate('local-signup', {

14

            successRedirect: '/dashboard',

15

16

            failureRedirect: '/signup'

17

        }

18

19

    ));

20

21

22

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

23

24

25

26

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

27

28

29

    app.post('/signin', passport.authenticate('local-signin', {

30

            successRedirect: '/dashboard',

31

32

            failureRedirect: '/signin'

33

        }

34

35

    ));

36

37

38

    function isLoggedIn(req, res, next) {

39

40

        if (req.isAuthenticated())

41

42

            return next();

43

44

        res.redirect('/signin');

45

46

    }

47

48

}

Sekarang jalankan aplikasi dan coba untuk masuk. Kamu harusnya bisa masuk dengan detil apapun yang digunakan ketika mendaftar, dan kamu akan dialihkan ke http://localhost:5000/dashboard/.

Selamat jika kamu berhasil! Kamu telah mampu menggunakan Sequelize dan Passport dengan database MySQL.

Kode lengkap dari tutorial ini bisa ditemukan di GitHub.

Kesimpulan

Ini menjadi kesimpulan dari tutorial menggunakan Passport untuk otentikasi pengguna dengan Sequelize dan MySQL. Sequelize sangat berguna bersama MySQL ketika menggunakan node. Saya merasa ini berguna, dan kamu akan mempertimbangkannya di aplikasi Node-MySQL berikutnya.

Referensi

• Sequelize docs
• Passport