MongoDB & NoSQL: Kapan dan Bagaimana Memakainya

# macOS
brew tap mongodb/brew
brew install mongodb-community
 
# Jalankan sebagai service
brew services start mongodb-community
 
# Atau pakai MongoDB Atlas (cloud, free tier) — tidak perlu install apapun

npm install mongoose

// src/db/mongo.js
import mongoose from 'mongoose';
 
export async function connectMongo() {
  await mongoose.connect(process.env.MONGODB_URI);
  console.log('MongoDB connected');
}
 
mongoose.connection.on('error', (err) => {
  console.error('MongoDB connection error:', err);
});

// Satu dokumen di collection "products"
{
  _id: ObjectId("65f1a2b3c4d5e6f7a8b9c0d1"),
  name: "Laptop Gaming X1",
  price: 15000000,
  category: "electronics",
  specs: {
    ram: "16GB",
    cpu: "Intel i7",
    storage: "512GB SSD",
  },
  tags: ["gaming", "laptop", "intel"],
  createdAt: ISODate("2024-01-15T10:00:00Z"),
}

// Order dengan item embedded
{
  _id: ObjectId("..."),
  customerName: "Budi Santoso",
  items: [
    { productName: "Kopi Arabika", quantity: 2, unitPrice: 85000 },
    { productName: "Teh Hijau", quantity: 1, unitPrice: 35000 },
  ],
  total: 205000,
  createdAt: ISODate("2024-01-15"),
}

// Product sebagai collection terpisah, order hanya simpan reference
// orders collection
{
  _id: ObjectId("..."),
  customerId: ObjectId("65f1..."),   // reference ke customers
  items: [
    { productId: ObjectId("65f2..."), quantity: 2 },
  ],
}

{
  items: [
    {
      productId: ObjectId("..."),  // reference untuk lacak balik ke produk asli
      productName: "Kopi Arabika", // snapshot — nama saat transaksi
      unitPrice: 85000,            // snapshot — harga saat transaksi
      quantity: 2,
    },
  ],
}

// src/models/product.model.js
import mongoose from 'mongoose';
 
const productSchema = new mongoose.Schema(
  {
    name: {
      type: String,
      required: [true, 'Nama produk wajib diisi'],
      trim: true,
      minlength: 3,
    },
    price: {
      type: Number,
      required: true,
      min: [0, 'Harga tidak boleh negatif'],
    },
    category: {
      type: String,
      required: true,
      enum: ['electronics', 'fashion', 'food', 'books'],  // sama seperti ENUM di SQL
    },
    specs: {
      type: mongoose.Schema.Types.Mixed,  // fleksibel — beda field per kategori
      default: {},
    },
    tags: [String],
    isActive: {
      type: Boolean,
      default: true,
    },
  },
  {
    timestamps: true,  // otomatis tambahkan createdAt & updatedAt
  }
);
 
export const Product = mongoose.model('Product', productSchema);

const product = await Product.create({
  name: 'Laptop Gaming X1',
  price: 15000000,
  category: 'electronics',
  specs: { ram: '16GB', cpu: 'Intel i7', storage: '512GB SSD' },
  tags: ['gaming', 'laptop'],
});

// Cari satu
const product = await Product.findById('65f1a2b3c4d5e6f7a8b9c0d1');
const product2 = await Product.findOne({ name: 'Laptop Gaming X1' });
 
// Cari banyak dengan filter, mirip WHERE
const laptops = await Product.find({
  category: 'electronics',
  price: { $gte: 5000000, $lte: 20000000 },  // setara WHERE price BETWEEN
  isActive: true,
});
 
// Pagination
const page = 2, limit = 10;
const products = await Product.find({ isActive: true })
  .sort({ createdAt: -1 })
  .skip((page - 1) * limit)
  .limit(limit);

// Update satu field
await Product.findByIdAndUpdate(id, { price: 14500000 });
 
// Update dengan operator — increment stok tanpa race condition
await Product.findByIdAndUpdate(id, { $inc: { stock: -1 } });
 
// Update banyak dokumen sekaligus
await Product.updateMany(
  { category: 'electronics' },
  { $set: { taxRate: 0.11 } }
);

// Hard delete
await Product.findByIdAndDelete(id);
 
// Soft delete — pola yang sama seperti di artikel #03
await Product.findByIdAndUpdate(id, { isActive: false });

try {
  await Product.create({ name: 'AB', price: -100, category: 'invalid' });
} catch (err) {
  // err.errors berisi detail per-field, mirip result.error dari Zod safeParse
  console.log(err.errors.name.message);      // "Nama produk wajib diisi" (kurang dari minlength)
  console.log(err.errors.price.message);     // "Harga tidak boleh negatif"
  console.log(err.errors.category.message);  // bukan salah satu ENUM
}

