Site icon JocoDEV

Tutorial Sequelize di Node.js: Koneksi SQLite dan CRUD Lengkap

Joko Nugroho

Sequelize adalah ORM (Object-Relational Mapping) untuk Node.js yang memungkinkan Anda berinteraksi dengan database lewat objek dan method JavaScript, tanpa menulis query SQL mentah di setiap baris kode. Bagi pemula yang ingin segera membangun backend, kombinasi Sequelize dan SQLite adalah titik awal paling praktis: tidak perlu memasang server database terpisah, cukup satu file, dan seluruh operasi CRUD bisa langsung dijalankan.

Artikel ini membahas tutorial Sequelize di Node.js secara lengkap, mulai dari instalasi, membuat koneksi ke SQLite, mendefinisikan model, hingga menjalankan operasi create, read, update, dan delete. Semua contoh kode bisa Anda salin dan jalankan langsung di komputer lokal.

Apa Itu Sequelize dan Kenapa Memilih SQLite

Sequelize mendukung banyak dialek database seperti PostgreSQL, MySQL, MariaDB, dan SQLite. Ia menyediakan model, validasi, asosiasi antar tabel, migration, serta query builder yang konsisten. Dengan pendekatan ini, kode aplikasi tidak terikat pada satu vendor database sehingga lebih mudah dipindahkan ketika kebutuhan berkembang.

SQLite cocok untuk tahap belajar dan prototipe karena bersifat file-based, tanpa konfigurasi server, dan tetap mendukung transaksi ACID. Keterbatasannya ada pada konkurensi penulisan yang terbatas, sehingga untuk aplikasi dengan trafik tinggi Anda perlu beralih ke PostgreSQL atau MySQL. Namun untuk latihan CRUD, SQLite sudah lebih dari cukup.

Persiapan Proyek Node.js dan Instalasi Sequelize

Inisialisasi proyek

Buat folder kerja, lalu inisialisasi proyek Node.js:

mkdir sequelize-sqlite-demo
cd sequelize-sqlite-demo
npm init -y

Pastikan Node.js versi LTS sudah terpasang. Jika baru pertama kali memakai Node.js, ada baiknya membaca panduan Node.js untuk pemula agar dasar seperti npm dan module system tidak membingungkan.

Instalasi dependensi

npm install sequelize sqlite3

Paket `sequelize` berisi ORM-nya, sedangkan `sqlite3` adalah driver yang menghubungkan Sequelize ke file database SQLite. Keduanya wajib dipasang karena Sequelize tidak membundel driver secara otomatis.

Membuat Koneksi Database SQLite dengan Sequelize

Buat file `database.js` di root proyek:

const { Sequelize } = require('sequelize');

const sequelize = new Sequelize({
  dialect: 'sqlite',
  storage: './database.sqlite',
  logging: false,
});

module.exports = sequelize;

Tiga opsi di atas adalah inti konfigurasi. `dialect` menentukan jenis database, `storage` menentukan lokasi file SQLite yang akan dibuat otomatis, dan `logging` dimatikan agar terminal tidak dipenuhi output query. Untuk aplikasi nyata, jangan menuliskan kredensial langsung di kode; simpan konfigurasi sensitif di environment variable.

Mendefinisikan Model Sequelize

Model adalah representasi tabel dalam bentuk class JavaScript. Buat file `models/User.js`:

const { DataTypes } = require('sequelize');
const sequelize = require('../database');

const User = sequelize.define('User', {
  name: {
    type: DataTypes.STRING,
    allowNull: false,
  },
  email: {
    type: DataTypes.STRING,
    allowNull: false,
    unique: true,
    validate: { isEmail: true },
  },
  age: {
    type: DataTypes.INTEGER,
    validate: { min: 0 },
  },
}, {
  tableName: 'users',
  timestamps: true,
});

module.exports = User;

Atribut `allowNull`, `unique`, dan `validate` membuat Sequelize menolak data yang tidak valid sebelum menyentuh database. Setelah model didefinisikan, jalankan `sequelize.sync()` sekali saat aplikasi mulai agar tabel `users` terbentuk. Untuk proyek produksi, gunakan migration alih-alih `sync()` supaya perubahan skema tercatat dan bisa di-rollback.

Menjalankan Aplikasi dan Memeriksa Database

Setelah model siap, buat file `index.js` sebagai titik masuk aplikasi:

const sequelize = require('./database');
const User = require('./models/User');

