autentikasi nodejs jwt json web token

📚 Seri Node.js from Zero to Zorro — Artikel 10 dari 16

Jaga Keamanan API dengan JWT — Autentikasi dan Otorisasi Menggunakan JSON Web Token

Pelajari cara mengimplementasikan JWT Node.js dari nol: buat token, verifikasi, hingga proteksi endpoint API kamu dengan JSON Web Token dan Express.

#JWT #Autentikasi #NodeJS #Express #Security

⏱️

Estimasi Baca

12–15 Menit

🎯

Level

Pemula — Menengah

📅

Tahun

2026

Bayangkan kamu bikin aplikasi keren — user bisa daftar, login, dan akses data pribadi mereka. Tapi tanpa sistem autentikasi yang benar, siapa pun bisa mengakses data siapa pun. Serem, kan? Nah, di sinilah JWT Node.js — alias JSON Web Token — hadir sebagai pahlawan tanpa tanda jasa dunia API modern.

Di artikel ke-10 seri Node.js from Zero to Zorro ini, kita akan belajar tuntas autentikasi API Node.js menggunakan JSON Web Token Express. Dari memahami konsep JWT, cara kerjanya, sampai implementasi nyata di project Express.js kamu — semuanya dikupas dengan analogi yang mudah dipahami dan kode yang bisa langsung dipraktikkan.

Siap bikin API kamu jadi benteng yang nggak gampang dibobol? Yuk, mulai! 🚀

🔐 Apa Itu JWT Node.js dan Kenapa Kamu Perlu Tahu?

Coba bayangkan kamu masuk ke sebuah konser. Di pintu masuk, kamu menunjukkan tiket — panitia memeriksa, cap di tanganmu, dan kamu masuk. Setelah itu, kamu nggak perlu terus-menerus menunjukkan tiket ke setiap petugas di dalam — cukup tunjukkan cap di tanganmu sebagai bukti kamu sudah valid.

Begitu kira-kira cara kerja JWT. Saat user login, server memberi "cap" digital berupa token. Token itu dibawa user di setiap request berikutnya — dan server bisa langsung memverifikasinya tanpa perlu cek database lagi.

🔑

📌 Definisi Penting

JWT (JSON Web Token) adalah standar terbuka (RFC 7519) yang mendefinisikan cara aman dan kompak untuk mentransfer informasi antar dua pihak dalam format JSON yang telah ditandatangani secara digital.

Header.Payload.Signature

Tiga bagian JWT dipisahkan titik — masing-masing di-encode Base64Url

🔥

Fakta Menarik

JWT digunakan oleh lebih dari 70% aplikasi web modern sebagai mekanisme autentikasi utama. Platform seperti Google, GitHub, dan Stripe semuanya menggunakan konsep token-based authentication yang serupa dengan JWT.

Anatomi JWT: Tiga Bagian yang Wajib Kamu Tahu

Bagian	Isi	Contoh Info
Header	Algoritma & tipe token	{ "alg": "HS256", "typ": "JWT" }
Payload	Data user (claims)	{ "id": 1, "role": "admin", "exp": ... }
Signature	Tanda tangan digital	HMACSHA256(base64(header+payload), secret)

⚙️ Implementasi Autentikasi API Node.js dengan JWT — Step by Step

Oke, teori sudah cukup. Sekarang kita masuk ke bagian yang paling seru: nulis kode! Kita akan membangun sistem autentikasi lengkap menggunakan JSON Web Token Express dari nol.

1

Install Package yang Dibutuhkan

Kita butuh dua package utama: jsonwebtoken untuk buat & verifikasi token, dan bcryptjs untuk hash password.

terminal

npm init -y
npm install express jsonwebtoken bcryptjs dotenv

2

Buat File .env — Simpan Secret Key

Secret key adalah "bumbu rahasia" JWT kamu. Jangan pernah taruh ini langsung di kode!

.env

JWT_SECRET=superSecretKunciRahasia123!@#
JWT_EXPIRES_IN=7d
PORT=3000

⚠️

Perhatian!

File .env harus masuk ke .gitignore! Secret key yang bocor ke GitHub adalah salah satu celah keamanan paling umum yang terjadi pada developer pemula. Serius, ini bukan bercanda.

3

Buat Endpoint Login — Generate JWT Token

