MongoDB untuk Pemula: Database NoSQL

# Jalankan MongoDB dengan Docker
docker run -d \
  --name mongodb \
  -p 27017:27017 \
  -e MONGO_INITDB_ROOT_USERNAME=admin \
  -e MONGO_INITDB_ROOT_PASSWORD=password123 \
  -v mongodb_data:/data/db \
  mongo:7

# Verifikasi container berjalan
docker ps | grep mongodb

# Masuk ke MongoDB shell
docker exec -it mongodb mongosh -u admin -p password123

# Ubuntu / Debian
wget -qO- https://www.mongodb.org/static/pgp/server-7.0.asc | \
  sudo tee /etc/apt/trusted.gpg.d/server-7.0.asc
echo "deb [ arch=amd64,arm64 ] https://repo.mongodb.org/apt/ubuntu \
  jammy/mongodb-org/7.0 multiverse" | \
  sudo tee /etc/apt/sources.list.d/mongodb-org-7.0.list
sudo apt update && sudo apt install -y mongodb-org

# macOS dengan Homebrew
brew tap mongodb/brew
brew install mongodb-community@7.0

# Jalankan service
sudo systemctl start mongod    # Linux
brew services start mongodb-community@7.0  # macOS

# Masuk ke MongoDB shell
mongosh

# Atau koneksi ke Atlas
mongosh "mongodb+srv://cluster0.xxxxx.mongodb.net/" --username myUser

# Di dalam shell, cek status
db.runCommand({ ping: 1 })
// Output: { ok: 1 }

# Lihat semua database
show dbs

# Buat / pilih database
use belajar_mongo

# Lihat collection di database saat ini
show collections

{
  _id: ObjectId("64a7b2c3d4e5f6a7b8c9d0e1"),  // Auto-generated, unik
  nama: "Budi Santoso",
  email: "budi@example.com",
  umur: 25,
  aktif: true,
  alamat: {
    jalan: "Jl. Sudirman No. 123",
    kota: "Jakarta",
    kode_pos: "12190"
  },
  hobi: ["coding", "membaca", "gaming"],
  pendidikan: [
    { institusi: "Universitas Indonesia", tahun: 2022 },
    { institusi: "SMA Negeri 1", tahun: 2018 }
  ],
  created_at: ISODate("2026-06-25T10:30:00Z")
}

// Insert satu document
db.users.insertOne({
  nama: "Budi Santoso",
  email: "budi@example.com",
  umur: 25,
  kota: "Jakarta",
  created_at: new Date()
})

// Insert banyak document sekaligus
db.users.insertMany([
  {
    nama: "Ani Wijaya",
    email: "ani@example.com",
    umur: 30,
    kota: "Bandung",
    created_at: new Date()
  },
  {
    nama: "Citra Dewi",
    email: "citra@example.com",
    umur: 22,
    kota: "Surabaya",
    created_at: new Date()
  },
  {
    nama: "Dedi Kurniawan",
    email: "dedi@example.com",
    umur: 28,
    kota: "Jakarta",
    created_at: new Date()
  }
])

// Output:
// {
//   acknowledged: true,
//   insertedIds: {
//     '0': ObjectId("..."),
//     '1': ObjectId("..."),
//     '2': ObjectId("...")
//   }
// }

// Ambil semua document dalam collection
db.users.find()

// Ambil dengan format yang rapi (pretty print)
db.users.find().pretty()

// Cari berdasarkan field tertentu
db.users.find({ kota: "Jakarta" })

// Cari satu document saja
db.users.findOne({ email: "budi@example.com" })

// Cari berdasarkan ID
db.users.findOne({
  _id: ObjectId("64a7b2c3d4e5f6a7b8c9d0e1")
})

// Hitung jumlah document
db.users.countDocuments({ kota: "Jakarta" })
// Output: 2

// Cek apakah document ada
db.users.findOne({ email: "tidakada@example.com" })
// Output: null

