Cara Menggunakan Mongoose di Aplikasi Express

Mengelola data dalam database MongoDB dapat menjadi tantangan, terutama ketika berhadapan dengan model data yang kompleks. MongoDB adalah basis data tanpa skema, artinya data dapat ditambahkan tanpa mengikuti struktur tertentu. Fleksibilitas ini membuat MongoDB ideal untuk menyimpan data dalam jumlah besar tetapi juga membuat pengelolaan data menjadi lebih sulit.

Mongoose menyediakan solusi berbasis skema yang membantu memastikan bahwa data yang disimpan ke MongoDB konsisten dan diformat dengan benar. Dengan Mongoose, Anda dapat menentukan skema untuk model data Anda, yang menentukan struktur data dan aturan bagaimana data tersebut harus diformat. Di sini Anda akan menjelajahi cara menggunakan Mongoose di aplikasi Express.

Menyiapkan Lingkungan Pengembangan Anda

Sebelum menggunakan Mongoose, Anda harus menginstalnya sebagai dependensi di proyek Anda.

Anda dapat menginstal Mongoose dengan menjalankan perintah di bawah ini:

npm instal luwak

Setelah Anda menginstal Mongoose di proyek Anda, Anda perlu menghubungkan aplikasi Anda ke MongoDB menggunakan Mongoose.

Mongoose terhubung ke Database MongoDB menggunakan Menghubung metode, yang menggunakan URI MongoDB sebagai argumen.

Ini contohnya:

// indeks.js
const luwak = memerlukan("luwak")
luwak.sambungkan("mongodb://127.0.0.1:27017/contoh", () =>
menghibur.catatan("Berhasil terhubung ke database")
);

Blok kode di atas terhubung ke instance MongoDB lokal dan mencatat pesan sukses saat aplikasi Anda berhasil terhubung ke MongoDB.

Membuat Model Mongoose

Model Mongoose adalah kelas berbasis skema di Mongoose yang memungkinkan Anda berinteraksi dengan koleksi MongoDB.

Skema Mongoose menentukan struktur dokumen yang dapat Anda simpan dalam koleksi MongoDB dan menyediakan antarmuka untuk membuat, membaca, memperbarui, dan menghapus dokumen di dalamnya koleksi.

Saat Anda menentukan model Mongoose, Anda menentukan skema untuk dokumen dalam koleksi tersebut, termasuk properti, tipenya, dan validasi apa pun.

Berikut adalah contoh model Mongoose untuk a Pengguna koleksi:

const luwak = memerlukan("luwak");
const userSchema = luwak. Skema({
 nama: {
 jenis: Rangkaian,
 diperlukan: [BENAR, "Nama diperlukan"],
 },
 surel: {
 jenis: Rangkaian,
 diperlukan: BENAR,
 },
 usia: {
 jenis: Nomor,
 validasi: {
 validator: fungsi (nilai) {
kembali nilai > 0;
 },
 pesan: () =>"Masukkan usia yang valid",
 },
 },
});
const Pengguna = luwak.model("Pengguna", skema pengguna);
modul.ekspor = Pengguna;

Blok kode di atas mendefinisikan skema Mongoose dengan tiga properti: nama, surel, Dan usia. Setiap properti memiliki kumpulan aturan yang ditentukan yang harus Anda ikuti saat memetakan nilai ke bidang yang ditentukan. Berikut rincian aturannya:

• nama: The nama properti adalah a rangkaian jenis ditandai sebagai diperlukan, artinya Anda harus memetakan string ke bidang ini. Jika Anda membiarkan bidang kosong atau masukkan yang berbeda tipe data JavaScript, Mongoose melempar kesalahan.
• surel: The surel properti adalah a rangkaian jenis ditandai sebagai diperlukan. Tidak ada aturan validasi lain, tetapi dalam praktiknya, Anda harus memvalidasi jika emailnya benar. Anda dapat memvalidasi email menggunakan ekspresi regex atau pustaka pihak ketiga, seperti class-validator.
• usia: The usia properti adalah a nomor ketik dengan aturan validasi khusus yang memeriksa apakah nilai yang dipetakan ke bidang lebih besar dari nol. Jika nilainya tidak lolos validasi, Mongoose akan melontarkan kesalahan dengan pesan tersebut Masukkan usia yang valid. Anda dapat mengosongkan bidang ini karena tidak ditandai sebagai diperlukan.

Setelah mendefinisikan skema, blok kode membuat model Mongoose yang disebut Pengguna menggunakan luwak.model() metode. Metode ini membutuhkan dua argumen: nama model dan skema yang digunakan untuk dokumen.

Akhirnya, Pengguna model diekspor ke bagian lain dari aplikasi Anda.

Berinteraksi Dengan MongoDB Menggunakan Mongoose

Dengan aplikasi Anda terhubung ke database MongoDB dan model Anda dibuat dan dapat diakses ke bagian lain dari aplikasi Anda, Anda dapat berinteraksi dengan database Anda menggunakan metode yang disediakan oleh Mongoose.

Untuk tutorial ini, Anda akan tampil Operasi CRUD pada database MongoDB.

Catatan: Pastikan untuk mengimpor model Mongoose Anda ke modul mana pun tempat Anda akan melakukan operasi CRUD.

Misalnya:

// router.js
const Pengguna = memerlukan("./userModel")

Membuat Dokumen