Inilah inti dari seluruh proses: saat user login berhasil, kita buat token JWT dan kirim ke client.

auth.js

const express = require('express')
const jwt     = require('jsonwebtoken')
const bcrypt  = require('bcryptjs')
require('dotenv').config()

const router = express.Router()

// Simulasi user dari database
const users = [
  { id: 1, email: 'saifi@email.com', 
    password: bcrypt.hashSync('password123', 10) }
]

// POST /auth/login
router.post('/login', async (req, res) => {
  try {
    const { email, password } = req.body

    // 1. Cari user berdasarkan email
    const user = users.find(u => u.email === email)
    if (!user) return res.status(401).json({ msg: 'User tidak ditemukan' })

    // 2. Verifikasi password
    const valid = await bcrypt.compare(password, user.password)
    if (!valid) return res.status(401).json({ msg: 'Password salah' })

    // 3. Generate JWT Token
    const token = jwt.sign(
      { id: user.id, email: user.email },
      process.env.JWT_SECRET,
      { expiresIn: process.env.JWT_EXPIRES_IN }
    )

    res.json({ 
      success: true, 
      token,
      message: 'Login berhasil! 🎉'
    })

  } catch (err) {
    res.status(500).json({ msg: 'Server error', error: err.message })
  }
})

module.exports = router

4

Buat Middleware Verifikasi Token

Middleware ini adalah "satpam" di depan pintu endpoint yang dilindungi. Kalau token nggak valid, langsung ditolak.

middleware/auth.js

const jwt = require('jsonwebtoken')

const verifyToken = (req, res, next) => {
  // Ambil token dari header Authorization
  const authHeader = req.headers['authorization']
  const token = authHeader && authHeader.split(' ')[1]

  if (!token) {
    return res.status(401).json({ 
      msg: 'Akses ditolak. Token tidak ditemukan!'
    })
  }

  try {
    // Verifikasi & decode token
    const decoded = jwt.verify(token, process.env.JWT_SECRET)
    req.user = decoded // Simpan data user ke request
    next()
  } catch (err) {
    res.status(403).json({ msg: 'Token tidak valid atau sudah kedaluwarsa' })
  }
}

module.exports = verifyToken

5

Proteksi Endpoint dengan Middleware

Sekarang pasang middleware verifyToken ke endpoint yang perlu dilindungi.

routes/profile.js

const express      = require('express')
const verifyToken = require('../middleware/auth')
const router      = express.Router()

// 🔒 Route ini hanya bisa diakses jika punya token valid
router.get('/profile', verifyToken, (req, res) => {
  res.json({
    success: true,
    message: 'Selamat datang di profil kamu!',
    user: req.user // Data user dari token
  })
})

module.exports = router

💡

Tips Pro

Saat mengirim JWT dari client, selalu gunakan format Authorization: Bearer <token> di HTTP header. Format "Bearer" adalah konvensi standar industri yang diikuti hampir semua framework dan library autentikasi.

⚡ JWT vs Session: Mana yang Lebih Cocok untuk Autentikasi API Node.js Kamu?

Ini pertanyaan klasik yang sering muncul di komunitas developer. Jawabannya: tergantung kebutuhan. Tapi biar kamu nggak bingung, ini breakdown komprehensifnya:

🔍 Analisis Mendalam: JWT vs Session

🔑 JWT (Stateless)

• ✅ Tidak perlu session store
• ✅ Cocok untuk microservices & API
• ✅ Bisa dipakai antar domain (CORS)
• ✅ Scalable secara horizontal
• ❌ Sulit di-revoke sebelum expired
• ❌ Payload bisa jadi besar

🗂️ Session (Stateful)

• ✅ Mudah di-revoke (logout instan)
• ✅ Data sensitif tetap di server
• ✅ Cocok untuk web tradisional
• ✅ Lebih mudah di-debug
• ❌ Butuh session storage (Redis dll)
• ❌ Kurang ideal untuk REST API

Kesimpulan: Untuk REST API dan aplikasi yang butuh scalability, JWT adalah pilihan yang lebih tepat. Untuk aplikasi web tradisional dengan kebutuhan logout instan, session mungkin lebih sesuai.

🛡️ Best Practices JSON Web Token Express yang Wajib Kamu Terapkan

