mongosh                              # connect to localhost
mongosh "mongodb://localhost:27017"  # explicit
mongosh "mongodb+srv://user:pass@cluster.mongodb.net/db"

show dbs                  # list databases
use bitwithbite           # switch to database
show collections          # list collections
db                        # show current database

// INSERT
db.users.insertOne({ name: 'Ali', age: 22, role: 'student' })
db.users.insertMany([
  { name: 'Sara', age: 25 },
  { name: 'John', age: 30 }
])

// READ
db.users.find()                        // all documents
db.users.find({ age: 22 })             // where age = 22
db.users.findOne({ name: 'Ali' })      // first match
db.users.find({}, { name: 1, _id: 0 }) // projection: name only
db.users.find().sort({ age: -1 })      // sort descending
db.users.find().limit(10).skip(20)     // pagination
db.users.countDocuments({ role: 'student' })

// UPDATE
db.users.updateOne(
  { name: 'Ali' },
  { $set: { age: 23 } }              // $set operator
)
db.users.updateMany(
  { role: 'student' },
  { $inc: { points: 10 } }           // increment
)
db.users.findOneAndUpdate(
  { name: 'Ali' },
  { $set: { age: 23 } },
  { returnDocument: 'after' }        // return updated doc
)

// DELETE
db.users.deleteOne({ name: 'Ali' })
db.users.deleteMany({ age: { $lt: 18 } })
db.users.drop()                       // delete entire collection

// Comparison
db.users.find({ age: { $gt: 18, $lt: 65 } })  // > 18 AND < 65
db.users.find({ age: { $gte: 18 } })
db.users.find({ role: { $in: ['admin', 'mod'] } })
db.users.find({ role: { $nin: ['banned'] } })
db.users.find({ age: { $ne: 18 } })

// Logical
db.users.find({ $and: [{ age: { $gt: 18 } }, { active: true }] })
db.users.find({ $or: [{ role: 'admin' }, { age: { $gt: 60 } }] })
db.users.find({ age: { $not: { $gt: 65 } } })

// Element
db.users.find({ email: { $exists: true } })    // has email field
db.users.find({ score: { $type: 'number' } })

// Array
db.users.find({ tags: 'javascript' })           // array contains value
db.users.find({ tags: { $all: ['js', 'py'] } }) // contains all
db.users.find({ tags: { $size: 3 } })           // array has 3 elements
db.users.find({ 'address.city': 'Lahore' })     // nested field dot notation

// Regex
db.users.find({ name: { $regex: /^Ali/i } })
db.users.find({ name: { $regex: 'ali', $options: 'i' } })

// $set / $unset
db.users.updateOne({ _id: id }, {
  $set:   { name: 'New Name', age: 25 },
  $unset: { oldField: '' }           // remove field
})

// $inc / $mul
db.products.updateOne({ _id: id }, {
  $inc: { stock: -1, sold: 1 },      // increment/decrement
  $mul: { price: 1.1 }               // multiply price by 1.1
})

// $push / $pull (arrays)
db.users.updateOne({ _id: id }, {
  $push: { tags: 'javascript' },     // add to array
  $addToSet: { tags: 'python' },     // add only if not exists
  $pull: { tags: 'php' },            // remove from array
  $pop: { log: 1 }                   // remove last (1) or first (-1)
})

// $push with $each and $slice
db.users.updateOne({ _id: id }, {
  $push: { scores: {
    $each: [85, 92, 78],
    $sort: -1,                       // sort descending
    $slice: 5                        // keep only top 5
  }}
})

// Upsert — update or insert
db.users.updateOne(
  { email: 'ali@test.com' },
  { $set: { name: 'Ali' } },
  { upsert: true }                   // creates if not exists
)

db.orders.aggregate([
  // Stage 1: Filter
  { $match: { status: 'completed', amount: { $gt: 100 } } },

  // Stage 2: Group
  { $group: {
    _id: '$customerId',
    totalSpent: { $sum: '$amount' },
    orderCount: { $count: {} },
    avgOrder:   { $avg: '$amount' },
    lastOrder:  { $max: '$date' }
  }},

  // Stage 3: Sort
  { $sort: { totalSpent: -1 } },

  // Stage 4: Limit
  { $limit: 10 },

  // Stage 5: Lookup (LEFT JOIN)
  { $lookup: {
    from: 'customers',           // collection to join
    localField: '_id',           // field from orders
    foreignField: '_id',         // field from customers
    as: 'customerInfo'           // output array field
  }},

  // Stage 6: Unwind (array to documents)
  { $unwind: '$customerInfo' },

  // Stage 7: Project (select fields)
  { $project: {
    totalSpent: 1,
    name: '$customerInfo.name',
    email: '$customerInfo.email'
  }}
])

