✏️ MongoDB CRUD Operations

CRUD in One Picture

CRUD is the contract between your application and the database. The app asks; the database answers. Each verb maps to one or two driver methods — learn the map and you've learned the whole surface.

Throughout this lesson we use the official MongoDB Node.js driver (the mongodb package) with async/await. This is the foundation Mongoose is built on — knowing the raw driver makes the higher-level tools far less mysterious.

Connecting from Node.js

Before any CRUD, you need a live connection and a reference to a collection. Install the driver, then keep your connection string in an environment variable — never hard-code credentials.

// Terminal:  npm install mongodb dotenv

import { MongoClient } from 'mongodb';
import 'dotenv/config';

// The connection string lives in .env, e.g.
// MONGODB_URI=mongodb+srv://user:pass@cluster0.xxxx.mongodb.net
const client = new MongoClient(process.env.MONGODB_URI);

await client.connect();                 // open the connection once, up front
const db = client.db('shop');           // pick a database
const products = db.collection('products'); // get a collection handle

console.log('Connected — ready for CRUD');

In the CRUD examples below, assume products is the collection handle from above. All driver methods return promises, so we await them.

Create: insertOne & insertMany

Create adds new documents. Use insertOne for a single document and insertMany for a batch — batching is dramatically faster than looping one insert at a time.

Insert a single document

const result = await products.insertOne({
  name: 'Smartphone X1',
  price: 699.99,
  category: 'Electronics',
  specs: { storage: '128GB', color: 'Black' },
  tags: ['phone', 'mobile'],
  inStock: true,
  createdAt: new Date()            // a real BSON Date, not a string
});

console.log(result.insertedId);    // → the auto-generated ObjectId

{ acknowledged: true, insertedId: new ObjectId("665f0a12ab34cd56ef789012") }

If you don't provide an _id, MongoDB creates an ObjectId for you and hands it back in result.insertedId. The insert is atomic — it fully succeeds or fully fails.

Insert many documents

const result = await products.insertMany([
  { name: 'Laptop Pro', price: 1299.99, category: 'Electronics', inStock: true },
  { name: 'Wireless Earbuds', price: 149.99, category: 'Audio', inStock: true },
  { name: 'Smart Watch', price: 299.99, category: 'Wearables', inStock: false }
]);

console.log(result.insertedCount);  // → 3
console.log(result.insertedIds);    // → { '0': ObjectId(...), '1': ..., '2': ... }

Read: find, findOne & operators

Read is where you'll spend most of your time. You describe the documents you want with a query filter — a plain object — and MongoDB returns the matches.

The basics

// find() returns a CURSOR, not an array — call toArray() to materialize it
const all = await products.find().toArray();

// A filter is just an object: field → value means "equals"
const electronics = await products.find({ category: 'Electronics' }).toArray();

// findOne() returns a single document (or null), no cursor needed
const one = await products.findOne({ name: 'Laptop Pro' });

Query operators

Equality only gets you so far. Query operators — keys that start with $ — express ranges, lists, and patterns. Here are the three you'll use constantly.

// $gt / $gte / $lt / $lte — comparisons
await products.find({ price: { $gt: 500 } }).toArray();        // price > 500
await products.find({ price: { $gte: 100, $lt: 300 } }).toArray(); // 100 ≤ price < 300

// $in — value is one of a list
await products.find({ category: { $in: ['Audio', 'Wearables'] } }).toArray();

// $regex — string matches a pattern ( i = case-insensitive )
await products.find({ name: { $regex: 'watch', $options: 'i' } }).toArray();

// Multiple fields in one filter are combined with AND
await products.find({ category: 'Electronics', inStock: true }).toArray();

// Dot notation reaches into embedded documents
await products.find({ 'specs.storage': '128GB' }).toArray();

Shaping results: projection, sort, limit

const rows = await products
  .find({ inStock: true })
  .project({ name: 1, price: 1, _id: 0 })  // include name & price, drop _id
  .sort({ price: -1 })                      // -1 descending, 1 ascending
  .limit(5)                                 // top 5 only
  .toArray();

Projection keeps payloads small by returning only the fields you need, sort orders the results, and limit caps how many come back — always limit in production so a huge collection can't flood your app.

Update: updateOne & $set

Update modifies existing documents. The critical rule: an update takes two arguments — a filter (which documents) and an update (what to change) — and the change is written with update operators like $set.