Implementasi JWT yang salah bisa berbahaya. Ini bukan soal "best practice yang bagus kalau dikerjakan" — ini soal keamanan yang harus kamu terapkan dari awal.

⚡

Insight Penting

JWT Payload TIDAK dienkripsi — hanya di-encode Base64. Artinya siapa pun bisa membaca isinya di jwt.io. Jangan pernah menyimpan password, data kartu kredit, atau informasi sensitif lainnya di dalam payload JWT!

1. Set Waktu Kadaluarsa yang Wajar
Gunakan expiresIn: '15m' untuk access token dan '7d' untuk refresh token. Access token yang pendek meminimalkan risiko jika token dicuri.

2. Gunakan Algoritma yang Aman
Default HS256 sudah cukup baik. Untuk keamanan ekstra di aplikasi enterprise, pertimbangkan RS256 (asymmetric).

3. Simpan Token dengan Aman di Client
Hindari localStorage karena rentan XSS. Gunakan httpOnly Cookie sebagai alternatif yang lebih aman.

4. Implementasikan Refresh Token
Buat sistem dua token: access token (pendek) + refresh token (panjang). Ketika access token expired, gunakan refresh token untuk dapat access token baru tanpa perlu login ulang.

💡

Tips Tambahan

Untuk testing cepat JWT kamu, gunakan tool gratis di jwt.io — kamu bisa decode token dan verifikasi signature langsung di browser. Sangat berguna saat debugging!

🏷️ Autentikasi API & Keamanan Node.js

#BelajarNodeJS #ZeroToZorro #JWTNodeJS #JSONWebToken #ExpressJS #WebSecurity #AutentikasiAPI

📝 Kesimpulan

Kamu Sudah Selangkah Lebih Maju dalam Keamanan API!

Di artikel ini, kamu sudah belajar:

▸

Konsep dan anatomi JWT Node.js — Header, Payload, Signature

▸

Implementasi lengkap autentikasi API Node.js dari login hingga proteksi endpoint

▸

Membuat middleware verifikasi JSON Web Token Express

▸

Perbedaan JWT vs Session dan kapan menggunakan masing-masing

▸

Best practices keamanan JWT yang wajib diterapkan

Keamanan API bukan fitur opsional — ini adalah fondasi dari setiap aplikasi yang serius. Dengan memahami JWT Node.js secara mendalam, kamu sudah selangkah lebih maju dari banyak developer pemula di luar sana. Tetap semangat dan terus praktik! 💪

💬 Punya pertanyaan atau menemukan bug di kode? Tinggalkan komentar di bawah! Dan kalau artikel ini bermanfaat, share ke teman-teman yang lagi belajar Node.js ya — kamu bakal bikin harinya lebih produktif. 🙌

📚

Seri Lengkap

Node.js from Zero to Zorro

Artikel ini adalah bagian dari seri belajar Node.js yang komprehensif — dari dasar hingga mahir. Cek seluruh daftar isi di sini:

🗂️ Lihat Semua Artikel Seri →

🧭 Navigasi Artikel

← Artikel Sebelumnya

Artikel 9

Lebih Modern dengan MongoDB

Artikel Selanjutnya →

Artikel 11

Upload File dan Kelola Gambar

nodejs mongodb mongoose crud

📚 Seri Belajar Node.js — Artikel 9 dari 16

Lebih Modern dengan MongoDB — Koneksi, CRUD, dan Mongoose sebagai ODM

Tinggalkan tabel SQL yang kaku. Saatnya kamu kenalan dengan database NoSQL paling populer di dunia Node.js — MongoDB — lengkap dengan operasi CRUD dan Mongoose ODM yang elegan.

#NodeJS #MongoDB #MongooseODM #CRUD #ZeroToZorro

⏱️

Estimasi Baca

12 Menit

🎯

Level

Pemula → Menengah

📅

Tahun

2026

Pernah nggak kamu frustrasi bikin tabel di MySQL setiap kali ada perubahan struktur data? Tambah kolom satu, migration dulu, update semua query, dan tiba-tiba semuanya error. Nyebelin banget, kan? Nah, di sinilah Node.js MongoDB hadir sebagai angin segar. MongoDB menyimpan data dalam format dokumen JSON yang fleksibel — nggak ada tabel, nggak ada kolom kaku, nggak ada drama migration.

