Cara Membuat REST API Sederhana dengan Node.js untuk Pemula (Step-by-Step)

Mafiatek
Mafiatek

Cara Membuat REST API Sederhana dengan Node.js untuk Pemula (Step-by-Step)

Setiap kali Anda menekan tombol "Pesan" di aplikasi ojek online, ada sesuatu yang terjadi di balik layar dalam hitungan milidetik: lokasi Anda dikirim ke server, driver terdekat dicari, harga dikalkulasi, dan semua data itu dikembalikan ke layar HP Anda. Yang menghubungkan semua itu? REST API.

REST API adalah fondasi dari hampir semua aplikasi modern. Dan kabar baiknya: membuat REST API sederhana dengan Node.js tidak sepusing yang kedengarannya.

Di artikel ini, kita akan membangun REST API fungsional dari nol — lengkap dengan operasi GET, POST, PUT, dan DELETE — menggunakan Node.js dan Express. Tidak ada database dulu, tidak ada autentikasi, tidak ada deployment. Hanya satu tujuan: Anda selesai membaca artikel ini dan punya REST API yang benar-benar jalan di komputer Anda.

Apa Itu REST API? (Penjelasan Singkat Tanpa Bertele-tele)

REST API (Representational State Transfer Application Programming Interface) adalah cara dua sistem berkomunikasi lewat protokol HTTP.

Bayangkan REST API seperti pelayan restoran. Anda (client) memesan makanan lewat pelayan (API), pelayan meneruskan pesanan ke dapur (server/database), dan membawa kembali hasilnya ke meja Anda. Anda tidak perlu tahu cara kerja dapur — cukup tahu cara memesan.

4 Method HTTP yang Wajib Diketahui

Method Fungsi Analogi
GET Ambil data Minta daftar menu
POST Tambah data baru Pesan makanan baru
PUT Update data yang ada Ganti pesanan
DELETE Hapus data Batalkan pesanan

Keempat method ini membentuk apa yang disebut CRUD — Create, Read, Update, Delete. Itulah yang akan kita buat.

Persiapan: Yang Dibutuhkan Sebelum Mulai

1. Install Node.js

Cek apakah Node.js sudah terinstall:

node -v
npm -v

Kalau muncul versi (misal v22.x.x), Node.js sudah ada. Kalau belum, download dari nodejs.org — pilih versi LTS (Long Term Support).

Per Juni 2026, versi LTS terbaru adalah Node.js 22.x.

2. Code Editor

Pakai VS Code dengan extension REST Client atau Thunder Client untuk testing API nanti.

3. Pengetahuan Dasar JavaScript

Artikel ini mengasumsikan Anda sudah mengerti dasar JavaScript: variabel, fungsi, array, object, dan arrow function. Kalau belum, pelajari itu dulu sebelum lanjut.

Struktur Project yang Akan Dibuat

Sebelum mulai coding, ini gambaran project yang akan kita buat:

rest-api-buku/
├── node_modules/
├── data/
│   └── books.js        ← Data buku (pengganti database)
├── routes/
│   └── books.js        ← Route handler untuk endpoint buku
├── index.js            ← Entry point aplikasi
└── package.json        ← Konfigurasi project

Project ini adalah API untuk manajemen daftar buku — simpel tapi mencakup semua operasi CRUD yang perlu dipahami.

Langkah 1: Setup Project

Buka terminal, buat folder baru, dan inisialisasi project Node.js:

mkdir rest-api-buku
cd rest-api-buku
npm init -y

Flag -y membuat npm langsung menjawab "yes" untuk semua pertanyaan setup. File package.json akan otomatis terbuat.

Sekarang install Express — framework Node.js yang akan menangani routing dan HTTP:

npm install express

Tunggu proses install selesai. Folder node_modules dan file package-lock.json akan muncul secara otomatis.

Langkah 2: Buat Data Sementara (Pengganti Database)

Kita tidak pakai database dulu agar tidak terlalu kompleks. Data disimpan di memory (array JavaScript).

Buat folder data dan file books.js di dalamnya:

mkdir data

Buat file data/books.js dan isi dengan:

// data/books.js
let books = [
  {
    id: 1,
    title: "Laskar Pelangi",
    author: "Andrea Hirata",
    year: 2005,
    genre: "Novel"
  },
  {
    id: 2,
    title: "Bumi Manusia",
    author: "Pramoedya Ananta Toer",
    year: 1980,
    genre: "Novel Sejarah"
  },
  {
    id: 3,
    title: "Filosofi Teras",
    author: "Henry Manampiring",
    year: 2018,
    genre: "Self-Help"
  }
];

module.exports = books;

Catatan penting: Data ini hilang setiap kali server di-restart karena disimpan di memory, bukan di database. Untuk project nyata, Anda perlu database seperti PostgreSQL atau MongoDB. Tapi untuk belajar, ini lebih dari cukup.

Langkah 3: Buat Route Handler

Route handler adalah fungsi yang menentukan apa yang terjadi saat endpoint tertentu dipanggil.

Buat folder routes dan file books.js di dalamnya:

mkdir routes

Buat file routes/books.js:

// routes/books.js
const express = require('express');
const router = express.Router();
const books = require('../data/books');

// GET semua buku
router.get('/', (req, res) => {
  res.json({
    success: true,
    total: books.length,
    data: books
  });
});

// GET satu buku berdasarkan ID
router.get('/:id', (req, res) => {
  const id = parseInt(req.params.id);
  const book = books.find(b => b.id === id);

  if (!book) {
    return res.status(404).json({
      success: false,
      message: `Buku dengan ID ${id} tidak ditemukan`
    });
  }

  res.json({
    success: true,
    data: book
  });
});

// POST: tambah buku baru
router.post('/', (req, res) => {
  const { title, author, year, genre } = req.body;

  // Validasi: pastikan field wajib ada
  if (!title || !author) {
    return res.status(400).json({
      success: false,
      message: 'Field title dan author wajib diisi'
    });
  }

  // Buat ID baru (ID tertinggi + 1)
  const newId = books.length > 0 ? Math.max(...books.map(b => b.id)) + 1 : 1;

  const newBook = {
    id: newId,
    title,
    author,
    year: year || null,
    genre: genre || 'Tidak dikategorikan'
  };

  books.push(newBook);

  res.status(201).json({
    success: true,
    message: 'Buku berhasil ditambahkan',
    data: newBook
  });
});

// PUT: update buku berdasarkan ID
router.put('/:id', (req, res) => {
  const id = parseInt(req.params.id);
  const bookIndex = books.findIndex(b => b.id === id);

  if (bookIndex === -1) {
    return res.status(404).json({
      success: false,
      message: `Buku dengan ID ${id} tidak ditemukan`
    });
  }

  const { title, author, year, genre } = req.body;

  // Update hanya field yang dikirim, sisanya tetap sama
  books[bookIndex] = {
    ...books[bookIndex],
    title: title || books[bookIndex].title,
    author: author || books[bookIndex].author,
    year: year || books[bookIndex].year,
    genre: genre || books[bookIndex].genre
  };

  res.json({
    success: true,
    message: 'Buku berhasil diupdate',
    data: books[bookIndex]
  });
});

// DELETE: hapus buku berdasarkan ID
router.delete('/:id', (req, res) => {
  const id = parseInt(req.params.id);
  const bookIndex = books.findIndex(b => b.id === id);

  if (bookIndex === -1) {
    return res.status(404).json({
      success: false,
      message: `Buku dengan ID ${id} tidak ditemukan`
    });
  }

  const deletedBook = books.splice(bookIndex, 1)[0];

  res.json({
    success: true,
    message: 'Buku berhasil dihapus',
    data: deletedBook
  });
});

module.exports = router;

Langkah 4: Buat Entry Point (index.js)

File index.js adalah titik awal yang dijalankan saat server dihidupkan.

Buat file index.js di root folder project:

// index.js
const express = require('express');
const app = express();
const PORT = 3000;

// Middleware: parse JSON dari request body
// WAJIB ada sebelum semua route!
// Tanpa ini, req.body akan selalu undefined
app.use(express.json());

// Import routes
const booksRouter = require('./routes/books');

// Daftarkan route
app.use('/api/books', booksRouter);

// Route root untuk cek server hidup
app.get('/', (req, res) => {
  res.json({
    message: 'REST API Buku berjalan!',
    endpoints: {
      'GET /api/books': 'Ambil semua buku',
      'GET /api/books/:id': 'Ambil satu buku',
      'POST /api/books': 'Tambah buku baru',
      'PUT /api/books/:id': 'Update buku',
      'DELETE /api/books/:id': 'Hapus buku'
    }
  });
});

