🔧 CRUD Operations in MongoDB

What Is CRUD?

CRUD stands for Create, Read, Update, Delete — the four fundamental things any application does with stored data. Signing up a user is a Create; loading a profile is a Read; editing a bio is an Update; closing an account is a Delete. Master these four and you can build the data layer of almost any app.

💡 The library analogy. Think of a collection as a library. Create is shelving a new book, Read is searching the catalog, Update is correcting a book's record, and Delete is removing a book from circulation. MongoDB simply gives you precise tools for each of those actions.

We'll use the official MongoDB Node.js driver (npm install mongodb). In a later lesson you'll layer Mongoose on top for schema validation, but working with the raw driver first shows you exactly what is happening underneath.

Connecting from Node.js

Every operation starts from a connected client. Create a small reusable connection module so the rest of your code never repeats connection boilerplate.

# Create and initialize the project
mkdir mongodb-crud-demo && cd mongodb-crud-demo
npm init -y
npm install mongodb dotenv

// connection.js
require('dotenv').config();
const { MongoClient } = require('mongodb');

// Read the URI from an environment variable — never hard-code credentials
const uri = process.env.MONGODB_URI || 'mongodb://localhost:27017';
const dbName = process.env.DB_NAME || 'crud_demo';

const client = new MongoClient(uri);

async function connectToDatabase() {
  await client.connect();
  console.log('Connected to MongoDB');
  return client.db(dbName);
}

async function closeConnection() {
  await client.close();
  console.log('Connection closed');
}

module.exports = { connectToDatabase, closeConnection };

Create: Inserting Documents

Use insertOne() for a single document and insertMany() for a batch. MongoDB adds an _id automatically if you don't provide one, and returns the generated id(s).

// insert.js
const { connectToDatabase, closeConnection } = require('./connection');

async function run() {
  try {
    const db = await connectToDatabase();
    const products = db.collection('products');

    // Insert one document
    const one = await products.insertOne({
      name: 'Laptop',
      price: 999.99,
      category: 'Electronics',
      inStock: true,
      tags: ['computers', 'work'],
      createdAt: new Date()
    });
    console.log('Inserted _id:', one.insertedId);

    // Insert many documents in a single round trip
    const many = await products.insertMany([
      { name: 'Smartphone', price: 699.99, category: 'Electronics', inStock: true,  tags: ['mobile'] },
      { name: 'Headphones', price: 149.99, category: 'Audio',       inStock: false, tags: ['audio', 'wireless'] }
    ]);
    console.log(`Inserted ${many.insertedCount} documents`);
  } finally {
    await closeConnection();
  }
}

run().catch(console.error);

Connected to MongoDB
Inserted _id: new ObjectId("65b2f1a...")
Inserted 2 documents
Connection closed

Read: Querying Documents

find() returns a cursor over many documents (call .toArray() to materialize them); findOne() returns a single document or null. A query is just a document describing what to match.

const products = db.collection('products');

// Everything
const all = await products.find().toArray();

// Exact match
const electronics = await products.find({ category: 'Electronics' }).toArray();

// Comparison operator: price less than 200
const affordable = await products.find({ price: { $lt: 200 } }).toArray();

// Multiple conditions are combined with AND
const inStockElectronics = await products.find({
  category: 'Electronics',
  inStock: true
}).toArray();

// OR condition
const techOrAudio = await products.find({
  $or: [{ category: 'Electronics' }, { category: 'Audio' }]
}).toArray();

// Query a nested field with dot notation
const oled = await products.find({ 'specs.screen': '6.7 inch OLED' }).toArray();

// Array membership: matches if the tags array contains 'wireless'
const wireless = await products.find({ tags: 'wireless' }).toArray();

// A single document (or null)
const laptop = await products.findOne({ name: 'Laptop' });

Projections and cursor methods

Return only the fields you need with a projection, and shape result sets with sort, skip, and limit — the building blocks of pagination.