// Create indexes
db.users.createIndex({ email: 1 })                   // ascending
db.users.createIndex({ email: 1 }, { unique: true })
db.users.createIndex({ name: 1, age: -1 })            // compound
db.users.createIndex({ name: 'text', bio: 'text' })   // text search
db.locations.createIndex({ coordinates: '2dsphere' }) // geospatial
db.sessions.createIndex({ createdAt: 1 }, { expireAfterSeconds: 3600 }) // TTL

// View indexes
db.users.getIndexes()

// Drop index
db.users.dropIndex({ email: 1 })

// Explain — analyze query performance
db.users.find({ email: 'ali@test.com' }).explain('executionStats')
// Look for 'IXSCAN' (good) vs 'COLLSCAN' (bad)

// Index usage hints
db.users.find({ email: 'ali@test.com' }).hint({ email: 1 })

// EMBEDDING (denormalized) — when data accessed together
{
  _id: ObjectId(),
  name: 'Ali',
  address: {              // embedded document
    street: '123 Main',
    city: 'Lahore',
    country: 'Pakistan'
  },
  orders: [               // embedded array (limit: ~16MB per doc)
    { id: 1, amount: 500, date: ISODate() },
    { id: 2, amount: 300, date: ISODate() }
  ]
}

// REFERENCING (normalized) — when data reused or grows large
// users collection
{ _id: ObjectId('user123'), name: 'Ali' }

// orders collection
{ _id: ObjectId(), userId: ObjectId('user123'), amount: 500 }

// Hybrid: summary in parent, details in child
{ _id: 'user123', name: 'Ali',
  orderCount: 15, totalSpent: 12000,      // summary (denormalized)
  recentOrders: [                          // only last 5 embedded
    { id: 'ord5', amount: 300 }
  ]
}

const mongoose = require('mongoose');

// Connect
await mongoose.connect('mongodb://localhost:27017/mydb');

// Schema
const userSchema = new mongoose.Schema({
  name:     { type: String, required: true, trim: true },
  email:    { type: String, required: true, unique: true, lowercase: true },
  password: { type: String, required: true, select: false },
  role:     { type: String, enum: ['user','admin'], default: 'user' },
  age:      { type: Number, min: 0, max: 120 },
  tags:     [String],
  address:  { city: String, country: String },
  createdAt: { type: Date, default: Date.now }
}, { timestamps: true });

// Middleware (hooks)
userSchema.pre('save', async function(next) {
  if (this.isModified('password')) {
    this.password = await bcrypt.hash(this.password, 12);
  }
  next();
});

const User = mongoose.model('User', userSchema);

// Queries
const users = await User.find({ role: 'admin' }).select('name email').limit(10);
const user = await User.findById(id);
const updated = await User.findByIdAndUpdate(id, { age: 23 }, { new: true });
await User.deleteOne({ _id: id });

// Populate (reference join)
await Order.find().populate('userId', 'name email');

# MongoDB Atlas CLI connect
mongosh "mongodb+srv://user:pass@cluster.mongodb.net/dbname"

# Atlas setup checklist:
# 1. Create cluster (free M0 available)
# 2. Database Access: create user with readWrite role
# 3. Network Access: add IP or 0.0.0.0/0 for all
# 4. Get connection string from 'Connect' button

# Environment variable (NEVER hardcode!)
MONGODB_URI=mongodb+srv://user:pass@cluster/db

# Connection with options (Node.js)
await mongoose.connect(process.env.MONGODB_URI, {
  maxPoolSize: 10,          // connection pool
  serverSelectionTimeoutMS: 5000,
  socketTimeoutMS: 45000,
});

# Backup
mongodump --uri="mongodb+srv://..." --out=./backup
mongorestore --uri="mongodb+srv://..." ./backup

# Performance checklist:
# Always index query fields
# Use projection to return only needed fields
# Use aggregation instead of fetching + processing in app
# Enable slow query logging in Atlas > Performance Advisor