// Update satu document — $set mengubah field tertentu
db.users.updateOne(
  { email: "budi@example.com" },   // filter
  { $set: { umur: 26, kota: "Bandung" } }  // perubahan
)

// Update — $inc menambah nilai numerik
db.users.updateOne(
  { nama: "Budi Santoso" },
  { $inc: { umur: 1 } }  // umur += 1
)

// Update — $push menambah elemen ke array
db.users.updateOne(
  { nama: "Budi Santoso" },
  { $push: { hobi: "berenang" } }
)

// Update — $addToSet menambah tanpa duplikasi
db.users.updateOne(
  { nama: "Budi Santoso" },
  { $addToSet: { hobi: "coding" } }  // Tidak ditambah karena sudah ada
)

// Update banyak document sekaligus
db.users.updateMany(
  { kota: "Jakarta" },              // filter
  { $set: { status: "aktif" } }     // perubahan
)

// Replace seluruh document (kecuali _id)
db.users.replaceOne(
  { email: "budi@example.com" },
  {
    nama: "Budi Santoso",
    email: "budi@example.com",
    umur: 27,
    kota: "Yogyakarta",
    updated_at: new Date()
  }
)

// Hapus satu document
db.users.deleteOne({ email: "dedi@example.com" })

// Hapus banyak document sesuai filter
db.users.deleteMany({ kota: "Jakarta" })

// Hapus SEMUA document dalam collection
db.users.deleteMany({})

// Hapus collection seluruhnya
db.users.drop()

// Hapus database (pilih dulu, lalu drop)
use temp_database
db.dropDatabase()

// $eq (equal) — sama dengan
db.users.find({ kota: { $eq: "Jakarta" } })
// Sama dengan: db.users.find({ kota: "Jakarta" })

// $ne (not equal) — tidak sama dengan
db.users.find({ kota: { $ne: "Jakarta" } })

// $gt (greater than) — lebih besar dari
db.users.find({ umur: { $gt: 25 } })

// $gte (greater than or equal) — lebih besar atau sama dengan
db.users.find({ umur: { $gte: 25 } })

// $lt (less than) — kurang dari
db.users.find({ umur: { $lt: 30 } })

// $lte (less than or equal) — kurang atau sama dengan
db.users.find({ umur: { $lte: 25 } })

// $in — nilai ada dalam array
db.users.find({ kota: { $in: ["Jakarta", "Bandung", "Surabaya"] } })

// $nin (not in) — nilai tidak ada dalam array
db.users.find({ kota: { $nin: ["Jakarta", "Bandung"] } })

// $and — kedua kondisi harus terpenuhi
db.users.find({
  $and: [
    { umur: { $gte: 20 } },
    { kota: "Jakarta" }
  ]
})

// $or — salah satu kondisi terpenuhi
db.users.find({
  $or: [
    { umur: { $lt: 23 } },
    { kota: "Bandung" }
  ]
})

// $not — negasi kondisi
db.users.find({
  umur: { $not: { $gte: 30 } }
})

// $nor — tidak ada kondisi yang terpenuhi
db.users.find({
  $nor: [
    { kota: "Jakarta" },
    { umur: { $gt: 35 } }
  ]
})

// Kombinasi kompleks
db.users.find({
  $and: [
    { umur: { $gte: 20, $lte: 30 } },
    {
      $or: [
        { kota: "Jakarta" },
        { kota: "Bandung" }
      ]
    }
  ]
})

// Projection — pilih field yang ingin ditampilkan
db.users.find(
  {},
  { nama: 1, email: 1, _id: 0 }   // 1 = tampilkan, 0 = sembunyikan
)

// Sort — urutkan hasil
db.users.find().sort({ umur: 1 })    // Ascending (A→Z, 0→9)
db.users.find().sort({ umur: -1 })   // Descending (Z→A, 9→0)

// Skip & Limit — pagination
db.users.find()
  .sort({ nama: 1 })
  .skip(0)       // Lewati 0 dokumen (halaman 1)
  .limit(10)     // Ambil 10 dokumen

