Authentication di Express JS - Perwira Learning Center

Latar Belakang

Pada pembahasan kali ini, saya mempelajari implementasi autentikasi (authentication) dalam REST API menggunakan Express.js. Setelah memahami cara membuat dan mengelola endpoint, saya menyadari bahwa sebuah aplikasi tidak cukup hanya mampu mengelola data, tetapi juga harus mampu membatasi akses pengguna. Autentikasi diperlukan untuk memastikan bahwa hanya pengguna yang terdaftar dan memiliki izin yang dapat mengakses fitur tertentu dalam sistem.

Dalam pengembangan aplikasi modern, fitur login dan pengamanan data merupakan kebutuhan dasar yang tidak dapat diabaikan. Oleh karena itu, mempelajari implementasi autentikasi menjadi langkah penting agar REST API yang dibangun tidak hanya berfungsi dengan baik, tetapi juga memiliki sistem keamanan yang memadai.

Alat dan Bahan

A. Perangkat Lunak

1. Terminal – Digunakan untuk membuat folder proyek dan menginstal dependensi.

2. Visual Studio Code – Digunakan untuk menuliskan dan mengelola kode program.

3. Node.js – Runtime environment untuk menjalankan JavaScript di sisi server.

4. NPM – Digunakan untuk mengelola dependensi.

5. REST Client – Digunakan untuk menguji endpoint login dan register.

B. Perangkat Keras

• Laptop dengan sistem operasi Ubuntu.

Konsep Authentication pada Express.js

Authentication adalah proses untuk memastikan bahwa pengguna yang mengakses sistem benar-benar memiliki hak akses. Dalam Express.js, autentikasi biasanya diterapkan menggunakan kombinasi:

• Hashing password (menggunakan bcrypt)

• Token berbasis JWT (JSON Web Token)

• Middleware untuk melindungi route tertentu

Pada proyek ini, saya menggunakan JWT untuk mengelola sesi pengguna. JWT memungkinkan server menghasilkan token setelah login berhasil, kemudian token tersebut dikirim kembali oleh client saat mengakses endpoint yang dilindungi.

Instalasi Dependensi

Untuk memulai proyek autentikasi, instal dependensi berikut:

npm init -y
npm install express sequelize mysql2 cors dotenv argon2
npm install -D nodemon 

Keterangan:

• Express.js → Framework untuk membangun server dan mengatur routing aplikasi.

• CORS → Mengatur izin akses antara frontend dan backend yang berbeda origin.

• express-session → Mengelola session pengguna setelah login berhasil.

• dotenv → Membaca variabel lingkungan dari file .env untuk menyimpan data sensitif.

• Argon2 → Mengenkripsi password sebelum disimpan ke database.

• Sequelize → ORM untuk mengelola dan memanipulasi database menggunakan JavaScript tanpa menulis query SQL secara langsung.

• MySQL2 → Driver yang digunakan Sequelize untuk terhubung ke database MySQL.

Struktur Proyek

auth-app/
│
├── config/
│   └── Database.js
│
├── controllers/
│   └── AuthController.js
│   └── UserController.js
│
├── middleware/
│   └── AuthUser.js
│
├── routes/
│   └── AuthRoute.js
│   └── UserRoute.js
│
├── models/
│   └── UserModel.js
│
├── request.rest
├── Server.js
└── .env

Konfigurasi Secret Key (.env)

Buat file .env dan tambahkan:

APP_PORT = masukkan_port

SESS_SECRET = masukkan_secret_key

Port digunakan untuk menginisialisasi port yang akan digunakan. Secret key digunakan untuk menandatangani token agar tidak dapat dimanipulasi oleh pihak lain.

Implementasi Kode

1. Server.js

import express from "express";
import cors from "cors";
import session from "express-session";
import dotenv from "dotenv";
import db from "./config/Database.js";
import SequelizeStore from "connect-session-sequelize";
import UserRoute from "./routes/UserRoute.js";
import ProductRoute from "./routes/ProductRoute.js";
import AuthRoute from "./routes/AuthRoute.js";
dotenv.config();

const app = express();

const sessionStore = SequelizeStore(session.Store);

