Sebelum mulai menulis kode, mari pahami perbedaan dua kategori database yang sering digunakan dalam ekosistem Node.js.

Yang pertama adalah database SQL atau relasional. Contoh dari database ini adalah PostgreSQL, MySQL, dan SQLite. Database jenis ini sangat cocok jika data yang kamu miliki sangat terstruktur dan memiliki relasi yang kuat antar entitas. Misalnya, sebuah entitas pengguna memiliki banyak entitas postingan. Database SQL juga menjamin transaksi yang aman dengan standar ACID (Atomicity, Consistency, Isolation, Durability). Untuk berinteraksi dengan database SQL, pengembang Node.js biasanya menggunakan pustaka tambahan seperti Prisma, Drizzle, Sequelize, atau Knex.

Yang kedua adalah database NoSQL berbasis dokumen, dengan MongoDB sebagai contoh paling populer. MongoDB menawarkan skema yang lebih fleksibel, memungkinkan penyimpanan data bersarang (nested data), dan sangat mendukung proses iterasi pengembangan yang cepat. Jika struktur data aplikasimu sering berubah, NoSQL bisa menjadi pilihan yang menarik. Untuk berinteraksi dengan MongoDB di Node.js, pustaka yang menjadi standar industri adalah Mongoose, yang bertindak sebagai ODM (Object Data Modeling), atau bisa juga menggunakan driver asli MongoDB.

Alur Akses Data yang Disarankan

Saat membangun aplikasi yang berskala besar, meletakkan semua logika database di dalam file pemetaan rute (route) akan membuat kode berantakan. Terdapat sebuah konvensi atau alur akses data yang disarankan agar kodemu tetap rapi dan mudah dirawat.

Alur yang disarankan berjalan seperti ini: permintaan masuk melalui Route, kemudian Route memanggil Controller. Controller akan memanggil Service yang berisi logika bisnis aplikasi. Service inilah yang kemudian berinteraksi dengan Model atau ORM. Terakhir, Model akan meneruskan perintah tersebut ke dalam Database yang sesungguhnya. Dengan memisahkan tanggung jawab ini, kodemu akan lebih mudah diuji dan dikembangkan di masa depan.

Mongoose adalah pustaka pemodelan objek elegan yang dirancang untuk bekerja pada lingkungan asinkron. Mongoose membantu kita mendefinisikan bentuk data (skema) sebelum menyimpannya ke dalam MongoDB, sehingga kita terhindar dari masuknya data yang tidak valid.

Membuat Skema dan Model

Mari kita lihat bagaimana cara mendefinisikan sebuah skema untuk data buku menggunakan Mongoose.

// src/models/book.js
import mongoose from 'mongoose';

const bookSchema = new mongoose.Schema({
  title: { type: String, required: true, trim: true },
  author: { type: String, required: true },
  year: { type: Number, min: 1000 },
  stock: { type: Number, default: 0 }
}, { timestamps: true });

export const Book = mongoose.model('Book', bookSchema);

Pada kode di atas, kita menentukan tipe data untuk masing-masing kolom. Atribut required: true memastikan bahwa judul dan penulis wajib diisi. Atribut trim: true akan memotong spasi kosong di awal dan akhir teks. Kita juga bisa memberikan batasan minimum seperti min: 1000 untuk tahun rilis, dan nilai bawaan default: 0 untuk stok. Selain itu, opsi timestamps: true sangat berguna karena Mongoose akan otomatis membuat dan mengelola kolom createdAt dan updatedAt untuk setiap dokumen buku.

Menyambungkan Database dan Menjalankan CRUD

Setelah model siap, kita perlu menyambungkan aplikasi Express ke database MongoDB. Proses ini biasanya dilakukan saat server baru mulai menyala.

// src/server.js
import mongoose from 'mongoose';
import app from './app.js';

await mongoose.connect(process.env.MONGODB_URI);
app.listen(process.env.PORT);

Dalam Express 5, menulis operasi CRUD (Create, Read, Update, Delete) di dalam pengontrol (controller) menjadi jauh lebih ringkas. Kita tidak perlu lagi menulis blok try/catch secara manual di setiap fungsi asinkron.

// src/controllers/books.js
import { Book } from '../models/book.js';