// Halaman ke-3 (10 per halaman)
db.users.find()
  .sort({ nama: 1 })
  .skip(20)      // Lewati 20 dokumen
  .limit(10)

// Element operators
db.users.find({ hobi: { $exists: true } })     // Field ada
db.users.find({ hobi: { $exists: false } })    // Field tidak ada
db.users.find({ umur: { $type: "int" } })      // Tipe data tertentu

// Regex — pencarian teks
db.users.find({ nama: { $regex: /Budi/i } })   // Case-insensitive
db.users.find({ email: { $regex: /@gmail/ } })

// Single Field Index — index pada satu field
db.users.createIndex({ email: 1 })         // Ascending
db.users.createIndex({ created_at: -1 })   // Descending

// Unique Index — memastikan nilai unik
db.users.createIndex({ email: 1 }, { unique: true })

// Compound Index — index pada beberapa field
db.users.createIndex({ kota: 1, umur: -1 })

// Text Index — untuk full-text search
db.posts.createIndex({ title: "text", content: "text" })

// Cari dengan text search
db.posts.find({ $text: { $search: "tutorial mongodb" } })

// Partial Index — index hanya untuk dokumen tertentu
db.users.createIndex(
  { email: 1 },
  { partialFilterExpression: { aktif: true } }
)

// TTL Index — auto-delete setelah waktu tertentu
db.sessions.createIndex(
  { created_at: 1 },
  { expireAfterSeconds: 3600 }  // Hapus setelah 1 jam
)

// Lihat semua index pada collection
db.users.getIndexes()

// Hapus index
db.users.dropIndex({ email: 1 })
db.users.dropIndex("email_1")    // Berdasarkan nama

// Hapus semua index kecuali _id
db.users.dropIndexes()

// Explain — analisis performa query
db.users.find({ email: "budi@example.com" }).explain("executionStats")
// Perhatikan: totalDocsExamined — semakin kecil semakin baik

// Contoh collection "orders":
// { _id, user: "Budi", produk: "Laptop", harga: 12000000, jumlah: 1, status: "selesai" }
// { _id, user: "Ani",  produk: "Mouse",  harga: 150000,   jumlah: 2, status: "selesai" }
// { _id, user: "Budi", produk: "Keyboard",harga: 500000,  jumlah: 1, status: "pending" }

// 1. Hitung total pendapatan per user (hanya yang selesai)
db.orders.aggregate([
  // Stage 1: Filter hanya order yang selesai
  { $match: { status: "selesai" } },

  // Stage 2: Group per user, hitung total
  { $group: {
      _id: "$user",
      totalPendapatan: { $sum: { $multiply: ["$harga", "$jumlah"] } },
      jumlahOrder: { $sum: 1 },
      rataRataHarga: { $avg: "$harga" }
    }
  },

  // Stage 3: Urutkan dari pendapatan terbesar
  { $sort: { totalPendapatan: -1 } }
])

// 2. Lookup (JOIN) — gabungkan data dari collection lain
db.orders.aggregate([
  { $lookup: {
      from: "users",              // Collection yang digabung
      localField: "user",         // Field di collection ini
      foreignField: "nama",       // Field di collection lain
      as: "userData"              // Nama field hasil
    }
  },
  { $unwind: "$userData" }        // "Buka" array menjadi object
])

// 3. Analisis per kota — siapa yang paling banyak belanja?
db.orders.aggregate([
  { $lookup: {
      from: "users",
      localField: "user",
      foreignField: "nama",
      as: "userData"
    }
  },
  { $unwind: "$userData" },
  { $group: {
      _id: "$userData.kota",
      totalBelanja: { $sum: { $multiply: ["$harga", "$jumlah"] } },
      jumlahPembeli: { $addToSet: "$user" }
    }
  },
  { $project: {
      kota: "$_id",
      totalBelanja: 1,
      jumlahPembeli: { $size: "$jumlahPembeli" }
    }
  },
  { $sort: { totalBelanja: -1 } }
])