// Handle 404 untuk route yang tidak ada
app.use((req, res) => {
  res.status(404).json({
    success: false,
    message: 'Endpoint tidak ditemukan'
  });
});

// Jalankan server
app.listen(PORT, () => {
  console.log(`Server berjalan di http://localhost:${PORT}`);
});

Langkah 5: Jalankan Server

Di terminal, pastikan Anda berada di folder rest-api-buku, lalu jalankan:

node index.js

Kalau berhasil, terminal akan menampilkan:

Server berjalan di http://localhost:3000

Server sudah hidup! Buka browser dan akses http://localhost:3000 — Anda akan melihat JSON response dari endpoint root.

Tambahkan Nodemon untuk Auto-Restart (Recommended)

Saat development, sangat menyebalkan harus restart server manual setiap kali ada perubahan kode. Nodemon menyelesaikan ini — ia otomatis restart server setiap kali file disimpan.

Install nodemon sebagai development dependency:

npm install --save-dev nodemon

Buka package.json dan tambahkan script di bagian "scripts":

{
  "scripts": {
    "start": "node index.js",
    "dev": "nodemon index.js"
  }
}

Sekarang jalankan server dengan:

npm run dev

Setiap kali Anda save file, server otomatis restart.

Langkah 6: Test API dengan Thunder Client

Sekarang saatnya test semua endpoint. Kami merekomendasikan Thunder Client — extension VS Code yang ringan dan tidak perlu install aplikasi terpisah seperti Postman.

Install Thunder Client di VS Code: Extensions → search "Thunder Client" → Install.

Test 1: GET Semua Buku

  • Method: GET
  • URL: http://localhost:3000/api/books
  • Klik Send

Response yang diharapkan:

{
  "success": true,
  "total": 3,
  "data": [
    { "id": 1, "title": "Laskar Pelangi", ... },
    { "id": 2, "title": "Bumi Manusia", ... },
    { "id": 3, "title": "Filosofi Teras", ... }
  ]
}

Test 2: GET Satu Buku by ID

  • Method: GET
  • URL: http://localhost:3000/api/books/1
  • Klik Send

Response:

{
  "success": true,
  "data": {
    "id": 1,
    "title": "Laskar Pelangi",
    "author": "Andrea Hirata",
    "year": 2005,
    "genre": "Novel"
  }
}

Test 3: POST Tambah Buku Baru

  • Method: POST
  • URL: http://localhost:3000/api/books
  • Tab Body → pilih JSON
  • Isi body:
{
  "title": "Atomic Habits",
  "author": "James Clear",
  "year": 2018,
  "genre": "Self-Help"
}
  • Klik Send

Response (status 201 Created):

{
  "success": true,
  "message": "Buku berhasil ditambahkan",
  "data": {
    "id": 4,
    "title": "Atomic Habits",
    "author": "James Clear",
    "year": 2018,
    "genre": "Self-Help"
  }
}

Test 4: PUT Update Buku

  • Method: PUT
  • URL: http://localhost:3000/api/books/1
  • Body (JSON):
{
  "genre": "Novel Fiksi"
}
  • Klik Send

Response:

{
  "success": true,
  "message": "Buku berhasil diupdate",
  "data": {
    "id": 1,
    "title": "Laskar Pelangi",
    "author": "Andrea Hirata",
    "year": 2005,
    "genre": "Novel Fiksi"
  }
}

Test 5: DELETE Hapus Buku

  • Method: DELETE
  • URL: http://localhost:3000/api/books/2
  • Klik Send

Response:

{
  "success": true,
  "message": "Buku berhasil dihapus",
  "data": {
    "id": 2,
    "title": "Bumi Manusia",
    ...
  }
}

Semua endpoint berjalan. REST API Anda sudah fungsional!

Memahami Kode: Konsep Penting yang Perlu Dipahami

Middleware: express.json()

app.use(express.json());

Ini adalah middleware — fungsi yang berjalan sebelum request sampai ke route handler. express.json() bertugas mengurai (parse) data JSON yang dikirim di request body, sehingga bisa diakses lewat req.body.

Tanpa baris ini, req.body selalu undefined saat Anda kirim data POST atau PUT. Ini adalah kesalahan paling umum pemula Node.js.

