1
2
3
4
5
6
// Example 1: Simple create
await User.create({ name: "Alice", age: 25 });

// Example 2: Using constructor + save
const user = new User({ name: "Bob", age: 30 });
await user.save();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// Example 1: Get all users
const users = await User.find();

// Example 2: Find by filter
const activeUsers = await User.find({ status: "active" });

// Example 3: Find one specific user
const user = await User.findOne({ email: "test@gmail.com" });

// Example 4: Find by ID
const user = await User.findById("652a12c4d12e1a2b5f8f3d9c");

// Example 5: Filter and select fields
const names = await User.find({}, "name email");

1
2
3
4
5
6
7
8
9
10
11
12
// Example 1: Update one
await User.updateOne({ name: "Alice" }, { $set: { age: 26 } });

// Example 2: Update many
await User.updateMany({ status: "inactive" }, { $set: { status: "active" } });

// Example 3: Update by ID and return the new version
const updatedUser = await User.findByIdAndUpdate(
  "652a12c4d12e1a2b5f8f3d9c",
  { $set: { age: 35 } },
  { new: true }
);

1
2
3
4
5
6
7
8
// Example 1: Delete one
await User.deleteOne({ name: "Alice" });

// Example 2: Delete many
await User.deleteMany({ status: "inactive" });

// Example 3: Delete by ID
await User.findByIdAndDelete("652a12c4d12e1a2b5f8f3d9c");

1
const users = await User.find({});

1
const youngUsers = await User.find({ age: 20 });

1
const result = await User.find({ age: { $gt: 18, $lte: 30 } });

1
const users = await User.find({ $and: [{ age: 20 }, { status: 'active' }] });

1
const users = await User.find({ age: { $in: [18, 20, 25] } });

1
const users = await User.find({ name: { $regex: 'john', $options: 'i' } });

1
const users = await User.find({ email: { $exists: true } });

1
const users = await User.find({ nickname: null });

1
2
3
4
5
6
7
8
9
10
11
// Equal to 25
await User.find({ age: { $eq: 25 } });

// Not equal to 'inactive'
await User.find({ status: { $ne: 'inactive' } });

// Greater than or equal to 30
await User.find({ age: { $gte: 30 } });

// Less than 40
await User.find({ age: { $lt: 40 } });

1
2
3
4
5
6
7
8
// Match users who are active AND older than 25
await User.find({ $and: [{ status: 'active' }, { age: { $gt: 25 } }] });

// Match users who are either admin OR manager
await User.find({ $or: [{ role: 'admin' }, { role: 'manager' }] });

// Match users who are NOT active
await User.find({ status: { $not: { $eq: 'active' } } });

1
2
3
4
5
6
7
8
// Match if 'skills' contains at least one of these values
await User.find({ skills: { $in: ['NodeJS', 'React'] } });

// Match if 'skills' includes ALL listed values
await User.find({ skills: { $all: ['MongoDB', 'Express'] } });

// Match arrays with exactly 3 items
await User.find({ skills: { $size: 3 } });

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// Set a new field value
await User.updateOne({ name: 'Alice' }, { $set: { status: 'active' } });

// Increment a number field
await User.updateOne({ name: 'Bob' }, { $inc: { age: 1 } });

// Add an item to an array
await User.updateOne({ name: 'Charlie' }, { $push: { skills: 'Docker' } });

// Remove an item from an array
await User.updateOne({ name: 'Charlie' }, { $pull: { skills: 'React' } });

// Add only if not already in array
await User.updateOne({ name: 'Ethan' }, { $addToSet: { skills: 'AI' } });

// Remove a field completely
await User.updateOne({ name: 'Diana' }, { $unset: { nickname: "" } });

1
2
3
4
5
// Find documents that have an 'email' field
await User.find({ email: { $exists: true } });

// Find where 'age' is stored as a Number
await User.find({ age: { $type: 'number' } });

1
const users = await User.find().limit(10);

1
const users = await User.find().skip(20);

1
2
3
4
5
// Ascending (youngest first)
const ascUsers = await User.find().sort({ age: 1 });

// Descending (oldest first)
const descUsers = await User.find().sort({ age: -1 });

1
await User.find().sort({ status: 1, age: -1 });

1
const users = await User.find().select('name age');

1
const users = await User.find().select('-password -email');

1
2
3
4
5
6
7
8
const page = 2;
const limit = 5;
const skip = (page - 1) * limit;

const users = await User.find()
  .sort({ createdAt: -1 })
  .skip(skip)
  .limit(limit);

1
const posts = await Post.find().populate('author', 'name email');

1
const posts = await Post.find().populate('author');

1
const posts = await Post.find().populate('author', 'name email');

1
2
3
4
5
const posts = await Post.find().populate({
  path: 'author',
  match: { status: 'active' },
  select: 'name email status'
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
const result = await User.aggregate([
  { $match: { status: 'active' } },
  { $lookup: {
      from: 'posts',
      localField: '_id',
      foreignField: 'author',
      as: 'posts'
  }},
  { $unwind: '$posts' },
  { $group: {
      _id: '$name',
      totalPosts: { $sum: 1 },
      avgLikes: { $avg: '$posts.likes' }
  }},
  { $sort: { totalPosts: -1 } }
]);

1
2
3
4
5
6
7
8
9
10
// Count all active users
const activeCount = await User.countDocuments({ status: 'active' });

// Get total number of users quickly
const totalCount = await User.estimatedDocumentCount();

// Check if a user with a given email exists
const isExisting = await User.exists({ email: 'alice@example.com' });

console.log({ activeCount, totalCount, isExisting });

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
const result = await User.aggregate([
  // 1. Filter only active users
  { 
    $match: { status: 'active' } 
  },

  // 2. Join with Post collection (JOIN equivalent)
  { 
    $lookup: {
      from: 'posts',
      localField: '_id',
      foreignField: 'author',
      as: 'posts'
    } 
  },

  // 3. Add computed fields (totalPosts, avgLikes)
  { 
    $addFields: {
      totalPosts: { $size: '$posts' },
      avgLikes: { $avg: '$posts.likes' }
    } 
  },

  // 4. Project only desired fields
  { 
    $project: { 
      name: 1, 
      email: 1, 
      totalPosts: 1, 
      avgLikes: { $round: ['$avgLikes', 1] } 
    } 
  },
  // 5. Sort descending
  { 
    $sort: { totalPosts: -1 } 
  }
]);