22 Membuat Sub-Schema Berdasarkan Modul: Panduan Praktis untuk Arsitektur Data yang Modular

Di dunia pengembangan aplikasi modern, terutama ketika kita berbicara tentang sistem berskala besar atau microservices, pengelolaan skema data sering kali menjadi tantangan tersendiri. Salah satu pendekatan yang banyak digunakan adalah modularisasi skema — di mana masing-masing modul fitur aplikasi memiliki sub-schema (subs-kema) tersendiri. Dalam artikel ini, kita akan membahas secara mendalam tentang membuat sub-schema berdasarkan modul di project backend, lengkap dengan contoh kode, simulasi kasus, serta diagram alur pembentukan skema yang terintegrasi.

Mengapa Perlu Sub-Schema per Modul?

Mari kita mulai dengan pertanyaan mendasar: Kenapa perlu membuat sub-schema berdasarkan modul?

Beberapa alasannya antara lain:

• Organisir kode lebih rapi: Skema data milik fitur spesifik hanya tinggal di folder modul miliknya.
• Kemudahan scaling dan maintainability: Saat menambah/merubah fitur, hanya perlu menyentuh bagian yang related.
• Mencegah “Entitas God”: Satu file schema besar membuat data model sulit dipelihara dan rentan terjadi konflik saat kolaborasi antar engineer.

Studi Kasus: Proyek CRUD Sederhana

Kita asumsikan membangun aplikasi RESTful sederhana dengan dua modul utama: Users dan Posts. Masing-masing punya schema dan logika sendiri. Kita akan pakai MongoDB dan Mongoose pada Node.js untuk ilustrasi implementasi.

Struktur folder project modular:

src/
│
├── modules/
│   ├── user/
│   │   ├── user.model.js
│   │   └── user.controller.js
│   └── post/
│       ├── post.model.js
│       └── post.controller.js
│
├── app.js
└── database.js

Membuat Sub-Schema: Contoh Implementasi

1. User Schema

// src/modules/user/user.model.js
const mongoose = require('mongoose');

const userSchema = new mongoose.Schema({
    name: { type: String, required: true },
    email: { type: String, unique: true },
    password: { type: String, required: true },
    createdAt: { type: Date, default: Date.now }
});

module.exports = mongoose.model('User', userSchema);

2. Post Schema dengan Sub-Schema (Embedded)

Akan lebih menarik jika di modul Post, kita embed sub-schema Comment khusus:

// src/modules/post/post.model.js
const mongoose = require('mongoose');

const commentSchema = new mongoose.Schema({
    user: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
    message: { type: String, required: true },
    postedAt: { type: Date, default: Date.now }
}, { _id: false }); // Sub-schema: komentar tidak perlu _id terpisah

const postSchema = new mongoose.Schema({
    title: String,
    content: String,
    author: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
    comments: [commentSchema] // Array sub-schema
});

module.exports = mongoose.model('Post', postSchema);

Keuntungan:
Sub-schema Comment BERBEDA dengan schema utama User & Post, sehingga bisa evolve mandiri sesuai kebutuhan Post.

Simulasi Relasi dan Modularisasi

Lihat berikut, setiap module punya tanggung jawab terhadap sub-schema-nya masing-masing. Untuk ilustrasi relasi dan modularity, berikut diagram alur pengelolaan data saat menambah post baru beserta komentar:

flowchart TD
    A[Client Request: Buat Post] --> B[Modul Post Menerima Request]
    B --> C[Akses User (author) dari Modul User]
    C --> D[Lolos? Continue, Gagal? Reject]
    D --> E[Modul Post Membuat Data Post (dengan Comments sbg Sub-Schema)]
    E --> F[Simpan ke Database]
    F --> G[Response ke Client]

Flow di atas jelas modular: module Post mengelola Post+Comment, dan module User hanya jadi referensi. Sub-schema Comment exclusive milik Post.

Studi Tabel: Modularisasi Vs. Schema Global

Tips & Best Practice Sub-Schema Modular

1. Pisahkan Folder Schema per Modul
   Agar source code mudah dirawat dan scalable.

2. Jangan Duplicate Skema Antar Modul
   Jika ada schema kecil yang dipakai di banyak module (misal Address), taruh di shared schemas.

3. Gunakan Referensi jika Entitas Besar
   Untuk data besar atau berubah cepat (misal User), disarankan oleh MongoDB untuk pakai ref daripada embedded sub-schema.

4. Testing Unit untuk Setiap Schema
   Modularisasi akan mempermudah pembuatan unit-test model yang isolated.

Integrasi Semua Sub-Schema: Entry Point Aplikasi

Saat app dijalankan, biasanya main app akan mendaftarkan semua schema di entry-point, tapi kode schema dan logika tetap diserahkan ke masing-masing modul, misal:

// app.js
const express = require('express');
const mongoose = require('mongoose');

// Connect to MongoDB (sesuai file database.js)
mongoose.connect('mongodb://localhost:27017/myapp');

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

// Import router dari masing-masing modul
const userRoutes = require('./modules/user/user.controller');
const postRoutes = require('./modules/post/post.controller');

app.use('/users', userRoutes);
app.use('/posts', postRoutes);

app.listen(3000, () => console.log('Server running at http://localhost:3000'));

Simulasi API Request

Buat Post baru:

POST /posts
{
  "title": "Membuat Sub-Schema Modular",
  "content": "Sub-schema itu solusi arsitektural yang powerful.",
  "author": "665e752f92a014c5efa4fbc9",
  "comments": [
    {"user": "665e752f92a014c5efa4fbc9", "message": "Nice post, thanks!"}
  ]
}

Respons dari server akan mengandung komentar sebagai sub-document di dalam comments.

Penutup: Kapan Harus Modularisasi Schema?

Modul schema sangat bermanfaat untuk:

• Aplikasi growing fast, banyak fitur baru
• Tim developer ukuran >3
• Backend siap microservices/monolith serviceful

Dengan sub-schema per modul, arsitektur project backend jadi robust dan scalable.

Catatan engineer senior:
“Modularizing schemas is an investment in maintainability. It might seem verbose at first, but it pays off quickly as your team and app grows.”

Semoga penjelasan dan simulasi pada artikel “Membuat Sub-Schema Berdasarkan Modul” ini membantu memberikan wawasan arsitektur backend yang solid dan siap scale! Jangan ragu untuk coba modularisasi schema di project Anda berikutnya. 🚀

Referensi

• MongoDB - Schema Design
• Mongoose Subdocuments
• Node.js Modular Architecture Best Practice