Di artikel ke-9 dari Seri Belajar Node.js ini, kamu akan belajar cara koneksi ke MongoDB, melakukan operasi CRUD MongoDB Node.js dari nol, sampai pakai Mongoose ODM untuk membuat kode yang lebih terstruktur dan elegan. Siap? Kita mulai!

🍃 Formula Konsep

MongoDB = Database berbasis Dokumen JSON

MongoDB bukan database relasional. Data disimpan sebagai dokumen BSON (Binary JSON) di dalam collection — bayangkan seperti folder berisi file JSON. Setiap dokumen bisa punya struktur berbeda tanpa perlu mendefinisikan schema terlebih dahulu.

SQL → Table

Row, Column

MongoDB → Collection

Document, Field

Kenapa Node.js MongoDB Jadi Kombinasi Favorit Developer?

Bayangkan MongoDB seperti laci arsip yang super fleksibel. Di MySQL, kamu harus bikin laci (tabel) dengan ukuran yang sudah ditentukan sejak awal. Di MongoDB, kamu bisa taruh dokumen apapun ke dalam satu laci — ada yang punya 3 field, ada yang punya 15 field — dan semuanya fine-fine aja.

Node.js dan MongoDB cocok banget karena keduanya "berbicara" dalam JavaScript dan JSON. Data dari frontend, diproses di Node.js, disimpan ke MongoDB — semuanya dalam format yang sama. Tidak ada translasi, tidak ada overhead konversi.

Fitur	MySQL (SQL)	MongoDB (NoSQL)
Struktur Data	Tabel kaku (baris & kolom)	Dokumen JSON fleksibel
Schema	Wajib didefinisikan	Opsional (schema-less)
Query Language	SQL	JavaScript/JSON
Skalabilitas	Vertical scaling	Horizontal scaling mudah
Cocok untuk	Data relasional terstruktur	Data dinamis, real-time, JSON

🔥

Fakta Menarik

MongoDB adalah database NoSQL paling populer di dunia selama bertahun-tahun berturut-turut, dan digunakan oleh perusahaan seperti Forbes, eBay, Adobe, dan Google. Stack MEAN (MongoDB, Express, Angular, Node.js) dan MERN (dengan React) menjadi blueprint aplikasi modern yang paling banyak dipakai startup.

Koneksi Node.js ke MongoDB dengan Mongoose ODM

Sebelum bisa operasi apapun, kamu perlu koneksi ke MongoDB. Ada dua cara: pakai native MongoDB driver, atau pakai Mongoose ODM (Object Data Modeling). Kita pilih Mongoose karena lebih developer-friendly — ada schema validation, middleware, dan banyak fitur keren lainnya.

Mongoose itu ibarat "penerjemah profesional" antara Node.js dan MongoDB. Kamu define schema-nya, Mongoose yang ngurusin sisanya.

1

Install Mongoose via npm

Buka terminal di folder project Node.js kamu dan jalankan perintah berikut.

npm install mongoose

2

Buat file koneksi db.js

Pisahkan konfigurasi koneksi ke file tersendiri agar kode lebih rapi.

// db.js
const mongoose = require('mongoose');

const connectDB = async () => {
  try {
    await mongoose.connect('mongodb://localhost:27017/belajar_nodejs');
    console.log('✅ MongoDB terhubung!');
  } catch (error) {
    console.error('❌ Gagal koneksi:', error.message);
    process.exit(1);
  }
};

module.exports = connectDB;

3

Buat Schema & Model dengan Mongoose

Schema adalah "blueprint" dokumen MongoDB kamu. Di sini kita buat model Produk sebagai contoh.

// models/Produk.js
const mongoose = require('mongoose');

const produkSchema = new mongoose.Schema({
  nama: { type: String, required: true },
  harga: { type: Number, required: true },
  stok: { type: Number, default: 0 },
  kategori: String,
  createdAt: { type: Date, default: Date.now }
});

module.exports = mongoose.model('Produk', produkSchema);

💡

Tips Pro

Untuk project produksi, simpan URI MongoDB di file .env dan akses via process.env.MONGO_URI. Jangan pernah hardcode credential di kode — ini kebiasaan profesional yang wajib kamu tanamkan dari sekarang!

Operasi CRUD MongoDB Node.js: Create, Read, Update, Delete

