Front-End & Back-End Development 6
2.8 Mongoose ODM - Schema & Model
Setelah memahami dasar MongoDB, kini saatnya kita beralih ke Mongoose, yaitu sebuah Object Data Modeling (ODM) library yang berfungsi sebagai jembatan antara aplikasi Node.js dan database MongoDB.
Dengan Mongoose, kita tidak lagi berurusan langsung dengan data mentah di MongoDB, tetapi bekerja menggunakan struktur yang lebih rapi dan mudah dikelola melalui Schema dan Model.
Bayangkan Mongoose seperti “arsitek” dalam dunia data — ia membantu kita menentukan bentuk, aturan, serta hubungan antar data sebelum data tersebut disimpan di database. Dengan begitu, setiap data yang masuk dapat dikontrol, divalidasi, dan dikelola secara konsisten.
Mongoose juga menyediakan fitur-fitur penting seperti validasi otomatis, middleware, hingga virtual properties yang membuat pengelolaan data menjadi lebih aman, efisien, dan sesuai standar aplikasi production.
Singkatnya, penggunaan Mongoose bukan hanya soal membuat data tersimpan di database, tetapi juga memastikan bahwa data tersebut terstruktur dengan baik, valid, dan mudah diolah kembali oleh aplikasi.
2.8.1 Apa Itu Schema?
Sebelum membuat model, kita perlu memahami konsep Schema. Schema adalah rancangan atau blueprint dari struktur data yang akan disimpan di dalam database. Dengan Schema, kita dapat menentukan:
Field apa saja yang ada dalam dokumen
Tipe data untuk setiap field
Validasi seperti required, min, max, dan sebagainya
Nilai default untuk field tertentu
Mari kita analogikan Schema seperti form pendaftaran. Di dalamnya ada kolom nama, email, dan password. Sedangkan Document adalah form yang sudah diisi oleh pengguna. Dengan Schema, Mongoose membantu memastikan data yang masuk ke database selalu sesuai aturan yang kita tentukan.
2.8.2 Install Mongoose dan Membuat Schema
Selanjutnya, kita akan belajar bagaimana menginstall mongoose dan membuat schema pertama Anda! Perhatikan langkah-langkahnya ya!
1. Install Mongoose
Sebelum mulai membuat Schema, pastikan Anda sudah menginstal Mongoose di proyek Anda.
npm install mongoose
2. Membuat Schema
Mari kita buat Schema pertama untuk koleksi Product. Schema ini akan mendefinisikan struktur data, tipe, serta validasi untuk setiap produk kesehatan.
const mongoose = require("mongoose");
const productSchema = new mongoose.Schema(
{
name: {
type: String, // Tipe data
required: [true, "Nama produk wajib diisi"], // Validation
trim: true, // Hapus spasi di awal/akhir
maxlength: [100, "Nama maksimal 100 karakter"],
},
description: {
type: String,
required: [true, "Deskripsi wajib diisi"],
},
category: {
type: String,
required: true,
enum: {
values: ["Vitamin", "Supplement", "Medical Equipment", "Medicine", "Other"],
message: "{VALUE} bukan kategori valid",
},
},
price: {
type: Number,
required: true,
min: [0, "Harga harus positif"],
},
stock: {
type: Number,
required: true,
min: [0, "Stock tidak boleh negatif"],
default: 0,
},
manufacturer: { type: String, required: true },
imageUrl: { type: String, default: "/images/default-product.jpg" },
isActive: { type: Boolean, default: true },
},
{
timestamps: true, // Otomatis tambah createdAt dan updatedAt
}
);
// Export Model
module.exports = mongoose.model("Product", productSchema);
Penjelasan Properti Schema:
Perhatikan penjelasan properti dari Schema di atas!
Penjelasan Properti Schema
{
timestamps: true; // Tambah createdAt & updatedAt otomatis
}
Opsi ini secara otomatis menambahkan createdAt dan updatedAt setiap kali dokumen dibuat atau diperbarui.
"name": "Vitamin C",
"price": 85000,
"createdAt": "2024-03-20T10:00:00.000Z", // Auto-generated
"updatedAt": "2024-03-20T15:30:00.000Z" // Auto-updated
}
2.8.3 Membuat Product Schema
Bagian ini bertujuan membantu Anda membuat Mongoose schema untuk entitas Product pada proyek Health E-Commerce. Fokus utamanya adalah membangun schema yang kuat dan andal dengan validasi lengkap, pesan error kustom yang informatif, serta penggunaan timestamps untuk kebutuhan pencatatan aktivitas (audit trail). Dengan memahami struktur dan validasi yang tepat, Anda dapat memastikan integritas data sekaligus menjaga konsistensi aturan bisnis dalam aplikasi.
Pada bagian ini, Anda akan menyusun schema yang merepresentasikan struktur data produk secara jelas dan terukur. Pendekatan ini tidak hanya menuliskan struktur dasar, tetapi juga memastikan setiap field memiliki validasi yang tepat, memberikan pesan error yang mudah dipahami, serta mencatat waktu pembuatan dan pembaruan data secara otomatis. Praktik ini merupakan bagian penting dalam pengembangan aplikasi yang stabil, aman, dan siap digunakan dalam lingkungan produksi.
Langkah-langkah Praktik:
- Buat folder dan file model
- Buat folder models/ di root proyek.
- Buat file models/Product.js.
- Review dan lengkapi struktur schema
- Pastikan field mencakup: name, description, category, price, stock, manufacturer, imageUrl, dan isActive
Tambahkan validasi lengkap pada masing-masing field, termasuk batasan nilai, enum, default value, serta pesan error kustom agar mudah dipahami saat terjadi kegagalan validasi. Pastikan juga opsi timestamps: true disertakan agar setiap dokumen menyimpan informasi waktu pembuatan dan pembaruan. - Contoh schema hasil refinement (copy-paste / adaptasi)
const productSchema = new mongoose.Schema(
{
name: {
type: String,
required: [true, "Nama produk wajib diisi"], // Aiman: Custom message!
trim: true,
maxlength: [100, "Nama maksimal 100 karakter"],
},
// ... fields lainnya
},
{
timestamps: true, // Copilot kadang lupa ini!
}
);
4. Export model
module.exports = mongoose.model("Product", productSchema);
Hasil Akhir:
Anda kini memiliki Product Schema yang lengkap, memiliki validasi kuat, pesan error yang jelas, serta timestamps yang memungkinkan proses audit trail berjalan otomatis. Dengan struktur seperti ini, data produk akan lebih terjaga integritasnya dan lebih mudah dikelola dalam jangka panjang.
Tips:
- Gunakan struktur schema yang rapi dan mudah dibaca untuk memudahkan pengembangan dan kolaborasi.
- Berikan pesan error yang informatif agar tim lain dapat menampilkan respons yang ramah pengguna.
- Uji schema menggunakan berbagai skenario, seperti nilai hilang, tipe data tidak sesuai, atau nilai di bawah batas minimum.
- Pertimbangkan penambahan index untuk field yang sering digunakan dalam query agar performa tetap optimal.
2.8.4 Schema Types Reference
Setelah memahami bagaimana membuat schema pada Mongoose, kini saatnya mengenal tipe data yang bisa digunakan di dalamnya. Tipe data ini menentukan bagaimana data disimpan, divalidasi, dan digunakan dalam aplikasi Anda.
Pemilihan tipe data yang tepat akan membuat struktur database lebih efisien, mudah dipelihara, dan bebas error.
Basic Types
Mongoose mendukung berbagai tipe data untuk kebutuhan yang berbeda:
{
stringField: String,
numberField: Number,
booleanField: Boolean,
dateField: Date,
arrayField: [String], // Array of strings
objectIdField: mongoose.Schema.Types.ObjectId
}
Penjelasan singkat tiap tipe data:
- String → Menyimpan teks, seperti nama produk, deskripsi, atau kategori.
- Number → Menyimpan angka, bisa untuk harga, stok, rating, atau kuantitas.
- Boolean → Nilai logika true atau false, sering digunakan untuk status aktif atau tidak aktif.
- Date → Menyimpan informasi waktu, misalnya tanggal dibuat atau diperbarui.
- Array → Menyimpan kumpulan data sejenis, seperti daftar tag atau kategori.
- ObjectId → Tipe khusus untuk menyimpan referensi ke dokumen lain dalam koleksi berbeda.
Nested Object
Kadang, sebuah dokumen membutuhkan struktur yang lebih kompleks, misalnya menyimpan alamat dalam bentuk objek bersarang (nested object).
{
address: {
street: String,
city: String,
zipCode: String
}
}
Penjelasan:
- Nested object memungkinkan Anda menyimpan beberapa informasi yang berhubungan di bawah satu field induk. Contohnya, address memiliki street, city, dan zipCode yang semuanya merupakan bagian dari satu entitas alamat.
Array of Objects
Gunakan tipe ini ketika sebuah field perlu menyimpan banyak objek dengan struktur serupa, seperti daftar ulasan produk atau riwayat transaksi.
{
reviews: [
{
user: String,
rating: { type: Number, min: 1, max: 5 },
comment: String,
date: { type: Date, default: Date.now },
},
];
}
Penjelasan:
- Field reviews di atas berisi kumpulan objek yang memiliki user, rating, comment, dan date.
- Setiap elemen array mewakili satu ulasan (review) yang memiliki struktur sama.
- Cocok untuk data yang bersifat one-to-many, seperti satu produk memiliki banyak review.
Reference ke Model Lain
Kadang data di satu koleksi perlu terhubung dengan koleksi lain. Dalam kasus ini, gunakan tipe ObjectId dengan opsi ref untuk membuat relasi antar model.
{
userId: {
type: mongoose.Schema.Types.ObjectId,
ref: 'User', // Reference ke model User
required: true
}
}
Penjelasan:
- ObjectId digunakan untuk menyimpan ID dari dokumen lain (misalnya ID user).
- ref: 'User' menunjukkan bahwa field ini mereferensikan model User.
- Dengan ini, Anda bisa melakukan populate() untuk mengambil data lengkap dari dokumen terkait.
2.8.5 Virtual Properties
Dalam pengembangan aplikasi, terkadang kita perlu menampilkan nilai turunan dari data yang sudah ada tanpa benar-benar menyimpannya ke database.
Nah, di sinilah Virtual Property berperan. Konsep ini memungkinkan kita membuat field yang tidak tersimpan secara fisik di MongoDB, tetapi tetap bisa digunakan seperti properti biasa di dalam aplikasi. Fitur ini sangat berguna untuk perhitungan otomatis, formatting data, atau menampilkan informasi tambahan tanpa menambah beban penyimpanan data.
Virtual Property adalah field yang dihitung secara otomatis berdasarkan field lain dalam dokumen. Dengan kata lain, nilainya hanya muncul ketika data diakses melalui aplikasi, bukan ketika disimpan di database.
Contoh sederhana: menghitung harga akhir produk setelah diskon.
const productSchema = new mongoose.Schema({
price: Number,
discount: { type: Number, default: 0 }, // Discount dalam persen
});
// Virtual: hitung final price setelah discount
productSchema.virtual("finalPrice").get(function () {
return this.price - (this.price * this.discount) / 100;
});
// Usage:
const product = await Product.findOne();
console.log(product.price); // 100000
console.log(product.discount); // 10 (10%)
console.log(product.finalPrice); // 90000 (computed!)
Penjelasan Tiap Bagian:
- productSchema.virtual("finalPrice") → Membuat properti baru bernama finalPrice.
- .get(function() {...}) → Mendefinisikan logika perhitungan nilai virtual setiap kali data diambil.
- this.price dan this.discount → Mengambil nilai dari field lain di dalam dokumen yang sama.
Virtual property sangat bermanfaat untuk:
- Menghitung nilai turunan (misalnya total harga setelah diskon).
- Menggabungkan beberapa field menjadi satu tampilan data (misalnya nama depan + nama belakang).
- Menampilkan data tambahan tanpa menyimpannya di database.
2.8.6 Middleware (Hooks)
Ketika aplikasi semakin kompleks, sering kali kita perlu menjalankan proses otomatis sebelum atau sesudah data disimpan di database. Misalnya: menyesuaikan format data, menambahkan pencatatan aktivitas, atau melakukan notifikasi setelah perubahan terjadi. Untuk itulah Mongoose menyediakan fitur Middleware (Hooks), yaitu fungsi otomatis yang dijalankan di titik tertentu dalam lifecycle data.
Middleware di Mongoose memungkinkan Anda menambahkan logika tambahan yang berjalan sebelum (pre) atau sesudah (post) operasi database seperti save, remove, update, dan sebagainya.
Pre Hook (Sebelum Operasi):
- Pre hooks dijalankan sebelum data benar-benar disimpan di database. Biasanya digunakan untuk memvalidasi atau memodifikasi data terlebih dahulu.
// Sebelum save, convert name ke uppercase
productSchema.pre("save", function (next) {
this.name = this.name.toUpperCase();
next();
});
// Sebelum save, set updatedBy
productSchema.pre("save", function (next) {
this.updatedBy = "Aiman";
next();
});
Penjelasan Tiap Bagian:
- productSchema.pre("save", ...) → Fungsi dijalankan sebelum data disimpan.
- this.name = this.name.toUpperCase() → Memodifikasi nilai field name menjadi huruf besar otomatis.
- next() → Wajib dipanggil agar proses penyimpanan dilanjutkan ke tahap berikutnya.
Post Hooks (Setelah Operasi)
- Post hooks dijalankan setelah operasi database selesai. Biasanya digunakan untuk logging, notifikasi, atau tindakan lanjutan lainnya.
// Setelah save, log ke console
productSchema.post("save", function (doc) {
console.log(`✅ Product ${doc.name} saved!`);
});
// Setelah remove, log deletion
productSchema.post("remove", function (doc) {
console.log(`🗑️ Product ${doc.name} deleted!`);
});
Penjelasan Tiap Bagian:
- productSchema.post("save", ...) → Dijalankan setelah data berhasil disimpan.
- doc → Merujuk ke dokumen yang baru saja disimpan atau dihapus.
- Berguna untuk mencatat log, memperbarui sistem audit, atau mengirim notifikasi otomatis.
Kesimpulan
Mongoose ODM (Object Data Modeling) menyediakan cara yang lebih terstruktur dan efisien untuk berinteraksi dengan MongoDB melalui konsep Schema dan Model. Schema berfungsi sebagai kerangka atau blueprint yang mendefinisikan struktur dokumen dalam sebuah collection, termasuk tipe data, validasi, dan default value. Model, di sisi lain, menjadi representasi nyata dari Schema yang digunakan untuk melakukan operasi database seperti query, insert, update, dan delete.
Dengan menggunakan Schema dan Model, developer dapat menjaga konsistensi data dan mengurangi potensi error, terutama dalam proyek besar yang melibatkan banyak relasi dan aturan validasi. Pendekatan ini juga membuat kode lebih mudah dibaca, dipelihara, dan dikembangkan.
2.9 CRUD Operations dengan Moogose
Setelah mempelajari dasar Mongoose dan cara membuat model, kini saatnya kita masuk ke tahap paling penting dalam pengelolaan data: CRUD Operations.
CRUD adalah singkatan dari Create, Read, Update, dan Delete — empat operasi utama yang digunakan untuk mengelola data di database.
Dalam konteks Mongoose, setiap operasi ini dilakukan melalui method yang disediakan oleh model. Mari kita bahas langkah demi langkah.
2.9.1 Setup Connection
Sebelum kita bisa melakukan operasi CRUD, hal pertama yang harus dilakukan adalah menghubungkan aplikasi ke MongoDB. Koneksi ini penting agar aplikasi Node.js dapat berinteraksi langsung dengan database. Langkah-langkahnya:
- Import Mongoose: Gunakan require("mongoose") untuk memanggil library Mongoose.
- Buat fungsi koneksi: Fungsi connectDB menggunakan mongoose.connect() untuk menghubungkan aplikasi dengan MongoDB. URL koneksi biasanya disimpan di environment variable (process.env.MONGODB_URI).
- Tangani koneksi: Jika berhasil, tampilkan pesan “✅ MongoDB connected”; jika gagal, tampilkan error dan hentikan proses dengan process.exit(1).
// config/database.js
const mongoose = require("mongoose");
const connectDB = async () => {
try {
await mongoose.connect(process.env.MONGODB_URI);
console.log("✅ MongoDB connected");
} catch (error) {
console.error("❌ MongoDB error:", error.message);
process.exit(1);
}
};
module.exports = connectDB;
2.9.2 CREATE - Membuat Data Baru
Langkah pertama dari CRUD adalah Create, yaitu menambahkan data baru ke database. Dengan Mongoose, kita bisa melakukannya menggunakan beberapa metode berbeda, tergantung kebutuhan.
Method 1: create()
Digunakan untuk membuat dan menyimpan data baru secara langsung dalam satu langkah.
const Product = require("./models/Product");
// Create one
const vitamin = await Product.create({
name: "Vitamin C 1000mg",
description: "Suplemen untuk daya tahan tubuh",
category: "Vitamin",
price: 85000,
stock: 50,
manufacturer: "PT Sehat Sejahtera",
});
console.log("Created:", vitamin);
Method 2: new + save()
Gunakan ketika kita ingin membuat objek terlebih dahulu (misalnya untuk manipulasi data), lalu menyimpannya belakangan.
const product = new Product({
name: "Vitamin D3",
category: "Vitamin",
price: 120000,
stock: 30,
manufacturer: "PT Sehat Alami",
});
await product.save();
Insert Many: Untuk menambahkan banyak data sekaligus.
const products = await Product.insertMany([
{ name: "Product 1", price: 50000 },
{ name: "Product 2", price: 75000 }
]);
2.9.3 READ - Mengambil Data
Tahap Read digunakan untuk menampilkan data dari database. Kita bisa menampilkan semua data, mencari data tertentu, atau bahkan menggunakan kondisi dan filter yang kompleks.
Find All
Menampilkan semua data yang ada di koleksi.
const products = await Product.find();
console.log(products); // Array of all products
Find dengan Filter
Gunakan kondisi tertentu untuk menyeleksi data.
// Products category Vitamin
const vitamins = await Product.find({ category: "Vitamin" });
// Products price < 100000
const affordable = await Product.find({ price: { $lt: 100000 } });
// Products in stock
const available = await Product.find({ stock: { $gt: 0 } });
Find One
Mengambil satu data spesifik berdasarkan ID atau filter tertentu.
// Find by ID
const product = await Product.findById("507f1f77bcf86cd799439011");
// Find one dengan filter
const vitamin = await Product.findOne({ category: "Vitamin" });
// Return produk Vitamin pertama yang ditemukan
Advanced Queries
Gunakan kondisi kompleks seperti AND, OR, atau text search.
// Multiple conditions (AND)
const products = await Product.find({
category: "Vitamin",
price: { $gte: 50000, $lte: 150000 },
stock: { $gt: 0 },
});
// OR conditions
const products = await Product.find({
$or: [{ category: "Vitamin" }, { category: "Supplement" }],
});
// Text search (perlu text index)
const products = await Product.find({
$text: { $search: "vitamin immune" },
});
Query Modifiers
Gunakan fitur tambahan untuk mengatur hasil query seperti sort, limit, dan pagination.
// Sort, limit, select
const products = await Product.find({ category: "Vitamin" })
.sort({ price: 1 }) // 1 = ascending, -1 = descending
.limit(10) // Max 10 results
.select("name price -_id"); // Hanya name & price, exclude _id
// Skip (untuk pagination)
const products = await Product.find()
.skip(10) // Skip 10 pertama
.limit(10); // Ambil 10 berikutnya (page 2)
2.9.4 UPDATE - Mengubah Data
Tahap Update digunakan untuk memperbarui data yang sudah ada di database. Mongoose menyediakan beberapa metode untuk memudahkan perubahan ini.
Update One
Ada dua cara umum untuk memperbarui satu data.
1. Method 1: findByIdAndUpdate()
const product = await Product.findByIdAndUpdate(
"507f1f77bcf86cd799439011", // ID
{ price: 95000, stock: 45 }, // Updates
{
new: true, // Return updated document
runValidators: true, // Jalankan validation
}
);
2. Method 2: findOneAndUpdate()
const product = await Product.findOneAndUpdate(
{ name: "Vitamin C 1000mg" }, // Filter
{ $inc: { stock: -5 } }, // Kurangi stock 5
{ new: true, runValidators: true }
);
Update Many
Untuk memperbarui banyak data sekaligus.
// Set semua products category Vitamin jadi inStock: true
const result = await Product.updateMany(
{ category: "Vitamin" },
{ $set: { inStock: true } }
);
console.log(`Updated ${result.modifiedCount} products`);
Update Operators
Gunakan operator MongoDB untuk memodifikasi data lebih fleksibel.
await Product.updateOne(
{ name: "Vitamin C" },
{
$set: { price: 95000 }, // Set nilai
$inc: { stock: -5 }, // Kurangi 5
$push: { tags: "bestseller" }, // Add ke array
$pull: { tags: "old" }, // Remove dari array
$unset: { discount: "" }, // Hapus field
}
);
2.9.5 DELETE - Menghapus Data
Tahap terakhir dari CRUD adalah Delete, yaitu menghapus data dari database. Kita bisa menghapus satu data tertentu atau banyak data sekaligus.
Delete One
Beberapa metode yang bisa digunakan:
// Method 1: findByIdAndDelete
const deleted = await Product.findByIdAndDelete("507f1f77bcf86cd799439011");
// Method 2: findOneAndDelete
const deleted = await Product.findOneAndDelete({ name: "Vitamin C" });
// Method 3: deleteOne
const result = await Product.deleteOne({ name: "Vitamin C" });
console.log(`Deleted ${result.deletedCount} product`);
Delete Many
Untuk menghapus beberapa data sekaligus berdasarkan kondisi tertentu.
// Hapus semua products yang nggak active
const result = await Product.deleteMany({ isActive: false });
console.log(`Deleted ${result.deletedCount} products`);
2.9.6 Full CRUD dengan Mongoose
Pada sesi ini, Anda akan membangun implementasi CRUD (Create, Read, Update, Delete) secara lengkap menggunakan Mongoose. Kegiatan ini bertujuan untuk memperkuat pemahaman Anda terhadap alur kerja CRUD serta penerapannya dalam pengembangan aplikasi berbasis database MongoDB.
Setelah memahami konsep dasar CRUD secara manual, bagian ini mengajak Anda untuk mengimplementasikannya secara langsung menggunakan Mongoose. Pendekatan ini membantu Anda memahami pola logika CRUD dengan lebih terstruktur dan efisien. Seluruh aktivitas dilakukan secara mandiri dengan menuliskan fungsi-fungsi CRUD berdasarkan kebutuhan aplikasi.
Langkah-langkah Coding:
1. Buat File Service
Buat file baru: productService.js.
File ini akan berisi seluruh fungsi CRUD untuk entitas Product.
2. Import Model
Tambahkan baris berikut di bagian atas file untuk memanggil model Product:
const Product = require("./models/Product");
3. CREATE – Menambahkan Produk Baru
async function createProduct(data) {
try {
const product = await Product.create(data);
return { success: true, data: product };
} catch (error) {
return { success: false, error: error.message };
}
}
Fungsi ini menerima data produk, menyimpannya ke database, dan mengembalikan informasi keberhasilan atau kegagalan.
4. READ – Mengambil Data Produk
Selanjutnya, buat fungsi untuk membaca semua produk, serta satu produk berdasarkan ID.
async function getAllProducts(filter = {}) {
try {
const products = await Product.find(filter)
.sort({ createdAt: -1 })
.limit(50);
return { success: true, count: products.length, data: products };
} catch (error) {
return { success: false, error: error.message };
}
}
async function getProductById(id) {
try {
const product = await Product.findById(id);
if (!product) {
return { success: false, error: "Product not found" };
}
return { success: true, data: product };
} catch (error) {
return { success: false, error: error.message };
}
}
Penjelasan singkat:
- - getAllProducts() digunakan untuk menampilkan daftar produk, bisa ditambah filter berdasarkan kategori atau kondisi lain.
- - getProductById() digunakan untuk mencari produk tertentu dengan ID unik.
5. UPDATE – Mengubah Data Produk
async function updateProduct(id, updates) {
try {
const product = await Product.findByIdAndUpdate(id, updates, {
new: true,
runValidators: true,
});
if (!product) {
return { success: false, error: "Product not found" };
}
return { success: true, data: product };
} catch (error) {
return { success: false, error: error.message };
}
}
Fungsi ini menggunakan findByIdAndUpdate() untuk memperbarui data berdasarkan ID, sekaligus menjalankan validasi model agar data tetap konsisten.
6. DELETE – Menghapus Produk (Soft Delete)
Terakhir, tambahkan fungsi soft delete, yaitu menandai data sebagai tidak aktif tanpa benar-benar menghapusnya dari database.
async function deleteProduct(id) {
try {
// Soft delete: set isActive = false
const product = await Product.findByIdAndUpdate(
id,
{ isActive: false },
{ new: true }
);
if (!product) {
return { success: false, error: "Product not found" };
}
return { success: true, message: "Product deactivated" };
} catch (error) {
return { success: false, error: error.message };
}
}
Soft delete membuat data tetap tersedia di database untuk kebutuhan audit atau pemulihan.
7. Testing CRUD Functions
Setelah semua fungsi siap, buatlah fungsi testCRUD() untuk mencoba seluruh proses secara berurutan.
async function testCRUD() {
await connectDB();
// CREATE
console.log("=== CREATE ===");
const created = await createProduct({
name: "Zinc 50mg",
category: "Supplement",
price: 75000,
stock: 40,
manufacturer: "PT Mineral Health",
});
console.log(created);
// READ
console.log("\n=== READ ===");
const all = await getAllProducts({ category: "Vitamin" });
console.log(all);
// UPDATE
console.log("\n=== UPDATE ===");
const updated = await updateProduct(created.data._id, { price: 80000 });
console.log(updated);
// DELETE
console.log("\n=== DELETE ===");
const deleted = await deleteProduct(created.data._id);
console.log(deleted);
}
testCRUD();
Hasil Akhir :
Pada tahap ini, Anda telah memiliki implementasi CRUD lengkap menggunakan Mongoose yang siap dipadukan dengan Express.js untuk membangun API pada modul selanjutnya. Seluruh fungsi telah mendukung pembuatan, penampilan, pembaruan, serta penghapusan data produk secara terstruktur.
Tips Praktis :
- - Gunakan try–catch di setiap fungsi untuk menjaga penanganan error tetap rapi.
- - Kembalikan format respons yang konsisten agar mudah digunakan di frontend.
- - Gunakan soft delete agar data tidak hilang permanen dan tetap dapat diaudit.
Kesimpulan
Melalui Mongoose, operasi CRUD (Create, Read, Update, Delete) dapat dilakukan dengan cara yang lebih efisien dan terstruktur. Mongoose menyediakan berbagai method siap pakai seperti Model.create(), Model.find(), Model.updateOne(), dan Model.deleteOne() yang memudahkan pengelolaan data tanpa perlu menulis query MongoDB mentah.
Dengan memahami CRUD menggunakan Mongoose, developer dapat membangun alur data yang stabil dan konsisten di dalam aplikasi. Operasi dasar ini menjadi fondasi penting sebelum melangkah ke pengelolaan data yang lebih kompleks, seperti membuat hubungan antar koleksi dan melakukan agregasi data.
Komentar
Posting Komentar