(async () => {
  await sequelize.authenticate();
  await sequelize.sync();
  console.log('Koneksi SQLite berhasil dan tabel siap dipakai');
})();

Method `authenticate()` memastikan koneksi benar-benar terbuka, sedangkan `sync()` menyesuaikan tabel dengan definisi model. Jalankan `node index.js`, lalu periksa folder proyek: akan muncul file `database.sqlite`. Anda bisa membukanya dengan DB Browser for SQLite untuk memastikan kolom `name`, `email`, dan `age` terbentuk sesuai tipe data yang diminta.

Operasi CRUD Lengkap dengan Sequelize

Create: menambah data

const user = await User.create({
  name: 'Budi',
  email: 'budi@example.com',
  age: 25,
});
console.log(user.id);

Method `create` langsung menyimpan baris baru dan mengembalikan instance model beserta `id` hasil auto-increment.

Read: membaca data

const semuaUser = await User.findAll();
const satuUser = await User.findByPk(1);
const cariEmail = await User.findOne({
  where: { email: 'budi@example.com' },
});

Gunakan `findAll` untuk daftar, `findByPk` untuk pencarian berdasarkan primary key, dan `findOne` untuk satu baris dengan kondisi tertentu. Anda juga bisa menambahkan `order`, `limit`, dan `attributes` untuk membatasi kolom yang diambil.

Update: mengubah data

await User.update(
  { age: 26 },
  { where: { id: 1 } }
);

Alternatifnya, ambil instance terlebih dahulu lalu panggil `user.update({ age: 26 })` dan `user.save()`. Cara kedua lebih mudah ketika Anda perlu menjalankan validasi per baris atau memicu hook model.

Delete: menghapus data

await User.destroy({ where: { id: 1 } });

`destroy` menghapus baris secara permanen. Jika ingin menyimpan riwayat, gunakan soft delete dengan opsi `paranoid: true` pada definisi model sehingga data hanya ditandai terhapus.

Menyajikan CRUD sebagai REST API

Agar operasi CRUD bisa diakses aplikasi lain, bungkus dengan Express:

const express = require('express');
const User = require('./models/User');

const app = express();
app.use(express.json());

app.get('/users', async (req, res) => {
  const users = await User.findAll();
  res.status(200).json(users);
});

app.post('/users', async (req, res) => {
  try {
    const user = await User.create(req.body);
    res.status(201).json(user);
  } catch (err) {
    res.status(400).json({ error: err.message });
  }
});

app.listen(3000);

Setiap endpoint memakai method dan status code yang sesuai: `200` untuk permintaan berhasil, `201` untuk data baru, `400` untuk input tidak valid, dan `404` ketika data tidak ditemukan. Memahami protokol HTTP dan status code membantu Anda merancang API yang konsisten dan mudah dipakai klien.

Untuk aplikasi yang lebih besar, pindahkan penanganan error ke middleware di aplikasi backend agar setiap route tidak perlu menulis blok `try catch` berulang.

Tips agar Implementasi Sequelize Tetap Rapi

Kesalahan Umum Saat Memakai Sequelize dan SQLite

Beberapa masalah paling sering muncul saat pertama kali memakai kombinasi ini. Pertama, lupa memasang driver `sqlite3` sehingga Sequelize melempar error dialek tidak dikenali. Kedua, memanggil `sync()` tanpa `await` sehingga query CRUD dijalankan sebelum tabel selesai dibuat. Ketiga, menyimpan file `database.sqlite` di dalam repositori Git sehingga data lokal ikut terunggah; tambahkan nama file tersebut ke `.gitignore`. Terakhir, mencampur penulisan query SQL mentah dan method ORM pada satu alur tanpa alasan jelas, yang membuat kode sulit dirawat.

Kesimpulan

Tutorial Sequelize di Node.js ini menunjukkan bahwa koneksi SQLite dan operasi CRUD lengkap bisa disiapkan dalam hitungan menit. Anda hanya perlu memasang `sequelize` dan `sqlite3`, membuat file koneksi, mendefinisikan model, lalu memanggil method `create`, `findAll`, `update`, dan `destroy`. Setelah alur dasar ini dikuasai, langkah berikutnya adalah menambahkan validasi, relasi antar tabel, migration, dan pengujian otomatis agar aplikasi tetap sehat saat skala data bertambah.

Foto sampul oleh Bernd 📷 Dittrich di Unsplash.

Exit mobile version