// Setara: SELECT category, COUNT(*), SUM(price) FROM products
//         WHERE isActive = true GROUP BY category
const summary = await Product.aggregate([
  { $match: { isActive: true } },
  {
    $group: {
      _id: '$category',
      totalProducts: { $sum: 1 },
      totalValue: { $sum: '$price' },
      avgPrice: { $avg: '$price' },
    },
  },
  { $sort: { totalValue: -1 } },
]);
 
// Hasil:
// [
//   { _id: 'electronics', totalProducts: 45, totalValue: 675000000, avgPrice: 15000000 },
//   { _id: 'fashion', totalProducts: 120, totalValue: 36000000, avgPrice: 300000 },
// ]

// orders collection punya customerId (reference) — "join" ke customers
const ordersWithCustomer = await Order.aggregate([
  {
    $lookup: {
      from: 'customers',       // collection yang di-join
      localField: 'customerId',
      foreignField: '_id',
      as: 'customer',          // hasil disimpan sebagai array di field ini
    },
  },
  { $unwind: '$customer' },    // ubah array 1-elemen jadi object langsung
  {
    $project: {                // pilih field yang ditampilkan, setara SELECT kolom tertentu
      total: 1,
      createdAt: 1,
      'customer.name': 1,
      'customer.email': 1,
    },
  },
]);

const monthlySales = await Order.aggregate([
  { $match: { status: 'completed' } },
  {
    $group: {
      _id: {
        year: { $year: '$createdAt' },
        month: { $month: '$createdAt' },
      },
      totalRevenue: { $sum: '$total' },
      orderCount: { $sum: 1 },
    },
  },
  { $sort: { '_id.year': -1, '_id.month': -1 } },
  { $limit: 12 },
]);

// Index sederhana — setara CREATE INDEX di SQL
await Product.collection.createIndex({ category: 1 });   // 1 = ascending
await Product.collection.createIndex({ createdAt: -1 }); // -1 = descending
 
// Compound index — urutan field penting, sama seperti composite index SQL
await Product.collection.createIndex({ category: 1, price: -1 });
 
// Unique index — setara UNIQUE constraint
await Product.collection.createIndex({ sku: 1 }, { unique: true });
 
// Text index — untuk full-text search sederhana
await Product.collection.createIndex({ name: 'text', description: 'text' });

// Definisikan langsung di schema — lebih idiomatik
const productSchema = new mongoose.Schema({
  sku: { type: String, unique: true, index: true },
  category: { type: String, index: true },
});
 
productSchema.index({ category: 1, price: -1 });  // compound index

const result = await Product.find({ category: 'electronics' }).explain('executionStats');
 
console.log(result.executionStats.executionStages.stage);
// "COLLSCAN" = collection scan (tanpa index, seperti Seq Scan di PostgreSQL)
// "IXSCAN"   = index scan (pakai index, bagus)

// src/models/product.model.js
const productSchema = new mongoose.Schema(
  {
    name: { type: String, required: true },
    category: {
      type: String,
      required: true,
      enum: ['laptop', 'fashion', 'book'],
    },
    price: { type: Number, required: true, min: 0 },
    stock: { type: Number, required: true, default: 0, min: 0 },
 
    // Bentuk field ini berbeda total tergantung category —
    // ini justru kasus yang paling natural untuk MongoDB
    attributes: {
      type: mongoose.Schema.Types.Mixed,
      default: {},
    },
  },
  { timestamps: true }
);
 
productSchema.index({ category: 1, price: 1 });
productSchema.index({ name: 'text' });
 
export const Product = mongoose.model('Product', productSchema);

// Insert laptop
await Product.create({
  name: 'Laptop Gaming X1',
  category: 'laptop',
  price: 15000000,
  stock: 10,
  attributes: { ram: '16GB', cpu: 'Intel i7', storage: '512GB SSD' },
});
 
// Insert baju — struktur attributes TOTAL berbeda, tidak perlu migration
await Product.create({
  name: 'Kemeja Flanel',
  category: 'fashion',
  price: 250000,
  stock: 50,
  attributes: { size: 'L', material: 'Cotton', warna: 'Navy' },
});

// Cari laptop dengan RAM tertentu
const laptops = await Product.find({
  category: 'laptop',
  'attributes.ram': '16GB',
});
 
// Range harga + kategori — kombinasi filter tetap mudah
const results = await Product.find({
  category: 'fashion',
  price: { $gte: 100000, $lte: 500000 },
  'attributes.size': { $in: ['M', 'L'] },
});