Inilah jantung dari semua aplikasi database — operasi CRUD. Dengan Mongoose, setiap operasi terasa intuitif dan mirip JavaScript biasa. Mari kita bedah satu per satu.

⚡

Insight Penting

Semua operasi Mongoose bersifat asynchronous — selalu gunakan async/await atau .then()/.catch(). Kode yang tidak menangani async dengan benar adalah sumber bug paling umum bagi pemula.

C

CREATE — Tambah Data Baru

const Produk = require('./models/Produk');

// Cara 1: new + save()
const produkBaru = new Produk({
  nama: 'Laptop Gaming',
  harga: 15000000,
  stok: 10,
  kategori: 'Elektronik'
});
await produkBaru.save();

// Cara 2: create() — lebih ringkas
const produk = await Produk.create({
  nama: 'Mouse Wireless', harga: 350000
});

R

READ — Ambil Data dari Database

// Ambil semua produk
const semuaProduk = await Produk.find();

// Cari berdasarkan kondisi
const elektronik = await Produk.find({ kategori: 'Elektronik' });

// Ambil satu dokumen berdasarkan ID
const satuproduk = await Produk.findById('60d5ec49...');

// Filter harga, sort, dan limit
const mahal = await Produk
  .find({ harga: { $gte: 1000000 } })
  .sort({ harga: -1 })
  .limit(5);

U

UPDATE — Perbarui Data yang Ada

// Update berdasarkan ID
await Produk.findByIdAndUpdate(
  '60d5ec49...',
  { $set: { harga: 14500000, stok: 8 } },
  { new: true } // kembalikan dokumen setelah update
);

// Update banyak dokumen sekaligus
await Produk.updateMany(
  { kategori: 'Elektronik' },
  { $inc: { harga: 50000 } } // naikkan harga 50rb
);

D

DELETE — Hapus Data dari Database

// Hapus berdasarkan ID
await Produk.findByIdAndDelete('60d5ec49...');

// Hapus berdasarkan kondisi
await Produk.deleteMany({ stok: 0 });

// Hapus satu dokumen berdasarkan filter
await Produk.deleteOne({ nama: 'Mouse Wireless' });

⚠️

Perhatian!

Hati-hati dengan deleteMany({}) tanpa filter — ini akan menghapus semua dokumen dalam collection! Selalu double-check kondisi filter sebelum menjalankan perintah delete atau update massal.

Mengapa Mongoose ODM Lebih Direkomendasikan untuk Node.js?

Kamu mungkin bertanya — kalau MongoDB sudah punya native driver sendiri (mongodb npm package), kenapa masih perlu Mongoose? Jawabannya sederhana: Mongoose ODM menambahkan lapisan abstraksi yang membuat hidup kamu jauh lebih mudah, terutama di project yang besar dan kompleks.

🔍 Analisis: Mongoose vs MongoDB Native Driver

MongoDB Native Driver

• Kontrol penuh, performa optimal
• Tidak ada schema validation bawaan
• Tidak ada middleware/hooks
• Cocok untuk use case sangat spesifik
• Kode lebih verbose dan manual

✨ Rekomendasi

Mongoose ODM

• Schema validation otomatis
• Middleware (pre/post hooks) powerful
• Virtual fields & computed properties
• Populate (relasi antar collection)
• API bersih dan developer-friendly

⚡

Insight: Fitur Mongoose yang Wajib Kamu Tahu

Mongoose punya fitur populate() yang memungkinkan kamu melakukan "join" antar collection — sesuatu yang perlu ditulis manual di native driver. Selain itu, pre/post hooks memungkinkan kamu menjalankan fungsi otomatis sebelum atau sesudah operasi save, find, delete, dll. — sempurna untuk hashing password sebelum disimpan!

// Contoh pre-save hook: hash password otomatis
userSchema.pre('save', async function(next) {
  if (this.isModified('password')) {
    this.password = await bcrypt.hash(this.password, 10);
  }
  next();
});

📚

Seri Belajar Node.js: Node.js from Zero to Zorro

Artikel ini adalah bagian ke-9 dari 16 artikel seri lengkap belajar Node.js dari nol hingga mahir. Cek daftar isi lengkapnya di sini:

📖 Lihat Daftar Isi Lengkap →

🎯 Kesimpulan

Kamu Sudah Satu Langkah Lebih Modern!

