Object Literal dalam MVC/Model-Controller-Routes di Express.js (Node.js) Mysql

Update 07/12/25 · Read 7 min

Node.js merupakan salah satu runtime JavaScript paling populer untuk membangun aplikasi web modern. Kombinasi Node.js dengan framework Express.js membuat pengembangan REST API menjadi cepat dan efisien.

Dalam membangun aplikasi berskala menengah, struktur MVC (Model-View-Controller) menjadi pendekatan yang disukai karena memisahkan logika bisnis, data, dan rute.

Salah satu cara sederhana untuk membangun model dan controller dalam Node.js adalah menggunakan Object Literal, sebuah konsep JavaScript yang memungkinkan kita mengelompokkan fungsi-fungsi dalam sebuah object.

Artikel ini akan membahas secara mendalam bagaimana menerapkan Object Literal dalam MVC di Express.js, lengkap dengan contoh CRUD (Create, Read, Update, Delete) menggunakan MySQL.

Apa itu Object Literal?

Object Literal adalah cara mendefinisikan object di JavaScript menggunakan tanda {}. Di dalam object literal, kita bisa mendefinisikan properti (data) dan method (fungsi).

Contoh sederhana:

const User = {
  name: 'Alice',
  greet() {
    console.log(`Hello, ${this.name}`);
  }
};

User.greet(); // Output: Hello, Alice

Kelebihan object literal:

Ringkas dan mudah dibaca.
Mudah di-maintain, karena semua fungsi terkait dikelompokkan.
Bisa dipakai sebagai container untuk method terkait, seperti method CRUD di model.

Dalam konteks Node.js + Express, object literal sering dipakai untuk membuat model dan controller, sehingga kode tetap rapi dan konsisten.

Mengapa Menggunakan MVC di Express.js?

MVC adalah pola desain arsitektur perangkat lunak yang memisahkan aplikasi menjadi tiga lapisan:

Model → bertanggung jawab untuk mengelola data, biasanya melakukan query ke database.
View → bertanggung jawab untuk menampilkan data ke user. (Di REST API, biasanya JSON)
Controller → bertanggung jawab untuk menghubungkan model dan view, menangani request, dan menentukan response.

Kelebihan MVC

Terstruktur dan modular: Setiap bagian aplikasi memiliki tanggung jawab jelas.
Mudah dikembangkan: Menambahkan fitur baru bisa dilakukan di layer tertentu tanpa merusak yang lain.
Maintainable: Mudah melakukan debugging karena fungsi dipisah.

Di REST API modern dengan Node.js, View sering direpresentasikan sebagai JSON response. Jadi fokus utama adalah Model dan Controller, dan Routes sebagai penghubung.

Koneksi model ke Mysql database

kode:

const mysql = require("mysql2/promise");

const pool = mysql.createPool({
  socketPath: '/var/run/mysqld/mysqld.sock',
  user: "usexxxxxx",
  password: "123xxxxxxx",
  database: "api_user",
  waitForConnections: true,
  connectionLimit: 50,
  queueLimit: 500,
});

module.exports = pool;

Object Literal untuk Model di Node.js

Model adalah lapisan yang berinteraksi langsung dengan database. Dengan Object Literal, kita bisa mengelompokkan semua fungsi query terkait satu entitas, misalnya User.

Contoh Model User

const pool = require('../db'); // koneksi MySQL

const User = {
  // Ambil semua user
  async getAllUsers() {
    const [rows] = await pool.query('SELECT * FROM users');
    return rows;
  },

  // Ambil user berdasarkan ID
  async getUserById(id) {
    const [rows] = await pool.query('SELECT * FROM users WHERE id = ?', [id]);
    return rows[0];
  },

  // Buat user baru
  async createUser(name, email) {
    const [result] = await pool.query(
      'INSERT INTO users (name, email) VALUES (?, ?)',
      [name, email]
    );
    return result.affectedRows;
  },

  // Update user
  async updateUser(id, name, email) {
    const [result] = await pool.query(
      'UPDATE users SET name = ?, email = ? WHERE id = ?',
      [name, email, id]
    );
    return result.affectedRows;
  },

  // Hapus user
  async deleteUser(id) {
    const [result] = await pool.query(
      'DELETE FROM users WHERE id = ?',
      [id]
    );
    return result.affectedRows;
  },

  // Cari user berdasarkan email
  async findByEmail(email) {
    const [rows] = await pool.query('SELECT * FROM users WHERE email = ?', [email]);
    return rows[0];
  }
};

module.exports = User;

Penjelasan

Semua fungsi CRUD terkait User dikumpulkan di satu object literal → rapi dan mudah dibaca.
Async/await digunakan untuk menunggu hasil query MySQL.
[rows] adalah hasil destructuring dari mysql2/promise.
Object literal memudahkan menambah fungsi baru, misalnya getUsersByRole() atau searchUser().

Object Literal untuk Controller

Controller bertugas menangani request dari client dan memutuskan respon JSON. Dengan object literal, kita bisa mengelompokkan semua fungsi controller yang terkait satu entitas.

READ : Install Node.js, MySQL, dan Express di Linux (Ubuntu/Debian) untuk Pemula

Contoh Controller User

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