// Menampilkan daftar buku terbaru
export const list = async (req, res) => {
  const books = await Book.find()
    .sort({ createdAt: -1 }).limit(20);
  res.json(books);
};

// Menampilkan detail satu buku
export const detail = async (req, res) => {
  const book = await Book.findById(req.params.id);
  if (!book) return res.sendStatus(404);
  res.json(book);
};

// Menambahkan buku baru
export const create = async (req, res) => {
  const book = await Book.create(req.body);
  res.status(201).json(book);
};

Berkat Express 5, jika ada kesalahan validasi data (misalnya pengguna lupa mengirim judul buku) atau database terputus saat pemanggilan await Book.create(), janji (promise) yang ditolak akan otomatis diteruskan ke penanganan error (error handler) bawaan Express. Kamu tidak perlu memanggil next(err) secara manual.

Jika proyekmu membutuhkan struktur data relasional dan tipe data yang ketat, PostgreSQL dengan Prisma 7 adalah kombinasi yang tangguh. Prisma bertindak sebagai ORM modern yang membaca skema datamu dan menghasilkan kode klien yang sepenuhnya memahami tipe data.

Persiapan dan Skema Prisma

Untuk memulai dengan Prisma, kamu perlu menginstal beberapa paket melalui terminal.

npm i -D prisma
npm i @prisma/client @prisma/adapter-pg pg
npx prisma init

Perintah inisialisasi akan membuat file konfigurasi skema. Mari kita lihat contoh skema untuk pengguna dan postingan.

// prisma/schema.prisma
generator client {
  provider = "prisma-client"
  output   = "../src/generated/prisma"
}

datasource db {
  provider = "postgresql"
}

model User {
  id       Int      @id @default(autoincrement())
  email    String   @unique
  name     String
  password String
  role     String   @default("user")
  posts    Post[]
}

model Post {
  id        Int      @id @default(autoincrement())
  title     String
  createdAt DateTime @default(now())
  author    User     @relation(fields: [authorId], references: [id])
  authorId  Int
}

Skema Prisma di atas mendefinisikan dua entitas. Pengguna memiliki kolom id yang nilainya bertambah otomatis. Kolom email ditandai sebagai unik, yang artinya tidak boleh ada dua pengguna dengan alamat email yang sama. Relasi juga terjalin jelas: satu pengguna bisa memiliki banyak postingan (Post[]), dan setiap postingan tertaut pada pengguna tertentu melalui authorId.

Setelah membuat skema, jalankan npx prisma migrate dev --name init untuk menerapkan perubahan tersebut ke dalam tabel PostgreSQL sesungguhnya, lalu npx prisma generate untuk membuat klien database.

Koneksi Klien dan Query

Selanjutnya, kita akan mengatur klien database agar dapat digunakan oleh aplikasi.

// src/db.ts
import { PrismaClient } from './generated/prisma/client';
import { PrismaPg } from '@prisma/adapter-pg';

const adapter = new PrismaPg({
  connectionString: process.env.DATABASE_URL!,
});
export const prisma = new PrismaClient({ adapter });

Sekarang kita bisa menggunakan objek prisma untuk melakukan interaksi database di dalam rute Express. Prisma memiliki API yang sangat ekspresif untuk menangani pencarian, pembatasan halaman (pagination), dan mengambil data relasional sekaligus.

// src/routes/users.ts
app.get('/api/users/:id', async (req, res) => {
  const user = await prisma.user.findUnique({
    where: { id: Number(req.params.id) },
    select: { id: true, email: true, name: true },
  });

  if (!user) return res.sendStatus(404);
  res.json(user);
});

Satu hal yang sering menjadi kesalahan fatal adalah membocorkan data sensitif. Perhatikan penggunaan properti select pada kode di atas. Dengan mendefinisikan kolom mana saja yang bernilai true, kita memastikan kolom password sama sekali tidak diambil dari database dan tidak akan pernah terkirim sebagai balasan ke klien. Ini adalah praktik keamanan yang sangat disarankan.

Prisma juga mendukung transaksi atomik. Jika kamu harus membuat pengguna baru dan profilnya secara bersamaan, dan salah satunya gagal, kamu dapat menggunakan prisma.$transaction([...]) untuk membatalkan seluruh operasi sehingga datamu tetap konsisten.