Di artikel ini, kamu telah mempelajari fondasi penting penggunaan Node.js MongoDB: mulai dari memahami perbedaan SQL vs NoSQL, mengkoneksikan project ke MongoDB menggunakan Mongoose ODM, mendefinisikan schema & model yang terstruktur, hingga menjalankan operasi lengkap CRUD MongoDB Node.js — Create, Read, Update, dan Delete.

✅ Poin yang sudah kamu kuasai:

🍃 Konsep MongoDB & NoSQL

🔌 Koneksi via Mongoose

📐 Schema & Model definition

✍️ Create & Read operasi

🔄 Update dengan operator

🗑️ Delete dokumen

Artikel selanjutnya kita akan naik level — bahas cara mengamankan API kamu dengan JWT (JSON Web Token). Jangan sampai ketinggalan!

Artikel ini bermanfaat? 👇

Tinggalkan komentar di bawah — share pengalamanmu pakai MongoDB, atau kalau ada yang masih bikin bingung, tanya langsung! Dan kalau artikel ini berguna, share ke teman-teman kamu yang lagi belajar Node.js. Bantu mereka juga naik level! 🚀

🏷️ Tags Artikel

#BelajarNodeJS #ZeroToZorro #NodeJSMongoDB #MongooseODM #CRUDMongoDB #NoSQL #WebDevelopment #BackendDeveloper

🧭 Navigasi Artikel

← Artikel Sebelumnya

Artikel 8

Simpan Data ke Database MySQL

Artikel Selanjutnya →

Artikel 10

Jaga Keamanan API dengan JWT

koneksi nodejs mysql query database

📚 SERI BELAJAR NODE.JS · ARTIKEL 8 DARI 16

Simpan Data ke Database MySQL
dengan Node.js

Koneksi Node.js ke MySQL, query data dari nol, sampai integrasi penuh ke REST API Express — panduan lengkap untuk pemula.

#NodeJS #MySQL #Database #REST API #Express.js

⏱️

Baca

12 Menit

🎯

Level

Pemula

📅

Tahun

2026

🗄️

Topik

Node.js + MySQL

Bayangkan kamu sudah capek-capek membangun REST API yang keren — endpoint-nya rapi, response JSON-nya mulus — tapi semua datanya cuma tersimpan di array JavaScript. Begitu server di-restart, poof, data hilang. Itulah masalah yang akan kita selesaikan hari ini: menghubungkan Node.js MySQL sehingga data kamu benar-benar tersimpan permanen.

Di artikel ke-8 dari Seri Belajar Node.js ini, kita akan belajar cara melakukan koneksi database MySQL Node.js, menjalankan query SQL dari kode JavaScript, hingga mengintegrasikan semuanya ke dalam REST API berbasis Express yang sudah kita buat sebelumnya. Kalau kamu pernah belajar SQL dasar, ini akan terasa familiar — bedanya sekarang kamu yang pegang kendali lewat kode!

🔑 Konsep Kunci

MySQL itu gudangnya, Node.js itu kurirnya.

MySQL menyimpan data secara permanen di disk. Node.js bertugas sebagai kurir yang mengantar permintaan (query) ke MySQL, mengambil hasilnya, lalu menyajikannya ke pengguna lewat API. Package mysql2 adalah jembatan resmi antara keduanya.

1. Persiapan: Install mysql2 dan Buat Database

Sebelum bisa melakukan koneksi database MySQL Node.js, kamu perlu dua hal: MySQL yang sudah terinstal (bisa pakai XAMPP, WAMP, atau MySQL langsung) dan package mysql2 di proyek Node.js-mu.

1

Install package mysql2

Package mysql2 adalah versi modern dan lebih cepat dari mysql. Ini pilihan yang direkomendasikan komunitas Node.js saat ini.

Terminal / CMD bash

npm install mysql2

2

Buat database dan tabel di MySQL

Jalankan perintah SQL ini di phpMyAdmin, MySQL Workbench, atau MySQL CLI. Kita akan pakai tabel users sebagai contoh sepanjang artikel ini.

SQL mysql

CREATE DATABASE belajar_nodejs;

USE belajar_nodejs;

