MongoDB with Node.js: Driver Examples (find, insert, update)

To use MongoDB from Node.js, install the official driver (npm install mongodb), connect with new MongoClient(uri), pick a database with client.db('name') and a collection with db.collection('name'). Every operation (insertOne, find, updateOne, deleteOne) returns a promise, so you await it. Documents go in and come out as plain JavaScript objects.

import { MongoClient } from 'mongodb';

const client = new MongoClient('mongodb://localhost:27017');
await client.connect();

const books = client.db('shop').collection('books');

await books.insertMany([
    { title: 'Dune', author: 'Herbert', year: 1965, price: 12 },
    { title: 'Neuromancer', author: 'Gibson', year: 1984, price: 9 },
    { title: 'Hyperion', author: 'Simmons', year: 1989, price: 11 },
]);

const all = await books.find().toArray();
console.log(all.map((b) => b.title));

await client.close();

It prints [ 'Dune', 'Neuromancer', 'Hyperion' ]. The shop database and books collection did not exist before: MongoDB creates them on the first insert, and toArray() loads every document the find() cursor points to.

Find documents with filters and projection

A filter is an object describing the documents you want. Plain values match exactly; operators such as $gt, $lt, $in and $regex go in a nested object. The second argument's projection picks which fields come back.

import { MongoClient } from 'mongodb';

const client = new MongoClient('mongodb://localhost:27017');
const books = client.db('shop').collection('books');

await books.insertMany([
    { title: 'Dune', author: 'Herbert', year: 1965, price: 12 },
    { title: 'Neuromancer', author: 'Gibson', year: 1984, price: 9 },
    { title: 'Hyperion', author: 'Simmons', year: 1989, price: 11 },
    { title: 'Foundation', author: 'Asimov', year: 1951, price: 8 },
]);

const recent = await books
    .find({ year: { $gt: 1960 } }, { projection: { _id: 0, title: 1, year: 1 } })
    .sort({ year: -1 })
    .limit(2)
    .toArray();
recent.forEach((b) => console.log(b));

const cheap = await books.findOne({ price: { $lt: 10 }, author: 'Asimov' });
console.log(cheap.title);

console.log(await books.countDocuments({ price: { $gte: 10 } }));

await client.close();

recent holds the two newest books after 1960, Hyperion then Neuromancer, with only title and year; findOne returns the first match (or null), and countDocuments counts 2 books costing 10 or more. Change $gt: 1960 to $gt: 1985 and only Hyperion is left.

Update and delete

updateOne(filter, update) changes the first matching document. The update uses operators: $set replaces fields, $inc adds to a number, $unset removes a field and $push appends to an array. updateMany and deleteMany work on every match.

import { MongoClient } from 'mongodb';

const client = new MongoClient('mongodb://localhost:27017');
const books = client.db('shop').collection('books');

await books.insertMany([
    { title: 'Dune', price: 12, stock: 3 },
    { title: 'Neuromancer', price: 9, stock: 0 },
]);

const res = await books.updateOne(
    { title: 'Dune' },
    { $set: { price: 10 }, $inc: { stock: -1 } }
);
console.log(res.matchedCount, res.modifiedCount);

const dune = await books.findOne({ title: 'Dune' });
console.log(dune.price, dune.stock);

const del = await books.deleteOne({ stock: 0 });
console.log('deleted', del.deletedCount, 'left', await books.countDocuments());

await client.close();

The update matched and modified one document, so Dune now costs 10 with 2 in stock, and deleting the book with no stock leaves 1. An update must use operators: pass { price: 10 } without $set and the driver refuses it (replaceOne is the call that replaces a whole document).

ObjectId and indexes

Every document gets an _id; when you do not set one, the driver creates an ObjectId. To find a document by an id that arrived as a string (from a URL, say), wrap it in new ObjectId(id). An index makes a field fast to search, and a unique index makes MongoDB refuse duplicates.

import { MongoClient, ObjectId } from 'mongodb';

const client = new MongoClient('mongodb://localhost:27017');
const users = client.db('app').collection('users');

await users.createIndex({ email: 1 }, { unique: true });

const { insertedId } = await users.insertOne({ email: 'ada@example.com' });
const idString = insertedId.toString();
console.log(idString.length);

const found = await users.findOne({ _id: new ObjectId(idString) });
console.log(found.email);
console.log(await users.findOne({ _id: idString }));

try {
    await users.insertOne({ email: 'ada@example.com' });
} catch (err) {
    console.log('duplicate, error code', err.code);
}

await client.close();

An ObjectId is 24 hex characters as a string, and searching with the plain string finds nothing, so that line prints null. The second insert breaks the unique index and fails with code 11000, which is how you detect "email already taken".

Use MongoDB in an Express API

Connect once when the server starts and share the collection; do not open a new connection per request. The driver keeps a pool of connections and reuses them.

// GET /books
import express from 'express';
import { MongoClient, ObjectId } from 'mongodb';

const client = new MongoClient('mongodb://localhost:27017');
const books = client.db('shop').collection('books');

// Setup: seed two books
await books.insertMany([
    { title: 'Dune', year: 1965 },
    { title: 'Hyperion', year: 1989 },
]);

const app = express();
app.use(express.json());

app.get('/books', async (req, res) => {
    const list = await books.find().sort({ year: 1 }).toArray();
    res.json(list);
});

app.get('/books/:id', async (req, res) => {
    if (!ObjectId.isValid(req.params.id)) {
        return res.status(400).json({ error: 'Bad id' });
    }
    const book = await books.findOne({ _id: new ObjectId(req.params.id) });
    if (!book) return res.status(404).json({ error: 'Not found' });
    res.json(book);
});

app.post('/books', async (req, res) => {
    const { insertedId } = await books.insertOne({ title: req.body.title, year: req.body.year });
    res.status(201).json({ _id: insertedId });
});

app.listen(3000);

GET /books returns both books, each with an _id. Copy one id into GET /books/<id> to fetch a single book, or send POST /books with a JSON body like {"title": "Foundation", "year": 1951} and list the books again.

A real app reads the connection string from process.env.MONGODB_URI instead of writing it in the code.

If you want schemas and validation on top of the driver, Mongoose (npm install mongoose) wraps it:

const Book = mongoose.model('Book', new mongoose.Schema({ title: String, year: Number }));
await Book.create({ title: 'Dune', year: 1965 });

Common mistakes

Forgetting toArray(). find() returns a cursor, not documents. Logging it shows a cursor object; call toArray(), or loop over it with for await.

Connecting on every request. Each new MongoClient opens its own pool. Create one client at startup and reuse it everywhere.

Never closing the client in a script. An open client keeps the process alive after your code is done. Call await client.close() at the end of scripts; a server keeps it open for its whole life.