Membangun REST API dengan Node.js & Express

Ingin membuat backend untuk aplikasi web atau mobile Anda? REST API adalah cara standar untuk melakukannya. Tutorial ini akan memandu Anda membangun REST API pertama Anda menggunakan Node.js dan Express, framework web populer untuk Node.js. Kita akan membuat API sederhana untuk mengelola daftar item.

Apa itu REST API?

REST (Representational State Transfer) adalah gaya arsitektur untuk membangun layanan web. REST API memungkinkan sistem yang berbeda (misalnya, frontend web dan backend server) berkomunikasi satu sama lain melalui protokol HTTP. Komunikasi ini biasanya menggunakan format data JSON. Operasi dasar dalam REST API melibatkan metode HTTP seperti:

GET: Untuk mengambil data.
POST: Untuk membuat data baru.
PUT / PATCH: Untuk memperbarui data yang ada.
DELETE: Untuk menghapus data.

Mengapa Node.js & Express?

Node.js adalah runtime JavaScript yang memungkinkan Anda menjalankan JavaScript di sisi server. Ini populer karena berbasis event, non-blocking I/O, membuatnya efisien untuk aplikasi yang menangani banyak koneksi bersamaan. Express adalah framework web minimalis dan fleksibel untuk Node.js, mempermudah pembuatan server web dan API dengan menyediakan fitur routing, middleware, dan lainnya.

Prasyarat

Node.js dan npm/yarn terinstall: Anda bisa mengunduhnya dari nodejs.org. npm (Node Package Manager) atau yarn akan terinstall bersama Node.js.
Pemahaman Dasar JavaScript: Variabel, fungsi, object, array, asynchronous (Promises/async-await akan membantu).
Terminal / Command Prompt: Anda perlu menjalankan beberapa perintah.
API Testing Tool (Opsional tapi Direkomendasikan): Postman atau Insomnia sangat membantu untuk menguji endpoint POST, PUT, DELETE. Alternatifnya, kita akan gunakan curl.

Langkah 1: Setup Project

Mari kita mulai dengan membuat direktori proyek dan menginisialisasi Node.js project.


# Buat direktori baru dan masuk ke dalamnya
mkdir simple-api
cd simple-api

# Inisialisasi proyek Node.js (membuat package.json)
npm init -y
# atau jika menggunakan yarn: yarn init -y

# Install Express sebagai dependency
npm install express
# atau jika menggunakan yarn: yarn add express

Perintah ini akan membuat file package.json (menyimpan metadata proyek dan daftar dependensi) dan folder node_modules (tempat menyimpan library yang diinstall, seperti Express).

Langkah 2: Membuat Server Express Sederhana

Buat file baru bernama server.js (atau app.js) di root direktori proyek Anda dan tambahkan kode berikut:


// 1. Import library Express
const express = require('express');

// 2. Buat instance aplikasi Express
const app = express();

// 3. Tentukan port server akan berjalan
//    Gunakan port dari environment variable jika ada, atau default ke 3000
const PORT = process.env.PORT || 3000;

// 4. Definisikan route sederhana untuk root URL ('/')
//    req = request object, res = response object
app.get('/', (req, res) => {
  res.send('Selamat Datang di Simple API!'); // Kirim response teks sederhana
});

// 5. Jalankan server dan dengarkan koneksi di port yang ditentukan
app.listen(PORT, () => {
  console.log(`Server berjalan di http://localhost:${PORT}`);
});

Untuk menjalankan server, buka terminal Anda di direktori proyek dan jalankan:


node server.js

Jika berhasil, Anda akan melihat pesan "Server berjalan di http://localhost:3000". Buka browser Anda dan kunjungi http://localhost:3000, Anda seharusnya melihat teks "Selamat Datang di Simple API!". Tekan `Ctrl + C` di terminal untuk menghentikan server.

Langkah 3: Membuat Data Dummy & Endpoint GET

Untuk tutorial ini, kita akan menggunakan array sederhana di memori sebagai database sementara. Tambahkan ini di server.js setelah inisialisasi `app`:


// ... (setelah const app = express();)

// Data dummy (biasanya ini dari database)
let items = [
  { id: 1, name: "Item Satu" },
  { id: 2, name: "Item Dua" },
  { id: 3, name: "Item Tiga" },
];

// Middleware untuk logging request sederhana (opsional)
app.use((req, res, next) => {
  console.log(`${req.method} ${req.url}`);
  next(); // Lanjutkan ke handler berikutnya
});

// Endpoint GET untuk mendapatkan semua item
// URL: /items
app.get('/items', (req, res) => {
  res.json(items); // Kirim response sebagai JSON
});