const store = new sessionStore({
    db: db
});

// (async()=>{
//     await db.sync();
// })();

app.use(session({
    secret: process.env.SESS_SECRET,
    resave: false,
    saveUninitialized: true,
    store: store,
    cookie: {
        secure: 'auto'
    }
}));

app.use(cors({
    credentials: true,
    origin: 'http://localhost:3000'
}));
app.use(express.json());
app.use(UserRoute);
app.use(ProductRoute);
app.use(AuthRoute);

// store.sync();

app.listen(process.env.APP_PORT, ()=> {
    console.log('Server up and running...');
});

2. config/Database.js

import {Sequelize} from "sequelize"; const db = new Sequelize('auth_db', 'root', '', { host: "localhost", dialect: "mysql" }); export default db;

3. models/UserModel.js

import { Sequelize } from "sequelize";
import db from "../config/Database.js";

const {DataTypes} = Sequelize;

const Users = db.define('users',{
    uuid:{
        type: DataTypes.STRING,
        defaultValue: DataTypes.UUIDV4,
        allowNull: false,
        validate:{
            notEmpty: true
        }
    },
    name:{
        type: DataTypes.STRING,
        allowNull: false,
        validate:{
            notEmpty: true,
            len: [3, 100]
        }
    },
    email:{
        type: DataTypes.STRING,
        allowNull: false,
        validate:{
            notEmpty: true,
            isEmail: true
        }
    },
    password:{
        type: DataTypes.STRING,
        allowNull: false,
        validate:{
            notEmpty: true
        }
    },
    role:{
        type: DataTypes.STRING,
        allowNull: false,
        validate:{
            notEmpty: true
        }
    }
},{
    freezeTableName: true
});

export default Users;

4. controllers/UserController.js

import User from "../models/UserModel.js";
import argon2 from "argon2";

export const getUsers = async(req, res) =>{
    try {
        const response = await User.findAll({
            attributes:['uuid','name','email','role']
        });
        res.status(200).json(response);
    } catch (error) {
        res.status(500).json({msg: error.message});
    }
}

export const getUserById = async(req, res) =>{
    try {
        const response = await User.findOne({
            attributes:['uuid','name','email','role'],
            where: {
                uuid: req.params.id
            }
        });
        res.status(200).json(response);
    } catch (error) {
        res.status(500).json({msg: error.message});
    }
}

export const createUser = async(req, res) =>{
    const {name, email, password, confPassword, role} = req.body;
    if(password !== confPassword) return res.status(400).json({msg: "Password dan Confirm Password tidak cocok"});
    const hashPassword = await argon2.hash(password);
    try {
        await User.create({
            name: name,
            email: email,
            password: hashPassword,
            role: role
        });
        res.status(201).json({msg: "Register Berhasil"});
    } catch (error) {
        res.status(400).json({msg: error.message});
    }
}

export const updateUser = async(req, res) =>{
    const user = await User.findOne({
        where: {
            uuid: req.params.id
        }
    });
    if(!user) return res.status(404).json({msg: "User tidak ditemukan"});
    const {name, email, password, confPassword, role} = req.body;
    let hashPassword;
    if(password === "" || password === null){
        hashPassword = user.password
    }else{
        hashPassword = await argon2.hash(password);
    }
    if(password !== confPassword) return res.status(400).json({msg: "Password dan Confirm Password tidak cocok"});
    try {
        await User.update({
            name: name,
            email: email,
            password: hashPassword,
            role: role
        },{
            where:{
                id: user.id
            }
        });
        res.status(200).json({msg: "User Updated"});
    } catch (error) {
        res.status(400).json({msg: error.message});
    }
}

export const deleteUser = async(req, res) =>{
    const user = await User.findOne({
        where: {
            uuid: req.params.id
        }
    });
    if(!user) return res.status(404).json({msg: "User tidak ditemukan"});
    try {
        await User.destroy({
            where:{
                id: user.id
            }
        });
        res.status(200).json({msg: "User Deleted"});
    } catch (error) {
        res.status(400).json({msg: error.message});
    }
}

5. controllers/AuthController.js

Daftar Pustaka