MongoDB is a document-oriented NoSQL database that stores data as flexible, JSON-like documents called BSON. At the heart of every MongoDB application lies CRUD — Create, Read, Update, and Delete — the four fundamental operations used to interact with data. This tutorial walks through each operation in detail, from beginner basics to advanced patterns, using the official MongoDB Node.js Driver.

📖 1. Introduction

Every database interaction ultimately boils down to one of four operations: creating new data, reading existing data, updating data, or deleting data. MongoDB provides a rich, expressive API for each of these operations, allowing developers to work with data in a natural, JavaScript-friendly way.

🧩 2. CRUD Overview

Each CRUD operation in MongoDB is exposed through methods on a Collection object. Before performing any operation, you must first connect to a MongoDB instance and select a database and collection.

const { MongoClient } = require("mongodb");

const client = new MongoClient("mongodb://localhost:27017");

async function main() {
  await client.connect();
  const db = client.db("shop");
  const collection = db.collection("products");
  // CRUD operations go here
}

main().catch(console.error);

➕ 3. Creating Documents

The Create operation adds new documents to a collection. MongoDB automatically generates a unique _id field for each document unless you explicitly provide one.

insertOne()

Use insertOne() to insert a single document into a collection.

const result = await collection.insertOne({
  name: "Wireless Mouse",
  price: 25.99,
  inStock: true
});

console.log(result.insertedId);

insertMany()

Use insertMany() to insert multiple documents in a single, efficient database call.

const result = await collection.insertMany([
  { name: "Keyboard", price: 49.99 },
  { name: "Monitor", price: 199.99 },
  { name: "Webcam", price: 39.99 }
]);

console.log(result.insertedCount);

🔍 6. Reading Documents

The Read operation retrieves documents from a collection based on specified criteria. MongoDB's query language is flexible, supporting exact matches, comparisons, and complex logical conditions.

find()

find() returns a cursor pointing to all documents matching a query. An empty filter {} returns every document in the collection.

const cursor = collection.find({ inStock: true });
const products = await cursor.toArray();

console.log(products);

findOne()

findOne() returns the first matching document only, or null if no document matches.

const product = await collection.findOne({ name: "Keyboard" });
console.log(product);

🎯 9. Query Filters

Query filters use comparison and logical operators to narrow down results. Filters are written as objects where keys map to fields and values describe the matching criteria.

const results = await collection.find({
  price: { $gte: 20, $lte: 100 },
  inStock: true
}).toArray();

🗂️ 10. Projection

Projection controls which fields are returned in query results, reducing network overhead by excluding unnecessary data.

// Include only name and price, exclude _id
const results = await collection
  .find({}, { projection: { name: 1, price: 1, _id: 0 } })
  .toArray();

↕️ 11. Sorting

The sort() method orders results by one or more fields. Use 1 for ascending order and -1 for descending order.

const results = await collection
  .find({})
  .sort({ price: -1 })
  .toArray();

🔢 12. Limiting Results

limit() restricts the number of documents returned, which is especially useful for pagination.

const topThree = await collection
  .find({})
  .sort({ price: -1 })
  .limit(3)
  .toArray();

⏭️ 13. Skipping Results

skip() bypasses a specified number of documents, commonly combined with limit() to implement paginated queries.

const page2 = await collection
  .find({})
  .sort({ _id: 1 })
  .skip(10)
  .limit(10)
  .toArray();

🔢 14. Counting Documents

Use countDocuments() to count how many documents match a given filter.

const count = await collection.countDocuments({ inStock: true });
console.log(`In-stock products: ${count}`);

✏️ 15. Updating Documents

The Update operation modifies existing documents. MongoDB uses update operators (prefixed with $) to describe precisely how a document should change.

updateOne()

Updates the first document that matches the filter.

const result = await collection.updateOne(
  { name: "Mouse" },
  { $set: { price: 22.99 } }
);

console.log(result.modifiedCount);

updateMany()

Updates all documents matching the filter.

const result = await collection.updateMany(
  { inStock: false },
  { $set: { discontinued: true } }
);

console.log(result.modifiedCount);

replaceOne()

Unlike updateOne(), which modifies specific fields, replaceOne() replaces the entire document (except _id) with a new one.

const result = await collection.replaceOne(
  { name: "Webcam" },
  { name: "Webcam Pro", price: 59.99, inStock: true }
);

🛠️ 19. Update Operators

await collection.updateOne(
  { name: "Mouse" },
  {
    $inc: { stockCount: -1 },
    $push: { tags: "electronics" }
  }
);

🗑️ 20. Deleting Documents

The Delete operation removes documents that match a given filter. Deleted documents cannot be recovered unless backups exist.

deleteOne()

const result = await collection.deleteOne({ name: "Webcam Pro" });
console.log(result.deletedCount);

deleteMany()

const result = await collection.deleteMany({ discontinued: true });
console.log(result.deletedCount);

⚙️ 23. Bulk Operations

bulkWrite() allows you to combine multiple insert, update, and delete operations into a single database round-trip, improving performance for batch workloads.

const result = await collection.bulkWrite([
  { insertOne: { document: { name: "USB Hub", price: 15.99 } } },
  { updateOne: {
      filter: { name: "Mouse" },
      update: { $set: { price: 19.99 } }
    }
  },
  { deleteOne: { filter: { name: "Old Item" } } }
]);

console.log(result);

🔁 24. Upserts

An upsert (update + insert) creates a new document if no document matches the filter, or updates the existing one if a match is found. Enable this behavior with the upsert option.

const result = await collection.updateOne(
  { sku: "SKU-1001" },
  { $set: { name: "Desk Lamp", price: 29.99 } },
  { upsert: true }
);

if (result.upsertedId) {
  console.log("New document created:", result.upsertedId);
}

🚨 25. Error Handling

Robust applications must handle errors gracefully — including connection failures, validation errors, and duplicate key violations.

try {
  await collection.insertOne({ _id: 1, name: "Duplicate" });
  await collection.insertOne({ _id: 1, name: "Duplicate" });
} catch (error) {
  if (error.code === 11000) {
    console.error("Duplicate key error:", error.message);
  } else {
    console.error("Unexpected error:", error);
  }
}

🌟 26. Best Practices

⚠️ 27. Common Mistakes

❓ 28. Frequently Asked Questions

📌 29. Summary