// Only name and price, exclude _id
const slim = await products
  .find({}, { projection: { name: 1, price: 1, _id: 0 } })
  .toArray();

// Page 2, 10 per page, newest first
const page = 2, pageSize = 10;
const results = await products
  .find({ inStock: true })
  .sort({ createdAt: -1 })   // -1 = descending, 1 = ascending
  .skip((page - 1) * pageSize)
  .limit(pageSize)
  .toArray();

// Counting and distinct values
const total = await products.countDocuments({ category: 'Electronics' });
const categories = await products.distinct('category');

Query Operators Reference

Operators start with $ and turn a plain match into an expressive query. These are the ones you'll use daily.

Update: Modifying Documents

An update has two parts: a filter (which documents) and an update document built from operators like $set. Use updateOne for the first match, updateMany for all matches, and replaceOne to swap an entire document (keeping its _id).

const products = db.collection('products');

// Update the first matching document
const res = await products.updateOne(
  { name: 'Laptop' },                       // filter
  { $set: { price: 1099.99, 'specs.ram': '32GB', updatedAt: new Date() } }
);
console.log(`Matched ${res.matchedCount}, modified ${res.modifiedCount}`);

// Update every matching document — 10% off all electronics
await products.updateMany(
  { category: 'Electronics' },
  { $set: { onSale: true }, $mul: { price: 0.9 } }
);

The update operators you'll reach for

Upsert: update if it exists, otherwise insert

Passing { upsert: true } tells MongoDB to create the document when the filter matches nothing. It's perfect for "save settings" or counters that may not exist yet.

// If "Tablet Pro" doesn't exist, it's created; otherwise its price is updated.
const result = await products.updateOne(
  { name: 'Tablet Pro' },
  {
    $set: { price: 549.99, category: 'Electronics', inStock: true },
    $setOnInsert: { createdAt: new Date() }   // only applied on creation
  },
  { upsert: true }
);
console.log('Upserted id:', result.upsertedId);  // set only when a new doc was created

Delete: Removing Documents

deleteOne() removes the first match; deleteMany() removes all matches. Both return a deletedCount.

const products = db.collection('products');

// Remove a single document
const one = await products.deleteOne({ name: 'Headphones' });
console.log(`Deleted ${one.deletedCount}`);

// Remove every out-of-stock product
const many = await products.deleteMany({ inStock: false });
console.log(`Deleted ${many.deletedCount}`);

// Drop an entire collection (structure and all)
await products.drop();

Hands-on Exercise

const { connectToDatabase, closeConnection } = require('./connection');

async function run() {
  try {
    const db = await connectToDatabase();
    const tasks = db.collection('tasks');
    await tasks.deleteMany({});               // start clean

    // CREATE
    await tasks.insertMany([
      { title: 'Write lesson', done: false, priority: 3, createdAt: new Date() },
      { title: 'Review PR',    done: false, priority: 2, createdAt: new Date() },
      { title: 'Water plants', done: false, priority: 1, createdAt: new Date() }
    ]);

    // READ
    const important = await tasks
      .find({ priority: { $gte: 2 } })
      .sort({ priority: -1 })
      .toArray();
    console.log('Important:', important.map(t => t.title));

    // UPDATE
    await tasks.updateOne({ title: 'Review PR' }, { $set: { done: true } });
    await tasks.updateMany({}, { $inc: { priority: 1 } });

    // DELETE
    const del = await tasks.deleteMany({ done: true });
    console.log(`Removed ${del.deletedCount} completed task(s)`);

    console.log('Remaining:', await tasks.find().toArray());
  } finally {
    await closeConnection();
  }
}

run().catch(console.error);

Best Practices

Summary & Quiz

📚 Further Reading

• MongoDB Manual — CRUD Operations
• MongoDB Manual — Query Operators
• MongoDB Node.js Driver Docs

🚀 What's Next?

You've driven the raw driver. Next we add structure and safety: Mongoose ODM Fundamentals brings schemas, validation, middleware, and population to your MongoDB code.