Belajar Node.js - Routing, Middleware, dan Request/Response

#Pendahuluan

Server HTTP dari episode 7 masih membalas semua request dengan cara yang sama. Padahal aplikasi nyata punya banyak endpoint: /pengguna, /artikel, /login, dan seterusnya. Dibutuhkan routing — mekanisme mencocokkan URL dan method ke handler yang tepat.

Episode 8 membangun fondasi itu dengan Node.js murni: router manual berbasis modul url, parsing query string, pola middleware dengan fungsi next, dan membaca body request. Pemahaman ini penting karena Express (episode 9) hanyalah penyempurnaan dari pola yang sama.

#Routing Manual

#Mencocokkan Method dan Path

Modul url membantu memecah URL menjadi bagian-bagian yang bisa dibandingkan. Gabungkan dengan req.method untuk routing lengkap:

Router manual

import http from "node:http";
import { parse } from "node:url";
 
const server = http.createServer((req, res) => {
  const url = parse(req.url, true);
 
  if (req.method === "GET" && url.pathname === "/") {
    res.end("Beranda");
  } else if (req.method === "GET" && url.pathname === "/pengguna") {
    res.end("Daftar pengguna");
  } else {
    res.writeHead(404, { "Content-Type": "text/plain" });
    res.end("Tidak ditemukan");
  }
});
 
server.listen(3000);

parse(req.url, true) menghasilkan objek dengan properti pathname dan query. Dengan membandingkan keduanya terhadap kondisi, kalian membangun routing yang bisa diperluas. Di akhir rantai if, selalu sediakan fallback 404.

#Parsing URL dan Query

#Mengambil Parameter dari Query String

Argumen kedua parse(req.url, true) mengaktifkan parsing query string otomatis. Akses parameter lewat url.query:

Membaca query string

import http from "node:http";
import { parse } from "node:url";
 
const server = http.createServer((req, res) => {
  const url = parse(req.url, true);
  if (url.pathname === "/pengguna") {
    res.end("Detail pengguna dengan id " + url.query.id);
  } else {
    res.writeHead(404);
    res.end();
  }
});
 
server.listen(3000);

Request GET /pengguna?id=42 menghasilkan url.query.id bernilai "42". Perhatikan bahwa nilai query selalu berbentuk string — konversikan ke number dengan Number(...) sebelum dipakai untuk logika. Pola ini adalah cikal bakal route parameter di Express.

#Pola Middleware

#Rantai Fungsi dengan next

Middleware adalah fungsi yang berjalan sebelum handler utama, berhak mengubah req dan res, lalu meneruskan kontrol ke fungsi berikutnya lewat next. Pola ini lahir di Node.js dan diadopsi penuh oleh Express:

Pola middleware

function logger(req, res, next) {
  console.log(req.method, req.url);
  next();
}
 
function auth(req, res, next) {
  const adaToken = req.headers["authorization"];
  if (!adaToken) {
    res.writeHead(401);
    res.end("Unauthorized");
    return;
  }
  next();
}

logger(req, res, next) mencatat request lalu memanggil next() untuk melanjutkan; auth memeriksa header dan bisa menghentikan rantai dengan response 401. Fungsi yang memanggil next() adalah kunci rantai middleware — urutan pemanggilan menentukan perilaku aplikasi.

#Membaca Body Request

#Mengumpulkan Data dari Stream

Request dengan method POST membawa data di body. Karena body berbentuk stream, kumpulkan potongan datanya lalu parse:

Membaca body request

import http from "node:http";
 
const server = http.createServer((req, res) => {
  let body = "";
  req.on("data", (chunk) => {
    body += chunk;
  });
  req.on("end", () => {
    const data = JSON.parse(body);
    console.log(data.nama);
    res.end("Data diterima");
  });
});
 
server.listen(3000);

req.on("data", ...) mengumpulkan setiap potongan body, dan setelah event end body lengkap siap di-parse. Untuk payload JSON, JSON.parse(body) mengubah teks menjadi objek. Di production, batasi ukuran body agar server tidak kehabisan memori — Express punya solusi bawaan yang akan kita lihat di episode 9.

#Menyatukan Semua Pola

#Arsitektur Handler yang Rapi

Routing, middleware, dan body parsing bekerja bersama: middleware berjalan lebih dulu untuk log dan autentikasi, router meneruskan ke handler yang tepat, dan handler membaca body bila perlu. Struktur ini — rantai fungsi sebelum dan saat response — adalah fondasi Express dan framework lain.

Di kode production, handler biasanya dipisah ke file berbeda per resource, dan middleware dirangkai dalam satu daftar. Semakin rapi kalian memisahkan tanggung jawab ini, semakin mudah kode diuji — sesuatu yang akan kita lakukan di episode 18.

#Penutup

Inti yang harus dibawa pulang:

• Routing manual membandingkan req.method dan url.pathname.
• parse(req.url, true) memberikan akses ke pathname dan query.
• Nilai query selalu string; konversi tipe sebelum dipakai.
• Middleware meneruskan kontrol lewat fungsi next.
• Middleware bisa menghentikan rantai dengan response langsung.
• Body request diambil dari stream dengan event data dan end.

Di episode 9 selanjutnya kita akan membahas Express.js atau framework minimal untuk API — install Express, routing dengan app.get dan app.post, middleware express.json, serta penanganan 404 dan error. Seluruh pola episode 8 akan kita lihat dalam bentuk yang lebih rapi.