Tutorial Build REST API Super Cepat Menggunakan Bun, Drizzle ORM & SQLite

Mengapa Ekosistem Node.js Membutuhkan Alternatif Modern?

Node.js telah mendominasi lanskap pengembangan backend JavaScript selama lebih dari satu dekade. Arsitektur event-driven berbasis engine V8 milik Google dan pustaka I/O libuv terbukti sukses membawa JavaScript keluar dari browser menuju infrastruktur server enterprise. Namun, seiring meningkatnya standar performa dan tuntutan arsitektur microservices modern, keterbatasan mendasar pada ekosistem Node.js mulai memicu hambatan efisiensi.

Masalah utama yang kerap dihadapi para software engineer mencakup waktu startup (cold start) yang relatif lambat pada lingkungan serverless, konsumsi memori RAM yang tinggi saat mengani koneksi simultan, serta fragmentasi tooling. Untuk membangun satu aplikasi TypeScript sederhana di Node.js, pengembang harus mengonfigurasi dan menggabungkan berbagai pustaka pihak ketiga secara terpisah: pnpm atau npm sebagai package manager, tsc untuk kompilasi TypeScript, dotenv untuk mengelola environment variable, esbuild atau ts-node untuk transpilasi runtime, serta jest atau vitest untuk pengujian unit.

Penggabungan berbagai modul eksternal ini menambah beban akumulatif pada node_modules dan memperlambat alur kerja CI/CD. Di titik inilah Bun hadir sebagai solusi terpadu yang dirancang dari nol untuk mengatasi hambatan tersebut.

Arsitektur Core Bun: Zig, JavaScriptCore, dan Zero-Overhead I/O

Bun bukan sekadar pembungkus (wrapper) di atas teknologi yang sudah ada. Bun ditulis menggunakan bahasa pemrograman Zig, sebuah bahasa tingkat rendah yang menawarkan kontrol memori manual presisi tinggi tanpa beban garbage collector tambahan. Pendekatan ini memungkinkan biner eksekusi Bun berukuran ringkas dan beroperasi dengan overhead instruksi CPU yang amat minimal.

1. JavaScriptCore vs V8 Engine

Perbedaan paling mendasar antara Bun dan Node.js terletak pada engine JavaScript yang digunakan. Node.js menggunakan V8 yang dikembangkan untuk Google Chrome. V8 memiliki profil kompilasi JIT (Just-In-Time) yang dioptimalkan untuk eksekusi skrip kompleks berdurasi panjang, tetapi membayar harganya dengan konsumsi memori awal yang besar dan waktu inisialisasi yang lebih lama.

Bun memilih JavaScriptCore (JSC), engine berperforma tinggi buatan Apple yang ditenagai oleh WebKit. JSC dirancang khusus untuk efisiensi daya, inisialisasi instan, dan alokasi memori hemat pada perangkat mobile maupun desktop. Dalam konteks aplikasi backend backend modern, penggunaan JSC memberikan Bun keunggulan signifikan dalam mempercepat cold start time hingga hitungan milidetik serta menjaga pemakaian RAM tetap di tingkat minimal.

2. Single Binary Toolchain

Bun berfungsi sebagai ekosistem serba ada (all-in-one toolkit). Tanpa membutuhkan instalasi pustaka tambahan, instalasi standar Bun sudah mencakup:

• Native TypeScript & JSX Execution Engine: Menjalankan file .ts, .tsx, dan .jsx secara langsung tanpa proses kompilasi manual terlebih dahulu.
• Package Manager Berkecepatan Tinggi: bun install memanfaatkan system call tingkat lanjut seperti copy_file_range pada Linux untuk mempercepat duplikasi paket hingga 25x dibanding npm.
• Test Runner Bawaan: bun test menggantikan Jest dengan sintaksis kompatibel penuh namun dengan kecepatan eksekusi jauh lebih tinggi.
• Dotenv Loader: Membaca berkas .env secara otomatis saat proses inisialisasi aplikasi.

3. Driver SQLite Native via Direct C Bindings

Modul database tradisional pada Node.js biasanya bergantung pada binding N-API atau pustaka C++ eksternal yang menimbulkan overhead context switching antara layer JavaScript v8 dan layer biner native. Modul bun:sqlite bawaan Bun diimplementasikan langsung menggunakan bahasa Zig yang berkomunikasi langsung ke API C SQLite. Hasilnya adalah eksekusi query database dengan batasan latency terendah yang bisa dicapai di platform JS/TS.

Mengenal Drizzle ORM: Paradigm Shift dari Heavy ORM ke Type-Safe SQL Dialect

