Membuat Simple Rest API Dengan Node Js

December 20, 2023

Node Js adalah sebuah platform yang memungkinkan kita untuk menjalankan JavaScript di luar browser. Node Js sangat cocok untuk membuat aplikasi web yang bersifat real-time, scalable, dan performant. Salah satu keunggulan Node Js adalah kemampuannya untuk membuat REST API, yaitu sebuah antarmuka yang memungkinkan komunikasi antara aplikasi dengan menggunakan protokol HTTP dan format data JSON atau XML.

Dalam artikel ini, kita akan belajar bagaimana membuat simple REST API dengan Node Js menggunakan framework Express, yang merupakan salah satu framework web paling populer dan mudah digunakan di Node Js. Kita juga akan menggunakan MongoDB sebagai database NoSQL yang menyimpan data dalam bentuk dokumen JSON. Kita akan membuat REST API untuk melakukan operasi CRUD (Create, Read, Update, Delete) pada data buku.

Langkah 1: Persiapan

Sebelum memulai, pastikan kita sudah memiliki Node Js dan MongoDB terinstal di komputer kita. Kita juga perlu menginstal beberapa library atau modul yang dibutuhkan untuk membuat REST API, yaitu:

Express: framework web yang menyediakan fitur-fitur seperti routing, middleware, template engine, dan lain-lain.
Mongoose: library yang memudahkan kita untuk berinteraksi dengan MongoDB menggunakan model dan schema.
Body-parser: middleware yang membantu kita untuk mengurai data yang dikirim melalui HTTP request body.
Nodemon: alat yang memantau perubahan kode kita dan secara otomatis menjalankan ulang aplikasi kita.

Untuk menginstal library-library tersebut, kita bisa menggunakan npm (Node Package Manager), yang merupakan manajer paket bawaan Node Js. Pertama, kita buat sebuah folder untuk proyek kita, misalnya dengan nama simple-rest-api. Kemudian, kita buka folder tersebut di terminal atau command prompt, dan jalankan perintah berikut:

npm init -y

Perintah ini akan membuat sebuah file bernama package.json yang berisi informasi tentang proyek kita, seperti nama, versi, deskripsi, dan dependensi. Kita bisa mengedit file ini sesuai kebutuhan kita, atau biarkan saja dengan nilai default yang diberikan oleh npm.

Selanjutnya, kita jalankan perintah berikut untuk menginstal library-library yang dibutuhkan:

npm install express mongoose body-parser nodemon --save

Perintah ini akan mengunduh library-library tersebut dari repositori npm dan menyimpannya di folder node_modules. Perintah ini juga akan menambahkan nama dan versi library-library tersebut ke dalam file package.json di bagian dependencies. Hal ini berguna untuk memudahkan kita untuk menginstal ulang library-library tersebut di komputer lain dengan hanya menjalankan perintah npm install.

Langkah 2: Membuat Server

Setelah menginstal library-library yang dibutuhkan, kita bisa mulai membuat server Node Js yang akan menjalankan REST API kita. Pertama, kita buat sebuah file bernama server.js di folder simple-rest-api. Kemudian, kita tulis kode berikut di file tersebut:

// Mengimpor library yang dibutuhkan
const express = require('express');
const mongoose = require('mongoose');
const bodyParser = require('body-parser');

// Membuat objek aplikasi Express
const app = express();

// Mengatur port yang akan digunakan oleh server
const port = 3000;

// Menghubungkan aplikasi dengan database MongoDB
mongoose.connect('mongodb://localhost:27017/simple-rest-api', {
  useNewUrlParser: true,
  useUnifiedTopology: true
});

// Mengatur middleware body-parser untuk mengurai data JSON
app.use(bodyParser.json());

// Membuat route untuk menguji server
app.get('/', (req, res) => {
  res.send('Hello, this is a simple REST API with Node Js');
});

// Menjalankan server di port yang ditentukan
app.listen(port, () => {
  console.log(`Server is running at http://localhost:${port}`);
});