// Endpoint GET untuk mendapatkan item spesifik berdasarkan ID
// URL: /items/:id (contoh: /items/1)
app.get('/items/:id', (req, res) => {
  // Ambil ID dari parameter URL (selalu string)
  const itemId = parseInt(req.params.id);

  // Cari item dalam array
  const item = items.find(i => i.id === itemId);

  if (item) {
    res.json(item); // Kirim item jika ditemukan
  } else {
    // Kirim status 404 (Not Found) jika item tidak ada
    res.status(404).json({ message: 'Item tidak ditemukan' });
  }
});

// ... (route '/' dan app.listen tetap ada di bawah)

Jalankan lagi server (`node server.js`). Sekarang Anda bisa menguji endpoint baru:

Buka http://localhost:3000/items di browser untuk melihat semua item dalam format JSON.
Buka http://localhost:3000/items/2 untuk melihat item dengan ID 2.
Buka http://localhost:3000/items/99 untuk melihat pesan error 404.

Tips: Ekstensi browser seperti "JSON Formatter" atau "JSONView" dapat membantu menampilkan data JSON agar lebih mudah dibaca di browser.

Langkah 4: Membuat Endpoint POST

Untuk membuat item baru, kita menggunakan metode POST. Klien akan mengirim data (biasanya dalam format JSON) di dalam *request body*. Agar Express bisa membaca JSON dari request body, kita perlu menggunakan *middleware* bawaan `express.json()`.

Tambahkan middleware ini sebelum definisi route Anda:


// ... (setelah let items = [...];)

// Middleware untuk parsing JSON request body
app.use(express.json());

// Middleware logging request (jika ada)
// app.use((req, res, next) => { ... });

// Endpoint GET /items
// app.get('/items', ...);

// Endpoint GET /items/:id
// app.get('/items/:id', ...);

// --- Tambahkan Endpoint POST di sini ---
// URL: /items , Method: POST
app.post('/items', (req, res) => {
  // Ambil data dari request body
  const newItemName = req.body.name;

  // Validasi sederhana (pastikan nama ada)
  if (!newItemName) {
    return res.status(400).json({ message: 'Properti "name" dibutuhkan' });
  }

  // Buat item baru
  const newItem = {
    id: items.length > 0 ? Math.max(...items.map(i => i.id)) + 1 : 1, // Generate ID sederhana
    name: newItemName
  };

  // Tambahkan item baru ke array (database dummy)
  items.push(newItem);
  console.log('Item baru ditambahkan:', newItem);

  // Kirim response: status 201 (Created) dan item yang baru dibuat
  res.status(201).json(newItem);
});


// ... (route '/' dan app.listen tetap ada di bawah)

Karena browser hanya bisa melakukan request GET secara langsung, kita perlu menggunakan `curl` atau alat API testing untuk menguji endpoint POST ini.

Hentikan server (`Ctrl + C`) dan jalankan lagi (`node server.js`). Lalu, buka terminal *baru* (biarkan server tetap berjalan di terminal pertama) dan jalankan perintah `curl` berikut:


# Kirim request POST ke /items dengan data JSON
curl -X POST http://localhost:3000/items \
     -H "Content-Type: application/json" \
     -d '{"name": "Item Baru dari Curl"}'

Anda seharusnya mendapatkan response JSON berisi item yang baru dibuat (misalnya, dengan ID 4).


{
  "id": 4,
  "name": "Item Baru dari Curl"
}

Sekarang, jika Anda akses http://localhost:3000/items lagi di browser, Anda akan melihat item baru tersebut sudah ditambahkan ke dalam daftar.

Kesimpulan & Langkah Berikutnya

Selamat! Anda telah berhasil membangun REST API sederhana menggunakan Node.js dan Express. Anda telah belajar cara:

Mengatur proyek Node.js dan menginstall Express.
Membuat server Express dasar.
Mendefinisikan route GET untuk mengambil semua data dan data spesifik berdasarkan ID (menggunakan `req.params`).
Menggunakan middleware `express.json()` untuk membaca request body.
Mendefinisikan route POST untuk membuat data baru (menggunakan `req.body`).
Mengirim response JSON dengan status code yang sesuai.
Menguji API menggunakan browser dan `curl`.

Ini adalah fondasi yang bagus. Langkah selanjutnya yang bisa Anda pelajari adalah:

Menggunakan database sungguhan (seperti MongoDB dengan Mongoose, atau PostgreSQL dengan Sequelize/pg) untuk menyimpan data secara permanen.
Menambahkan endpoint PUT/PATCH untuk update dan DELETE untuk menghapus data.
Menerapkan validasi data yang lebih baik.
Menambahkan penanganan error (error handling) yang lebih robust.
Struktur proyek yang lebih terorganisir (misalnya, memisahkan routes dan controllers).
Autentikasi dan otorisasi.

Teruslah belajar dan mencoba! Dunia backend development sangat luas dan menarik.