const userController = {
  async getUsers(req, res) {
    try {
      const users = await User.getAllUsers();
      res.json(users);
    } catch (err) {
      res.status(500).json({ error: err.message });
    }
  },

  async getUserById(req, res) {
    try {
      const user = await User.getUserById(req.params.id);
      if (!user) return res.status(404).json({ message: 'User not found' });
      res.json(user);
    } catch (err) {
      res.status(500).json({ error: err.message });
    }
  },

  async createUser(req, res) {
    try {
      const { name, email } = req.body;
      const newUser = await User.createUser(name, email);
      res.status(201).json(newUser);
    } catch (err) {
      res.status(500).json({ error: err.message });
    }
  },

  async updateUser(req, res) {
    try {
      const { name, email } = req.body;
      const affectedRows = await User.updateUser(req.params.id, name, email);
      if (affectedRows === 0) return res.status(404).json({ message: 'User not found' });
      res.json({ id: req.params.id, name, email });
    } catch (err) {
      res.status(500).json({ error: err.message });
    }
  },

  async deleteUser(req, res) {
    try {
      const affectedRows = await User.deleteUser(req.params.id);
      if (affectedRows === 0) return res.status(404).json({ message: 'User not found' });
      res.json({ message: 'User deleted' });
    } catch (err) {
      res.status(500).json({ error: err.message });
    }
  }
};

module.exports = userController;

Kelebihan

Semua controller terkait User ada di satu object literal → konsisten dengan model.
Error handling menggunakan try/catch → client mendapat response yang jelas.
Mudah dihubungkan dengan routes.

Routes di Express.js

Routes adalah penghubung antara HTTP request dan controller. Dengan object literal controller, routes menjadi lebih sederhana.

const express = require('express');
const router = express.Router();
const userController = require('../controllers/userController');

router.get('/', userController.getUsers);
router.get('/:id', userController.getUserById);
router.post('/', userController.createUser);
router.put('/:id', userController.updateUser);
router.delete('/:id', userController.deleteUser);

module.exports = router;

Integrasi Routes di `app.js`

const express = require('express');
const userRoutes = require('./routes/userRoutes');

const app = express();
const PORT = 3000;

app.use(bodyParser.json());
app.use('/users', userRoutes);

app.listen(PORT, () => {
  console.log(`Server running on http://localhost:${PORT}`);
});

Mengapa Object Literal Cocok untuk MVC di Node.js?

Ringkas: Semua method terkait model atau controller dikumpulkan di satu object.
Mudah dikembangkan: Tambah fungsi baru cukup menambah method object.
Tidak perlu instance: Tidak seperti class, kita bisa langsung memanggil User.getAllUsers().
Konsisten: Model dan controller sama-sama menggunakan object literal → mudah di-maintain.
Cocok untuk CRUD standar: Sangat efisien untuk REST API dengan operasi database standar.

Best Practice Menggunakan Object Literal

Pisahkan file: models/User.js, controllers/userController.js, routes/userRoutes.js, db.js.
Gunakan async/await: Agar kode linear dan mudah dibaca.
Error handling di controller: Model cukup throw error, controller yang menangani try/catch.
Gunakan pool MySQL: Untuk performa lebih baik, hindari membuat koneksi baru setiap request.
Komentar kode: Agar mudah dipahami, terutama untuk tim atau pemula.

Menguji REST API Express.js Menggunakan Terminal Linux

Pengujian API tidak selalu membutuhkan Postman. Pada Linux, kita bisa melakukan tes endpoint dengan perintah curl. Cara ini cepat, ringan, dan ideal untuk debugging ketika membangun aplikasi Express berbasis MVC/MRC.

Menjalankan Server Express

Pastikan server Express sudah aktif:

node app.js

Jika berhasil, muncul pesan:

Server running on port 3000

Server siap menerima request.

Menguji Endpoint GET

Endpoint GET digunakan untuk mengambil data.

GET Semua Data

curl -X GET http://localhost:3000/users

GET Berdasarkan ID

curl -X GET http://localhost:3000/users/1

Perintah ini memastikan API mampu mengembalikan data sesuai permintaan.

Menguji Endpoint POST

Endpoint POST digunakan untuk menambahkan data. Kita mengirim data JSON dengan Header.

curl -X POST http://localhost:3000/users \
     -H "Content-Type: application/json" \
     -d '{"name":"Alex","email":"alex@mail.com"}'

Jika berhasil, data baru tersimpan dan response berupa objek user.

READ : Membuat Sistem Login PHP Mysql + Hashing Password BCRYPT

Menguji Endpoint PUT

PUT dipakai untuk melakukan perubahan (update).

curl -X PUT http://localhost:3000/users/1 \
     -H "Content-Type: application/json" \
     -d '{"name":"Alex Updated","email":"alexu@mail.com"}'

Response menunjukkan data berhasil diperbarui.

Menguji Endpoint DELETE

Untuk menghapus data:

curl -X DELETE http://localhost:3000/users/1

Jika berhasil, API mengirim pesan konfirmasi penghapusan.

Menampilkan Header Respons

Untuk melihat status kode HTTP dan tipe konten:

curl -i http://localhost:3000/users

Ini berguna saat debugging format respons.

Menggunakan jq untuk Format JSON

Agar tampilan JSON lebih rapi, instal jq:

sudo apt install jq

Penggunaan:

curl http://localhost:3000/users | jq

Keuntungan Menguji API Dengan Curl

Ringan dan cepat.
Tidak perlu aplikasi tambahan.
Bisa dibuat dalam script otomatis.
Cocok untuk backend developer.

Kesimpulan

Object literal adalah metode sederhana, rapi, dan praktis untuk mengimplementasikan model dan controller dalam MVC di Express.js dengan Node.js. Dengan pola ini, kode menjadi lebih modular, konsisten, dan mudah dikembangkan.

Model → Object literal mengelompokkan semua query database.
Controller → Object literal menangani logika bisnis dan error handling.
Routes → Menghubungkan HTTP request ke controller.

Pendekatan ini sangat cocok untuk proyek REST API skala kecil hingga menengah, dan bisa dengan mudah dikembangkan ke proyek yang lebih besar.