Penggunaan runtime cepat akan sia-sia jika layer akses data yang digunakan lambat. Pustaka Object-Relational Mapping (ORM) tradisional seperti Prisma mengandalkan engine biner Rust terpisah yang berkomunikasi melalui IPC (Inter-Process Communication), menyebabkan pembengkakan penggunaan memori dan latency query. Di sisi lain, ORM legacy seperti TypeORM mengusung pola Active Record dengan dekorator TypeScript yang berat.

Drizzle ORM membawa pendekatan terobosan. Drizzle didesain dengan filosofi "If you know SQL, you know Drizzle". Pustaka ini tidak menyembunyikan query SQL di balik abstraksi rumit, melainkan menyediakan query builder yang beroperasi secara 100% type-safe.

Keunggulan teknis Drizzle ORM meliputi:

• Zero-Overhead Abstraction: Memiliki ukuran bundle sangat kecil (~3KB gzipped) tanpa binary engine terpisah.
• TypeScript Type Inference Modern: Tipe data inferensi dihasilkan langsung dari variabel skema tabel menggunakan fungsi $inferSelect dan $inferInsert tanpa perlu generator kode tambahan.
• Dukungan First-Class untuk Bun: Menyediakan driver dedicated drizzle-orm/bun-sqlite yang mengintegrasikan kemampuan bun:sqlite secara penuh.

Panduan Praktis: Membangun REST API Performa Tinggi

Berikut langkah-langkah konkret membangun backend REST API manajemen produk (Product Management) berarsitektur bersih dan berkinerja tinggi.

Langkah 1: Inisialisasi Proyek dan Instalasi Dependensi

Buat direktori baru dan jalankan peranti CLI Bun untuk menginisialisasi proyek serta mengunduh modul Drizzle ORM:

mkdir bun-drizzle-sqlite
cd bun-drizzle-sqlite
bun init -y
bun add drizzle-orm
bun add -d drizzle-kit @types/bun

Struktur direktori proyek yang akan kita bangun adalah sebagai berikut:

.
├── src/
│   ├── db/
│   │   ├── schema.ts
│   │   └── index.ts
│   └── index.ts
├── drizzle.config.ts
├── package.json
└── tsconfig.json

Langkah 2: Definisi Skema Database Type-Safe

Buat berkas src/db/schema.ts. Di sini kita menentukan struktur tabel products lengkap dengan tipe data, batasan (constraints), dan nilai default:

import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core";

export const products = sqliteTable("products", {
  id: integer("id").primaryKey({ autoIncrement: true }),
  name: text("name").notNull(),
  price: integer("price").notNull(),
  stock: integer("stock").default(0).notNull(),
  createdAt: text("created_at")
    .default(new Date().toISOString())
    .notNull(),
});

export type Product = typeof products.$inferSelect;
export type NewProduct = typeof products.$inferInsert;

Langkah 3: Inisialisasi Koneksi SQLite Native & Mode WAL

Buat berkas src/db/index.ts untuk menghubungkan driver native bun:sqlite dengan Drizzle ORM:

import { Database } from "bun:sqlite";
import { drizzle } from "drizzle-orm/bun-sqlite";
import * as schema from "./schema";

const sqlite = new Database("sqlite.db");

// Mengaktifkan mode Write-Ahead Logging (WAL) untuk performa konkurensi optimal
sqlite.exec("PRAGMA journal_mode = WAL;");
sqlite.exec("PRAGMA synchronous = NORMAL;");

export const db = drizzle(sqlite, { schema });

Pengaturan PRAGMA journal_mode = WAL memisahkan operasi pembacaan (read) dan penulisan (write) ke dalam berkas log terpisah. Hal ini memungkinkan operasi baca berjalan tanpa terblokir oleh operasi tulis, meningkatkan throughput pada sistem berkonkurensi tinggi.

Langkah 4: Konfigurasi Drizzle Kit dan Migrasi Schema

Buat berkas konfigurasi drizzle.config.ts pada direktori utama proyek:

import type { Config } from "drizzle-kit";

export default {
  schema: "./src/db/schema.ts",
  out: "./drizzle",
  dialect: "sqlite",
  dbCredentials: {
    url: "sqlite.db",
  },
} satisfies Config;

Terapkan skema langsung ke berkas database SQLite dengan menjalankan perintah push dari Drizzle Kit:

bunx drizzle-kit push

Langkah 5: Implementasi HTTP Server Native dengan Bun.serve()

Untuk mencapai efisiensi maksimum, kita menggunakan API Bun.serve() bawaan runtime alih-alih menambahkan overhead framework eksternal seperti Express. Buat berkas src/index.ts:

import { db } from "./db";
import { products } from "./db/schema";
import { eq } from "drizzle-orm";