# Inisialisasi proyek Node.js
mkdir mongo-app && cd mongo-app
npm init -y

# Instal mongoose
npm install mongoose

# (Opsional) Untuk environment variables
npm install dotenv

const mongoose = require('mongoose');

// Definisikan Schema — "blueprint" untuk data
const userSchema = new mongoose.Schema({
  nama: {
    type: String,
    required: [true, 'Nama wajib diisi'],
    trim: true,
    minlength: [3, 'Nama minimal 3 karakter'],
    maxlength: [100, 'Nama maksimal 100 karakter']
  },
  email: {
    type: String,
    required: [true, 'Email wajib diisi'],
    unique: true,
    lowercase: true,
    match: [/^\S+@\S+\.\S+$/, 'Format email tidak valid']
  },
  umur: {
    type: Number,
    min: [0, 'Umur tidak boleh negatif'],
    max: [150, 'Umur tidak valid']
  },
  role: {
    type: String,
    enum: ['user', 'admin', 'moderator'],
    default: 'user'
  },
  hobi: {
    type: [String],
    default: []
  },
  alamat: {
    jalan: String,
    kota: String,
    kode_pos: String
  },
  aktif: {
    type: Boolean,
    default: true
  }
}, {
  timestamps: true   // Auto tambah createdAt & updatedAt
});

// Virtual field — tidak disimpan di database
userSchema.virtual('infoLengkap').get(function() {
  return `${this.nama} (${this.email}) - ${this.umur} tahun`;
});

// Middleware (hook) sebelum save
userSchema.pre('save', function(next) {
  console.log(`Menyimpan user: ${this.nama}`);
  next();
});

// Static method
userSchema.statics.findByKota = function(kota) {
  return this.find({ 'alamat.kota': kota });
};

// Instance method
userSchema.methods.isActive = function() {
  return this.aktif === true;
};

// Buat Model dari Schema
const User = mongoose.model('User', userSchema);
module.exports = User;

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

// Koneksi ke MongoDB
mongoose.connect('mongodb://localhost:27017/belajar_mongo')
  .then(() => console.log('✅ Terhubung ke MongoDB'))
  .catch(err => console.error('❌ Error:', err));

async function main() {
  // CREATE — buat user baru
  const user = new User({
    nama: 'Budi Santoso',
    email: 'budi@example.com',
    umur: 25,
    alamat: { jalan: 'Jl. Sudirman 123', kota: 'Jakarta' }
  });
  await user.save();
  console.log('User tersimpan:', user.infoLengkap);

  // CREATE — alternatif dengan create()
  const users = await User.create([
    { nama: 'Ani', email: 'ani@example.com', umur: 30 },
    { nama: 'Citra', email: 'citra@example.com', umur: 22 }
  ]);

  // READ — cari dengan filter
  const jakartaUsers = await User.find({ 'alamat.kota': 'Jakarta' });
  const satuUser = await User.findOne({ email: 'budi@example.com' });

  // READ — dengan chaining
  const hasil = await User
    .find({ umur: { $gte: 20 } })
    .select('nama email umur')
    .sort({ nama: 1 })
    .limit(10)
    .skip(0);

  // UPDATE
  await User.updateOne(
    { email: 'budi@example.com' },
    { $set: { umur: 26 } }
  );

  // Atau gunakan findByIdAndUpdate untuk return document baru
  const updated = await User.findByIdAndUpdate(
    user._id,
    { $set: { umur: 27 } },
    { new: true }  // Return document setelah update
  );

  // DELETE
  await User.deleteOne({ email: 'citra@example.com' });

  // Validasi error handling
  try {
    const invalid = new User({ nama: '', email: 'bad' });
    await invalid.save();
  } catch (err) {
    console.log('Validasi error:', err.errors.nama.message);
    // Output: "Nama wajib diisi"
  }
}

main();