db.products.insertOne({
  name: 'Laptop Pro',
  price: 1299,
  stock: 45
})

db.products.insertMany([
  { name: 'Mouse',  price: 29 },
  { name: 'Keyboard', price: 149 }
], { ordered: false })

db.products.find()
db.products.findOne(
  { name: 'Laptop Pro' }
)
// Projection: name & price only
db.products.find(
  { category: 'Electronics' },
  { name: 1, price: 1, _id: 0 }
)

db.products.updateOne(
  { name: 'Mouse' },
  { $set: { price: 34.99 },
    $inc: { stock: 50 } }
)
// 10% price increase for all Furniture
db.products.updateMany(
  { category: 'Furniture' },
  { $mul: { price: 1.10 } }
)

db.products.deleteOne(
  { name: 'Notebook A5' }
)
db.products.deleteMany(
  { stock: 0 }
)
// Always test filter with find() first!

// Greater than / less than
db.products.find({
  price: { $gt: 100, $lte: 500 }
})

// In a set of values
db.products.find({
  category: { $in: ['Electronics',
                       'Furniture'] }
})

// Not equal
db.products.find({
  status: { $ne: 'discontinued' }
})

// $and — all conditions match
db.products.find({ $and: [
  { category: 'Electronics' },
  { price: { $lt: 200 } },
  { rating: { $gte: 4.5 } }
]})

// $or — any condition matches
db.products.find({ $or: [
  { price: { $lt: 30 } },
  { stock: { $gt: 100 } }
]})

{
  _id: ObjectId("..."),
  orderNumber: "ORD-001",
  customer: {          // embedded
    name: "Bob Smith",
    email: "bob@..."
  },
  items: [             // embedded array
    { product: "Laptop", qty: 1, price: 1200 }
  ]
}

// Products collection
{ _id: ObjectId("prod001"),
  name: "Laptop", stock: 50 }

// Orders — reference by ID
{ _id: ObjectId("ord001"),
  items: [{
    productId: ObjectId("prod001"),
    qty: 1
  }]
}

const session = db.getMongo()
  .startSession()
session.startTransaction()
try {
  accounts.updateOne(
    { _id: 'acc001' },
    { $inc: { balance: -500 } },
    { session }
  )
  accounts.updateOne(
    { _id: 'acc002' },
    { $inc: { balance: 500 } },
    { session }
  )
  session.commitTransaction()
} catch (e) {
  session.abortTransaction()
}

// Watch with filter
const pipeline = [{
  $match: {
    operationType: 'update',
    'updateDescription'
    '.updatedFields.status': 'completed'
  }
}]

db.orders
  .watch(pipeline)
  .forEach(change => {
    printjson(change)
  })

const userSchema = new mongoose.Schema({
  name:  { type: String, required: true, trim: true },
  email: { type: String, unique: true, lowercase: true },
  role:  { type: String,
    enum: ['admin', 'customer'],
    default: 'customer' }
}, { timestamps: true })

// Pre-save hook — hash password
userSchema.pre('save', async function(next) {
  if (!this.isModified('password')) return next()
  this.password = await bcrypt.hash(this.password, 12)
  next()
})

module.exports = mongoose.model('User', userSchema)

// CREATE
await User.create({ name: 'Alice', ... })

// READ with filtering & projection
await User.find({ role: 'customer' })
  .select('name email')
  .sort({ createdAt: -1 })
  .limit(20)

// UPDATE — return updated doc
await User.findByIdAndUpdate(
  userId,
  { $set: { bio: 'Developer' } },
  { new: true, runValidators: true }
)

// DELETE
await User.findByIdAndDelete(userId)

// Attacker sends: { $gt: '' }
db.users.findOne({
  email: req.body.email,
  password: req.body.password
})

// Find by email, verify via bcrypt
const user = await User
  .findOne({ email: req.body.email })
  .select('+password')
if (!user || !await user
  .comparePassword(req.body.password)) {
  return res.status(401).json({ error: 'Unauthorized' })
}

# Full backup with compression
mongodump \
  --uri='mongodb://localhost/myapp' \
  --gzip \
  --archive=/backups/myapp_$(date +%Y%m%d).gz

# Restore from archive
mongorestore \
  --gzip \
  --archive=/backups/myapp_20240115.gz

# Restore to a different DB name
mongorestore \
  --nsFrom='myapp.*' \
  --nsTo='myapp_staging.*' \
  /backups/20240115

MONGO_URI=mongodb+srv://appUser:<pass>
  @cluster0.abc123.mongodb.net/myapp
  ?retryWrites=true&w=majority