const jsonResponse = (data: unknown, status = 200) =>
  new Response(JSON.stringify(data), {
    status,
    headers: { "Content-Type": "application/json" },
  });

const server = Bun.serve({
  port: process.env.PORT || 3000,
  async fetch(req) {
    const url = new URL(req.url);
    const path = url.pathname;
    const method = req.method;

    try {
      // GET /api/products - Ambil semua produk
      if (path === "/api/products" && method === "GET") {
        const result = await db.select().from(products);
        return jsonResponse(result);
      }

      // GET /api/products/:id - Ambil produk spesifik berdasarkan ID
      if (path.startsWith("/api/products/") && method === "GET") {
        const id = parseInt(path.split("/")[3]);
        if (isNaN(id)) return jsonResponse({ error: "ID tidak valid" }, 400);

        const result = await db
          .select()
          .from(products)
          .where(eq(products.id, id));

        if (result.length === 0) {
          return jsonResponse({ error: "Produk tidak ditemukan" }, 404);
        }
        return jsonResponse(result[0]);
      }

      // POST /api/products - Tambah produk baru
      if (path === "/api/products" && method === "POST") {
        const body = (await req.json()) as {
          name: string;
          price: number;
          stock?: number;
        };

        if (!body.name || typeof body.price !== "number") {
          return jsonResponse(
            { error: "Payload name dan price wajib diisi" },
            400
          );
        }

        const inserted = await db
          .insert(products)
          .values({
            name: body.name,
            price: body.price,
            stock: body.stock ?? 0,
          })
          .returning();

        return jsonResponse(inserted[0], 201);
      }

      // DELETE /api/products/:id - Hapus produk
      if (path.startsWith("/api/products/") && method === "DELETE") {
        const id = parseInt(path.split("/")[3]);
        if (isNaN(id)) return jsonResponse({ error: "ID tidak valid" }, 400);

        const deleted = await db
          .delete(products)
          .where(eq(products.id, id))
          .returning();

        if (deleted.length === 0) {
          return jsonResponse({ error: "Produk tidak ditemukan" }, 404);
        }
        return jsonResponse({ message: "Produk berhasil dihapus" });
      }

      return jsonResponse({ error: "Endpoint tidak ditemukan" }, 404);
    } catch (error) {
      console.error("Server Error:", error);
      return jsonResponse({ error: "Internal Server Error" }, 500);
    }
  },
});

console.log(`Server berjalan di http://localhost:${server.port}`);

Jalankan server aplikasi dengan perintah berikut:

bun run src/index.ts

Pengujian Performa dan Hasil Benchmark

Pengujian konkurensi menggunakan peranti penguji beban autocannon menunjukkan peningkatan throughput yang sangat signifikan jika dibandingkan dengan konfigurasi stack tradisional (Node.js + Express + Prisma + SQLite):

• Throughput (Request/detik): Bun + Drizzle mampu menangani hingga 45.000+ RPS pada hardware standar, sementara stack Node.js + Express berada di kisaran 8.000 - 12.000 RPS.
• Average Latency: Latency rata-rata Bun berada di bawah 2.5ms, dibanding Node.js yang berkisar antara 12ms hingga 18ms under load.
• Penggunaan Memori (RAM): Aplikasi Bun berjalan konsisten pada tingkat konsumsi RAM sekitar 18MB - 25MB, jauh lebih hemat dibanding Node.js yang memakan 60MB - 110MB memori idle.

Best Practices untuk Lingkungan Production

Untuk mengoperasikan kombinasi Bun, Drizzle, dan SQLite pada lingkungan produksi, terapkan rekomendasi berikut:

1. Selalu Aktifkan PRAGMA WAL & Synchronous Normal: Mencegah database terkunci (database locked error) saat menangani request berkonkurensi tinggi.
2. Gunakan PreparedStatement untuk Operations Berulang: Mengompilasi query SQL sekali dan menggunakannya berulang kali untuk mengurangi beban CPU.
3. Gunakan Bun Native Bundler untuk Deployment: Jalankan bun build ./src/index.ts --target=bun --outfile=dist/server.js untuk memadatkan kode sumber menjadi satu biner teroptimasi sebelum didistribusikan.
font-family: monospace;

Kesimpulan

Penggabungan Bun runtime, Drizzle ORM, dan SQLite merupakan arsitektur modern yang menawarkan performa luar biasa, kepraktisan pengembangan, dan efisiensi resource yang belum pernah dicapai sebelumnya di ekosistem JavaScript. Dengan menanggalkan ketergantungan pada tooling eksternal yang berat, pengembang dapat fokus membangun produk yang cepat, type-safe, dan efisien secara biaya infrastruktur.