CREATE TABLE users (
  id       INT AUTO_INCREMENT PRIMARY KEY,
  nama     VARCHAR(100) NOT NULL,
  email    VARCHAR(150) UNIQUE NOT NULL,
  dibuat   TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

💡

Tips Pemula

Gunakan XAMPP kalau kamu di Windows/Mac dan ingin cara paling simpel. Cukup klik "Start" di Apache dan MySQL, lalu buka localhost/phpmyadmin untuk mengelola database-mu secara visual.

2. Koneksi Node.js ke MySQL: Pool vs Single Connection

Ada dua cara melakukan koneksi database MySQL Node.js: koneksi tunggal (single connection) atau pool koneksi (connection pool). Analoginya begini — single connection itu seperti kamu pergi ke kasir sendirian, satu per satu. Pool koneksi itu seperti punya 10 kasir siaga sekaligus. Untuk aplikasi nyata, selalu pakai pool.

⚖️ Perbandingan: Single Connection vs Pool

Aspek	Single Connection	Connection Pool
Kecepatan	Lambat (antri)	✅ Cepat (paralel)
Multi-user	❌ Tidak ideal	✅ Sangat ideal
Kegunaan	Skrip sekali jalan	✅ Server/API produksi
Kompleksitas	✅ Mudah	Sedikit lebih banyak setup

Mari kita buat file db.js khusus untuk mengelola koneksi pool:

📄 db.js — Modul Koneksi Database javascript

const mysql = require('mysql2/promise');

// Buat connection pool
const pool = mysql.createPool({
  host    : 'localhost',
  user    : 'root',
  password: '',          // sesuaikan password MySQL kamu
  database: 'belajar_nodejs',
  waitForConnections: true,
  connectionLimit: 10,   // maksimal 10 koneksi paralel
});

module.exports = pool;

⚡

Insight Penting

Kita pakai mysql2/promise bukan mysql2 biasa. Versi promise memungkinkan kita memakai async/await — kode jadi jauh lebih bersih dan mudah dibaca dibandingkan callback tradisional.

3. Query MySQL dengan Node.js: SELECT, INSERT, UPDATE, DELETE

Setelah koneksi berhasil, saatnya belajar cara menjalankan query MySQL Express untuk operasi CRUD — Create, Read, Update, Delete. Semua query dikirim lewat metode pool.query() yang sudah kita buat tadi.

GET

SELECT — Ambil Semua Data

Contoh query SELECT

const [rows] = await pool.query('SELECT * FROM users');
console.log(rows); // array of objects

POST

INSERT — Tambah Data Baru

Selalu gunakan parameterized query (tanda ?) — bukan string concatenation — untuk mencegah SQL Injection!

Contoh query INSERT

const [result] = await pool.query(
  'INSERT INTO users (nama, email) VALUES (?, ?)',
  ['Budi Santoso', 'budi@email.com']
);
console.log('ID baru:', result.insertId);

PUT

UPDATE — Ubah Data

Contoh query UPDATE

const [result] = await pool.query(
  'UPDATE users SET nama = ? WHERE id = ?',
  ['Budi Baru', 1]
);
console.log('Baris diubah:', result.affectedRows);

DEL

DELETE — Hapus Data

Contoh query DELETE

const [result] = await pool.query(
  'DELETE FROM users WHERE id = ?',
  [1]
);
console.log('Baris dihapus:', result.affectedRows);

⚠️

Perhatian — SQL Injection

Jangan pernah memasukkan input user langsung ke string query seperti 'SELECT * FROM users WHERE id = ' + req.params.id. Ini membuka celah SQL Injection. Selalu gunakan parameterized query dengan tanda ?!

4. Integrasi Query MySQL Express ke REST API

Inilah bagian paling seru — menggabungkan semua yang sudah kita pelajari di artikel sebelumnya. Kita akan membuat file app.js dengan Express yang endpoint-nya langsung terhubung ke database MySQL. Inilah cara kerja aplikasi backend yang sesungguhnya.

📄 app.js — REST API + MySQL Lengkap javascript

const express = require('express');
const pool    = require('./db'); // import modul koneksi kita
const app    = express();

app.use(express.json());

// GET /users — Ambil semua user
app.get('/users', async (req, res) => {
  try {
    const [rows] = await pool.query('SELECT * FROM users');
    res.json(rows);
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

// GET /users/:id — Ambil satu user
app.get('/users/:id', async (req, res) => {
  const [rows] = await pool.query(
    'SELECT * FROM users WHERE id = ?',
    [req.params.id]
  );
  if (!rows.length) return res.status(404).json({ message: 'User tidak ditemukan' });
  res.json(rows[0]);
});

// POST /users — Tambah user baru
app.post('/users', async (req, res) => {
  const { nama, email } = req.body;
  const [result] = await pool.query(
    'INSERT INTO users (nama, email) VALUES (?, ?)',
    [nama, email]
  );
  res.status(201).json({ id: result.insertId, nama, email });
});

// PUT /users/:id — Update user
app.put('/users/:id', async (req, res) => {
  const { nama } = req.body;
  await pool.query('UPDATE users SET nama = ? WHERE id = ?', [nama, req.params.id]);
  res.json({ message: 'User berhasil diperbarui' });
});

// DELETE /users/:id — Hapus user
app.delete('/users/:id', async (req, res) => {
  await pool.query('DELETE FROM users WHERE id = ?', [req.params.id]);
  res.json({ message: 'User berhasil dihapus' });
});

app.listen(3000, () => console.log('Server jalan di port 3000 🚀'));

🔥

Fakta Menarik

MySQL adalah database relasional yang paling banyak digunakan di dunia — mentenagai raksasa seperti Facebook (di masa awal), Twitter, dan YouTube. Dengan hanya ~50 baris kode yang baru saja kita tulis, kamu sudah menggunakan teknologi yang sama seperti yang dipakai jutaan aplikasi global!

5. Struktur Proyek dan Best Practice Node.js MySQL

Sebelum proyek kamu makin besar dan berantakan, yuk kenali struktur folder yang rapi untuk aplikasi Node.js MySQL. Ini bukan sekedar estetika — struktur yang baik membuat kode lebih mudah di-maintain, di-debug, dan dikembangkan bersama tim.

📁 Struktur Folder yang Disarankan

my-api/
├── db.js          ← konfigurasi koneksi pool
├── app.js         ← entry point Express
├── routes/
│   └── users.js   ← semua route /users dipisah di sini
├── controllers/
│   └── userCtrl.js ← logika bisnis (query ke DB)
├── .env               ← simpan credential database
└── package.json

Simpan credential database di file .env menggunakan package dotenv — jangan hardcode password di kode!

📄 .env

DB_HOST=localhost
DB_USER=root
DB_PASS=passwordkamu
DB_NAME=belajar_nodejs

💡

Tips Keamanan

Setelah buat file .env, tambahkan ke .gitignore supaya credential-mu tidak ikut terupload ke GitHub. Ini kebiasaan wajib setiap developer profesional!

✅ Kesimpulan

Sekarang Data Kamu Tersimpan Permanen! 🎉

Di artikel ini, kamu sudah menguasai cara melakukan koneksi database MySQL Node.js menggunakan connection pool, menjalankan query MySQL Express untuk operasi CRUD lengkap, dan mengintegrasikan semuanya ke REST API. Tiga skill utama yang sudah kamu kuasai:

• ✦ Install dan konfigurasi mysql2/promise dengan connection pool
• ✦ Menjalankan query SELECT, INSERT, UPDATE, DELETE dengan parameterized query yang aman
• ✦ Membangun REST API Express yang terhubung penuh ke database MySQL

Punya pertanyaan atau ada bagian yang masih membingungkan? Yuk tulis di kolom komentar — kita diskusi bareng! Kalau artikel ini bermanfaat, bantu share ke teman-temanmu yang juga lagi belajar backend. 🙏

Lanjut Artikel 9 → MongoDB 🍃 Lihat Semua Artikel 📚

🏷️ Tags Artikel

#BelajarNodeJS #ZeroToZorro #NodeJsMySQL #KoneksiDatabase #QueryMySQLExpress #RESTAPI #BackendDevelopment #ExpressJS

📚

Seri Lengkap

Node.js from Zero to Zorro

Artikel ini adalah bagian dari seri lengkap 16 artikel belajar Node.js dari nol sampai mahir. Klik tombol di bawah untuk melihat daftar isi lengkap dan navigasi antar artikel.

🗺️ Lihat Daftar Isi Lengkap →

🧭 Navigasi Artikel

← Artikel Sebelumnya

7. Kelola Data dengan RESTful API

Express.js · REST API

Artikel Selanjutnya →

9. Lebih Modern dengan MongoDB

MongoDB · Mongoose · CRUD