Dokumen adalah turunan dari model. Ada beberapa cara untuk membuat dan menyimpan dokumen ke MongoDB menggunakan Mongoose.

Pertama, Anda dapat membuat instance dari kelas model Anda dan kemudian memanggil menyimpan metode di atasnya.

Misalnya:

//Membuat pengguna baru
membiarkan pengguna = baru Pengguna({
 nama,
 surel,
 usia,
});
//Menyimpan pengguna ke database
pengguna
 .menyimpan()
 .Kemudian(() => {
menghibur.catatan("Pengguna berhasil dibuat");
 })
 .menangkap((kesalahan) => {
// tangani kesalahan
 });

Blok kode di atas membuat dan menyimpan yang baru Pengguna dokumen ke database MongoDB Anda.

Anda juga dapat menyimpan data ke database Anda menggunakan membuat metode. Itu membuat method instantiates model Anda dan memanggil menyimpan metode di atasnya. Dengan kata lain, ini menggabungkan dua operasi dari teknik yang disebutkan sebelumnya.

Misalnya:

Pengguna.buat({ nama, email, umur }, (err, data) => {
jika (berbuat salah) melemparkanbaruKesalahan("Kesalahan server dari dalam");
menghibur.catatan(`Pengguna berhasil dibuat: ${data}`);
 });

Blok kode di atas membuat yang baru Pengguna dokumen dengan properti yang diteruskan sebagai argumen ke membuat metode.

Atau, Anda dapat menyimpan data ke database Anda menggunakan insertMany metode. Meskipun metode ini hanya ideal untuk menyimpan data secara berkelompok.

Misalnya:

Pengguna.masukkanBanyak(
 [
 { nama, email, umur },
 { nama_1, email_1, usia_1 },
 ],
 (err, hasil) => {
jika (salah) {
// tangani kesalahan
 } kalau tidak {
//Kirim hasil
 }
 }
 );

Blok kode di atas membuat dua dokumen baru di Pengguna koleksi menggunakan array yang diteruskan sebagai argumen ke insertMany metode.

Membaca Dokumen

Anda dapat mengakses semua dokumen yang disimpan di database MongoDB Anda menggunakan Mongoose menemukan metode.

Misalnya:

Pengguna.temukan({})
 .Kemudian((data) => {
menghibur.log (data);
 })
 .menangkap((berbuat salah) => {
// tangani kesalahan
 });

Blok kode di atas akan mengembalikan semua dokumen di Pengguna koleksi.

Anda juga dapat menemukan semua dokumen yang cocok dengan kueri tertentu dengan meneruskan kueri ke metode find.

Misalnya:

// temukan semua dokumen yang usianya minimal 18 tahun
Pengguna.temukan({ usia: { $gte: 18 } })
 .Kemudian((data) =>menghibur.log (data))
 .menangkap((kesalahan) =>menghibur.log (kesalahan));

Blok kode di atas akan mengembalikan semua dokumen dengan nilai usia lebih dari 18 tahun Pengguna koleksi.

Atau, Anda dapat membaca catatan tunggal menggunakan findById metode dan meneruskan ID dokumen sebagai argumen atau menggunakan findOne metode dan melewati filter sebagai argumen.

Misalnya:

//findById
User.findById (id, (kesalahan, hasil) => {
jika (hasil) menghibur.log (hasil);
jika (kesalahan) menghibur.error (kesalahan)
 });
//findOne
Pengguna.findOne({ surel: "[email protected]" }).Kemudian((pengguna) => {
jika (!pengguna) {
// tangani kesalahan
 }
//kirim tanggapan
 });

Dalam blok kode di atas, file findById metode mengembalikan dokumen dengan ID yang cocok. Itu findOne metode mengembalikan dokumen pertama yang memiliki email [email protected].

Memperbarui Dokumen

Anda dapat memperbarui dokumen di MongoDB dengan Mongoose menggunakan findByIdAndUpdate metode. Metode ini mengambil ID dan objek dengan detail yang diperbarui.

Misalnya:

User.findByIdAndUpdate (id, req.body, (err, doc) => {
jika (dok) {
//Kirim tanggapan
 }
jika (salah) {
// tangani kesalahan
 }
});

Blok kode di atas memperbarui dokumen yang memiliki ID yang cocok dengan ID yang diberikan dengan objek pembaruan yang disediakan (req.body).

Menghapus Dokumen

Anda dapat menghapus dokumen di MongoDB dengan Mongoose menggunakan findByIdAndDelete metode. Metode ini menggunakan ID sebagai argumen dan menghapus dokumen dengan ID yang sesuai.

Misalnya:

User.findByIdAndDelete (id, (kesalahan, hasil) => {
jika (hasil) {
//Menangani hasil
 }
jika (kesalahan) {
//Menangani kesalahan
 }
});

Blok kode di atas menghapus dokumen dengan ID yang diberikan dari database MongoDB Anda.

Menggunakan Mongoose di Aplikasi Ekspres Anda

Artikel ini memberikan ikhtisar tentang bagaimana Anda dapat menggunakan Mongoose di aplikasi ekspres Anda. Meliputi bagaimana Anda dapat membuat koneksi ke MongoDB, menyusun dan memvalidasi data yang disimpan ke database MongoDB Anda, dan melakukan operasi CRUD sederhana.

Dengan menggunakan Mongoose di aplikasi Express Anda, Anda dapat menyederhanakan dan merampingkan interaksi antara aplikasi Anda dan database MongoDB.