Penjelasan kode di atas adalah sebagai berikut:

Kita mengimpor library yang dibutuhkan dengan menggunakan fungsi require. Fungsi ini akan mengembalikan objek yang berisi fungsi-fungsi dan properti-properti yang disediakan oleh library tersebut.
Kita membuat objek aplikasi Express dengan menggunakan fungsi express. Objek ini akan menjadi inti dari aplikasi kita, yang menyediakan berbagai metode untuk mengatur server, routing, middleware, dan lain-lain.
Kita mengatur port yang akan digunakan oleh server dengan menggunakan variabel port. Port adalah sebuah angka yang digunakan untuk mengidentifikasi proses yang berjalan di komputer. Kita bisa menggunakan port apa saja yang tersedia, asalkan tidak bentrok dengan port yang digunakan oleh aplikasi lain. Biasanya, port yang sering digunakan untuk aplikasi web adalah 3000, 8000, atau 8080.
Kita menghubungkan aplikasi dengan database MongoDB dengan menggunakan fungsi mongoose.connect. Fungsi ini menerima sebuah parameter berupa URL yang menunjukkan lokasi dan nama database yang akan digunakan. Kita juga menambahkan beberapa opsi untuk menghindari peringatan yang muncul di terminal. Kita bisa mengganti nama database sesuai keinginan kita, asalkan tidak ada spasi atau karakter khusus.
Kita mengatur middleware body-parser untuk mengurai data JSON yang dikirim melalui HTTP request body. Middleware adalah sebuah fungsi yang dijalankan sebelum atau sesudah sebuah route dijalankan. Middleware body-parser akan membaca data yang dikirim melalui HTTP request body dan mengubahnya menjadi objek JavaScript yang bisa kita akses melalui properti req.body.
Kita membuat route untuk menguji server dengan menggunakan metode app.get. Metode ini menerima dua parameter, yaitu path dan callback. Path adalah sebuah string yang menunjukkan alamat yang akan diakses oleh HTTP request. Callback adalah sebuah fungsi yang menerima dua parameter, yaitu req dan res. Req adalah sebuah objek yang berisi informasi tentang HTTP request, seperti method, headers, query, body, dan lain-lain. Res adalah sebuah objek yang berisi metode-metode untuk mengirim HTTP response, seperti send, json, status, dan lain-lain. Dalam contoh ini, kita hanya mengirim sebuah string “Hello, this is a simple REST API with Node Js” sebagai HTTP response.
Kita menjalankan server di port yang ditentukan dengan menggunakan metode app.listen. Metode ini menerima dua parameter, yaitu port dan callback. Callback adalah sebuah fungsi yang dijalankan ketika server berhasil berjalan. Dalam contoh ini, kita hanya menampilkan sebuah pesan “Server is running at http://localhost:3000” di terminal.

Untuk menjalankan server, kita bisa membuka terminal atau command prompt di folder simple-rest-api dan menjalankan perintah berikut:

node server.js

Perintah ini akan menjalankan file server.js dengan menggunakan Node Js. Jika tidak ada error, kita akan melihat pesan “Server is running at http://localhost:3000” di terminal. Kita bisa membuka browser dan mengakses alamat http://localhost:3000 untuk melihat hasilnya. Kita seharusnya melihat sebuah teks “Hello, this is a simple REST API with Node Js” di browser.

Untuk memudahkan proses pengembangan, kita bisa menggunakan nodemon untuk menjalankan server. Nodemon adalah sebuah alat yang memantau perubahan kode kita dan secara otomatis menjalankan ulang server. Untuk menggunakan nodemon, kita bisa mengubah file package.json dan menambahkan sebuah script berikut di bagian scripts:

"start": "nodemon server.js"

Script ini akan menjalankan perintah nodemon server.js ketika kita menjalankan perintah npm start. Dengan begitu, kita tidak perlu menjalankan ulang server secara manual setiap kali kita mengubah kode. Kita bisa membuka terminal atau command prompt di folder simple-rest-api dan menjalankan perintah berikut:

npm start

Perintah ini akan menjalankan script yang sudah kita tambahkan di file package.json. Jika tidak ada error, kita akan melihat pesan “Server is running at http://localhost:3000” di terminal. Kita bisa membuka browser dan mengakses alamat http://localhost:3000 untuk melihat hasilnya. Kita juga bisa mengubah kode di file server.js dan melihat perubahan yang terjadi di browser tanpa harus menjalankan ulang server.

Langkah 3: Membuat Model

Setelah berhasil membuat server, kita bisa mulai membuat model untuk data buku yang akan kita simpan di database MongoDB. Untuk membuat model, kita perlu menggunakan mongoose, yang merupakan library yang memudahkan kita untuk berinteraksi dengan MongoDB menggunakan model dan schema. Model adalah sebuah objek yang merepresentasikan koleksi dokumen di database, sedangkan schema adalah sebuah objek yang mendefinisikan struktur dan validasi data untuk model.

Pertama, kita buat sebuah file bernama book.js di folder simple-rest-api. Kemudian, kita tulis kode berikut di file tersebut:

// Mengimpor mongoose
const mongoose = require('mongoose');

// Membuat schema untuk data buku
const bookSchema = new mongoose.Schema({
  title: {
    type: String,
    required: true
  },
  author: {
    type: String,
    required: true
  },
  genre: {
    type: String,
    required: true
  },
  year: {
    type: Number,
    required: true
  }
});

// Membuat model untuk data buku
const Book = mongoose.model('Book', bookSchema);

// Menyimpan model ke dalam module.exports agar bisa diimpor oleh file lain
module.exports = Book;

Penjelasan kode di atas adalah sebagai berikut:

Kita mengimpor mongoose dengan menggunakan fungsi require.
Kita membuat schema untuk data buku dengan menggunakan konstruktor new mongoose.Schema. Konstruktor ini menerima sebuah parameter berupa objek yang menentukan properti-properti dan tipe data yang dimiliki oleh data buku. Kita juga bisa menambahkan beberapa opsi untuk setiap properti, seperti required, yang menentukan apakah properti tersebut wajib diisi atau tidak. Dalam contoh ini, kita menentukan bahwa data buku memiliki empat properti, yaitu title, author, genre, dan year, yang semuanya bertipe String atau Number dan wajib diisi.
Kita membuat model untuk data buku dengan menggunakan fungsi mongoose.model. Fungsi ini menerima dua parameter, yaitu nama model dan schema yang digunakan. Nama model akan menjadi nama koleksi di database, yang biasanya menggunakan bentuk jamak dan huruf kecil. Dalam contoh ini, kita menggunakan nama model Book, yang akan menjadi koleksi books di database. Fungsi ini akan mengembalikan sebuah objek yang berisi metode-metode untuk melakukan operasi CRUD pada data buku, seperti find, create, update, delete, dan lain-lain.
Kita menyimpan model ke dalam module.exports agar bisa diimpor oleh file lain. module.exports adalah sebuah objek yang berisi nilai-nilai yang bisa diakses oleh file lain yang mengimpor file ini. Dengan begitu, kita bisa menggunakan model Book di file server.js atau file lain yang membutuhkannya.

Langkah 4: Membuat Route

Setelah membuat model, kita bisa mulai membuat route untuk REST API kita. Route adalah sebuah fungsi yang menentukan apa yang akan terjadi ketika sebuah HTTP request mengakses alamat tertentu. Route biasanya terdiri dari tiga bagian, yaitu method, path, dan callback. Method adalah sebuah string yang menunjukkan jenis HTTP request yang digunakan, seperti GET, POST, PUT, atau DELETE. Path adalah sebuah string yang menunjukkan alamat yang akan diakses oleh HTTP request. Callback adalah sebuah fungsi yang menerima dua parameter, yaitu req dan res, yang berisi informasi tentang HTTP request dan response.

Dalam contoh ini, kita akan membuat empat route untuk melakukan operasi CRUD pada data buku, yaitu:

GET /books: untuk mendapatkan semua data buku yang ada di database.
POST /books: untuk menambahkan data buku baru ke database.
PUT /books/:id: untuk mengubah data buku yang sudah ada di database berdasarkan id.
DELETE /books/:id: untuk menghapus data buku yang sudah ada di database berdasarkan id.

Untuk membuat route, kita perlu mengimpor model Book yang sudah kita buat sebelumnya. Kita juga bisa menggunakan objek Router yang disediakan oleh Express untuk mengelompokkan route yang memiliki path yang sama. Dengan begitu, kita bisa membuat kode yang lebih rapi dan mudah dibaca.

Pertama, kita buat sebuah file bernama book.js di folder simple-rest-api/routes. Kemudian, kita tulis kode berikut di file tersebut:

// Mengimpor express dan model Book
const express = require('express');
const Book = require('../book');

// Membuat objek router
const router = express.Router();

// Membuat route untuk mendapatkan semua data buku
router.get('/', async (req, res) => {
  try {
    // Menggunakan metode find untuk mendapatkan semua data buku dari database
    const books = await Book.find();
    // Mengirim data buku sebagai HTTP response dengan format JSON
    res.json(books);
  } catch (err) {
    // Menangkap error dan mengirim pesan error sebagai HTTP response dengan status 500
    res.status(500).json({ message: err.message });
  }
});

// Membuat route untuk menambahkan data buku baru
router.post('/', async (req, res) => {
  try {
    // Membuat objek buku baru dengan menggunakan data yang dikirim melalui HTTP request body
    const book = new Book({
      title: req.body.title,
      author: req.body.author,
      genre: req.body.genre,
      year: req.body.year
    });
    // Menggunakan metode save untuk menyimpan data buku baru ke database
    const newBook = await book.save();
    // Mengirim data buku baru sebagai HTTP response dengan format JSON dan status 201
    res.status(201).json(newBook);
  } catch (err) {
    // Menangkap error dan mengirim pesan error sebagai HTTP response dengan status 400
    res.status(400).json({ message: err.message });
  }
});

// Membuat middleware untuk mendapatkan data buku berdasarkan id
// Middleware ini akan digunakan oleh route PUT dan DELETE
router.use('/:id', async (req, res, next) => {
  try {
    // Menggunakan metode findById untuk mendapatkan data buku dari database berdasarkan id yang dikirim melalui path parameter
    const book = await Book.findById(req.params.id);
    // Jika data buku tidak ditemukan, mengirim pesan error sebagai HTTP response dengan status 404
    if (book == null) {
      return res.status(404).json({ message: 'Book not found' });
    }
    // Jika data buku ditemukan, menyimpan data buku ke dalam properti req.book dan memanggil fungsi next untuk melanjutkan ke route selanjutnya
    req.book = book;
    next();
  } catch (err) {
    // Menangkap error dan mengirim pesan error sebagai HTTP response dengan status 500
    res.status(500).json({ message: err.message });
  }
});

// Membuat route untuk mengubah data buku berdasarkan id
router.put('/:id', async (req, res) => {
  try {
    // Mengubah properti-properti data buku yang ada di properti req.book dengan menggunakan data yang dikirim melalui HTTP request body
    req.book.title = req.body.title;
    req.book.author = req.body.author;
    req.book.genre = req.body.genre;
    req.book.year = req.body.year;
    // Menggunakan metode save untuk menyimpan perubahan data buku ke database
    const updatedBook = await req.book.save();
    // Mengirim data buku yang sudah diubah sebagai HTTP response dengan format JSON
    res.json(updatedBook);
  } catch (err) {
    // Menangkap error dan mengirim pesan error sebagai HTTP response dengan status 400
    res.status(400).json({ message: err.message });
  }
});