HTTP Status Code

Status code adalah angka yang memberitahu client apakah request berhasil atau tidak:

Status Code Artinya Kapan Dipakai
200 OK Request berhasil (GET, PUT, DELETE)
201 Created Data baru berhasil dibuat (POST)
400 Bad Request Data yang dikirim tidak valid
404 Not Found Data yang dicari tidak ada
500 Internal Server Error Ada error di server

Selalu kembalikan status code yang tepat — ini adalah bagian dari "good API design".

req.params vs req.body vs req.query

Tiga cara client mengirim data ke API:

req.params — data di URL path:

GET /api/books/5  →  req.params.id = "5"

req.body — data di body request (JSON):

POST /api/books  →  req.body = { title: "...", author: "..." }

req.query — data di URL query string:

GET /api/books?genre=novel  →  req.query.genre = "novel"

Troubleshooting: Error yang Sering Muncul

Cannot find module 'express'

Express belum terinstall. Jalankan npm install express di folder project.

req.body selalu undefined

Lupa tambahkan app.use(express.json()) sebelum route. Pastikan baris ini ada di index.js.

Error: listen EADDRINUSE: address already in use :::3000

Port 3000 sudah dipakai oleh proses lain. Dua solusi:

Ganti port di index.js:

const PORT = 3001; // atau angka lain

Atau matikan proses yang memakai port 3000:

# Windows
netstat -ano | findstr :3000
taskkill /PID <PID_NUMBER> /F

SyntaxError: Unexpected token saat POST

Body JSON yang Anda kirim formatnya tidak valid. Pastikan:

  • Semua key dalam tanda kutip ganda: "title", bukan title
  • Tidak ada koma di akhir item terakhir
  • Tanda kutip yang dipakai adalah ", bukan " atau "

Langkah Selanjutnya Setelah Ini

REST API yang sudah Anda buat masih sangat sederhana. Ini yang perlu dipelajari berikutnya, secara berurutan:

1. Integrasikan dengan database

Data saat ini hilang setiap restart. Pelajari cara koneksi ke database:

  • SQLite (paling mudah untuk pemula, tidak perlu setup server)
  • PostgreSQL (production-grade, lebih proper)
  • MongoDB (NoSQL, populer untuk Node.js)

2. Tambahkan validasi yang lebih robust

Library Joi atau Zod bisa memvalidasi struktur data yang masuk ke API secara lebih ketat dari validasi manual.

3. Error handling yang proper

Buat middleware error handler terpusat agar semua error ditangani secara konsisten:

app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).json({ success: false, message: 'Internal server error' });
});

4. Autentikasi dengan JWT

Lindungi endpoint agar tidak bisa diakses sembarangan menggunakan JSON Web Token (JWT).

5. Deploy ke server

Setelah API siap, deploy ke platform seperti Railway, Render, atau Vercel agar bisa diakses dari internet.

Kesimpulan

Selamat — Anda baru saja membuat REST API fungsional dengan Node.js dari nol.

Recap apa yang sudah dibangun:

  • Setup project Node.js dengan Express
  • Data layer sederhana dengan array JavaScript
  • 5 endpoint CRUD: GET all, GET by ID, POST, PUT, DELETE
  • Response format yang konsisten dengan status code yang tepat
  • Testing dengan Thunder Client

Project lengkap dalam struktur yang rapi:

rest-api-buku/
├── data/books.js       ← Data buku
├── routes/books.js     ← Route handler CRUD
├── index.js            ← Server + middleware setup
└── package.json

REST API yang Anda buat sekarang bisa langsung dikonsumsi oleh frontend manapun — React, Vue, aplikasi mobile, atau bahkan aplikasi lain yang butuh data buku.

Langkah berikutnya yang paling impactful: tambahkan database. Dengan itu, data Anda tidak akan hilang lagi setiap kali server di-restart.

Ada bagian dari tutorial ini yang membingungkan atau error yang tidak ada di troubleshooting section? Tulis di kolom komentar — kami jawab!

Mafiatek
Mafiatek
Berisi Informasi Seputar Digital Berupa Perkembangan Aplikasi Android, game, Windows Pc, Office, Blog dan Teknologi Terkini Lainnya

Related Posts

Memuat…

Posting Komentar