// Change specific fields, leaving the rest of the document untouched
const result = await products.updateOne(
  { name: 'Smartphone X1' },                    // filter: which document
  { $set: { price: 649.99, 'specs.color': 'Blue' } }  // update: what to change
);

console.log(result.matchedCount);    // 1 — one document matched the filter
console.log(result.modifiedCount);   // 1 — one document was actually changed

More update operators

// $inc — add to a number (use a negative value to subtract)
await products.updateOne({ name: 'Laptop Pro' }, { $inc: { price: -100 } });

// $push — append to an array
await products.updateOne({ name: 'Smart Watch' }, { $push: { tags: 'sale' } });

// $unset — remove a field entirely
await products.updateOne({ name: 'Smart Watch' }, { $unset: { color: '' } });

// updateMany — apply to EVERY matching document
await products.updateMany(
  { category: 'Electronics' },
  { $set: { onSale: true } }
);

// upsert — update if found, otherwise insert a new document
await products.updateOne(
  { name: 'Tablet Mini' },
  { $set: { price: 349.99, category: 'Electronics' } },
  { upsert: true }
);

Delete: deleteOne & deleteMany

Delete removes documents. The same one-vs-many split applies, and the filter is everything — a mistake here is unrecoverable.

// Remove a single document
const result = await products.deleteOne({ name: 'Wireless Earbuds' });
console.log(result.deletedCount);   // → 1

// Remove every matching document
await products.deleteMany({ inStock: false });

// findOneAndDelete returns the document it removed — handy for logging/undo
const removed = await products.findOneAndDelete({ name: 'Smart Watch' });
console.log('Deleted:', removed?.name);

Indexes: Faster Reads

Without an index, MongoDB answers a query by scanning every document in the collection — fine for 50 documents, catastrophic for 5 million. An index is a sorted data structure that lets the database jump straight to matches, exactly like the index at the back of a textbook lets you find a topic without reading every page.

// Create an ascending index on a single field
await products.createIndex({ category: 1 });   // 1 ascending, -1 descending

// Compound index — supports queries that filter/sort on both fields
await products.createIndex({ category: 1, price: -1 });

// Unique index — the database rejects duplicate values
await products.createIndex({ sku: 1 }, { unique: true });

// See what indexes exist
console.log(await products.indexes());

Practice & Quiz

// TODO: implement each function with the driver
async function addTask(title, priority) { /* insert a new, not-done task */ }
async function getOpenTasks() { /* all tasks where done is false, newest first */ }
async function completeTask(id) { /* set done: true for the task with this _id */ }
async function removeTask(id) { /* delete the task with this _id */ }

import { ObjectId } from 'mongodb';

async function addTask(title, priority) {
  const result = await tasks.insertOne({
    title,
    priority,
    done: false,
    createdAt: new Date()
  });
  return result.insertedId;
}

async function getOpenTasks() {
  return tasks
    .find({ done: false })
    .sort({ createdAt: -1 })   // newest first
    .toArray();
}

async function completeTask(id) {
  const result = await tasks.updateOne(
    { _id: new ObjectId(id) },
    { $set: { done: true, completedAt: new Date() } }
  );
  return result.modifiedCount;  // 1 if it worked, 0 if nothing matched
}

async function removeTask(id) {
  const result = await tasks.deleteOne({ _id: new ObjectId(id) });
  return result.deletedCount;
}

const rows = await products
  .find({
    category: { $in: ['Electronics', 'Audio'] },
    price: { $lt: 800 },
    inStock: true
  })
  .project({ name: 1, price: 1, _id: 0 })
  .sort({ price: 1 })
  .toArray();

Best Practices & Pitfalls

✅ Do

• Use insertMany and bulk writes instead of looping single inserts
• Always .limit() and .project() production queries to keep payloads small
• Wrap changes in update operators ($set, $inc, $push)
• Wrap _id strings in new ObjectId(...) before filtering
• Index the fields you filter and sort on most

❌ Don't

• Call deleteMany({}) or updateMany({}, ...) without triple-checking the empty filter
• Load huge collections with .toArray() — iterate the cursor instead
• Assume an update matched — check matchedCount / modifiedCount
• Leave leading-wildcard regexes like /^.*x/ in hot queries — they can't use an index

Summary

📚 Additional Resources

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

🚀 What's Next?

You've been connecting with a raw URI string. Next you'll set up a real cloud database properly, from account to connection: MongoDB Atlas Setup — the free-tier cluster that will host every project from here on.