// Membuat route untuk menghapus data buku berdasarkan id
router.delete('/:id', async (req, res) => {
  try {
    // Menggunakan metode remove untuk menghapus data buku yang ada di properti req.book dari database
    await req.book.remove();
    // Mengirim pesan sukses sebagai HTTP response dengan format JSON
    res.json({ message: 'Book deleted' });
  } catch (err) {
    // Menangkap error dan mengirim pesan error sebagai HTTP response dengan status 500
    res.status(500).json({ message: err.message });
  }
});

// Menyimpan router ke dalam module.exports agar bisa diimpor oleh file lain
module.exports = router;

Penjelasan kode di atas adalah sebagai berikut:

Kita mengimpor express dan model Book dengan menggunakan fungsi require.
Kita membuat objek router dengan menggunakan fungsi express.Router. Objek ini akan berisi route-route yang memiliki path yang sama, yaitu /books.
Kita membuat route untuk mendapatkan semua data buku dengan menggunakan metode router.get. Metode ini menerima dua parameter, yaitu path dan callback. Path adalah sebuah string yang menunjukkan alamat yang akan diakses oleh HTTP request.

Langkah 5: Mengatur Routing

Setelah membuat route, kita perlu mengatur routing di file server.js agar route-route yang kita buat bisa diakses oleh HTTP request. Routing adalah sebuah proses yang menentukan route mana yang akan dijalankan berdasarkan method dan path yang dikirim oleh HTTP request. Untuk mengatur routing, kita perlu mengimpor router yang sudah kita buat sebelumnya dan menggunakan metode app.use untuk menambahkan router ke dalam aplikasi Express.

Pertama, kita buka file server.js di folder simple-rest-api. Kemudian, kita tulis kode berikut di file tersebut:

// Mengimpor library yang dibutuhkan
const express = require('express');
const mongoose = require('mongoose');
const bodyParser = require('body-parser');

// Mengimpor router untuk data buku
const bookRouter = require('./routes/book');

// Membuat objek aplikasi Express
const app = express();

// Mengatur port yang akan digunakan oleh server
const port = 3000;

// Menghubungkan aplikasi dengan database MongoDB
mongoose.connect('mongodb://localhost:27017/simple-rest-api', {
  useNewUrlParser: true,
  useUnifiedTopology: true
});

// Mengatur middleware body-parser untuk mengurai data JSON
app.use(bodyParser.json());

// Mengatur routing untuk data buku dengan menggunakan router yang sudah diimpor
app.use('/books', bookRouter);

// Membuat route untuk menguji server
app.get('/', (req, res) => {
  res.send('Hello, this is a simple REST API with Node Js');
});

// Menjalankan server di port yang ditentukan
app.listen(port, () => {
  console.log(`Server is running at http://localhost:${port}`);
});

Penjelasan kode di atas adalah sebagai berikut:

Kita mengimpor router untuk data buku dengan menggunakan fungsi require. Kita perlu menuliskan path relatif dari file server.js ke file book.js yang berisi router tersebut, yaitu ./routes/book.
Kita mengatur routing untuk data buku dengan menggunakan metode app.use. Metode ini menerima dua parameter, yaitu path dan middleware. Path adalah sebuah string yang menunjukkan alamat yang akan diakses oleh HTTP request. Middleware adalah sebuah fungsi yang dijalankan sebelum atau sesudah sebuah route dijalankan. Dalam contoh ini, kita menggunakan router yang sudah kita buat sebagai middleware, dan menambahkan path /books di depannya. Hal ini berarti bahwa semua route yang ada di router tersebut akan memiliki path yang diawali dengan /books. Misalnya, route GET / di router tersebut akan menjadi GET /books/ di aplikasi Express.

Dengan begitu, kita sudah selesai membuat simple REST API dengan Node Js. Kita bisa menguji REST API kita dengan menggunakan alat seperti Postman, Insomnia, atau Curl. Kita bisa mengirim HTTP request ke alamat http://localhost:3000/books dengan method dan data yang sesuai dengan operasi CRUD yang ingin kita lakukan. Kita seharusnya mendapatkan HTTP response dengan format JSON yang berisi data buku atau pesan error yang sesuai dengan hasil operasi CRUD tersebut.