Table of Contents
- Introduction
- Why Use the Official MongoDB Driver?
- Installing MongoDB Driver for Node.js
- Connecting to MongoDB (Local and Atlas)
- CRUD Operations with the MongoDB Driver
- Using Connection Pooling
- Error Handling
- Structuring Code for Maintainability
- Best Practices
- Conclusion
1. Introduction
MongoDB is a flexible, document-based NoSQL database that pairs seamlessly with JavaScript via Node.js. While many developers use ODMs like Mongoose, there are cases—especially in performance-critical apps—where using the official MongoDB Node.js driver directly provides better control and transparency.
In this module, we’ll cover how to interact with MongoDB using the official driver, perform CRUD operations, and apply best practices for real-world projects.
2. Why Use the Official MongoDB Driver?
While ORMs/ODMs provide abstraction, the official driver gives you:
- Full access to MongoDB’s native features
- Better performance for low-level database control
- Fine-tuned configuration and optimization options
- Lightweight integration without heavy abstractions
It’s a great choice when you need flexibility or are building tools, services, or microservices that prioritize speed and custom queries.
3. Installing MongoDB Driver for Node.js
To get started, initialize a Node.js project:
npm init -y
Then install the official MongoDB driver:
npm install mongodb
4. Connecting to MongoDB (Local and Atlas)
Connecting to Localhost:
const { MongoClient } = require('mongodb');
const uri = 'mongodb://127.0.0.1:27017';
const client = new MongoClient(uri);
async function connectDB() {
try {
await client.connect();
console.log("Connected to MongoDB");
} catch (err) {
console.error("Connection failed:", err);
}
}
connectDB();
Connecting to MongoDB Atlas:
const uri = 'mongodb+srv://<username>:<password>@cluster.mongodb.net/?retryWrites=true&w=majority';
Always secure your credentials using .env files and dotenv.
5. CRUD Operations with the MongoDB Driver
1. Create (Insert):
const db = client.db('testdb');
const users = db.collection('users');
await users.insertOne({ name: "Alice", age: 25 });
2. Read (Find):
const user = await users.findOne({ name: "Alice" });
console.log(user);
You can also use .find() with .toArray():
const allUsers = await users.find({}).toArray();
3. Update:
await users.updateOne(
{ name: "Alice" },
{ $set: { age: 26 } }
);
4. Delete:
await users.deleteOne({ name: "Alice" });
6. Using Connection Pooling
MongoClient automatically manages a connection pool. You can configure it like this:
const client = new MongoClient(uri, {
maxPoolSize: 10, // Maximum connections in pool
minPoolSize: 2, // Minimum maintained connections
});
This is especially useful for performance tuning in high-traffic apps.
7. Error Handling
Always wrap async operations in try-catch blocks and handle database errors gracefully:
try {
const result = await users.insertOne({ name: "Bob" });
} catch (err) {
if (err.code === 11000) {
console.error("Duplicate key error");
} else {
console.error("Unknown error:", err);
}
}
Use proper logging and monitoring for production environments.
8. Structuring Code for Maintainability
Instead of writing all database logic in a single file, separate your concerns:
/db
└── connect.js
/models
└── userModel.js
/routes
└── userRoutes.js
index.js
Example of connect.js:
const { MongoClient } = require('mongodb');
const client = new MongoClient(process.env.MONGO_URI);
let db;
async function initDB() {
if (!db) {
await client.connect();
db = client.db('appdb');
}
return db;
}
module.exports = initDB;
This structure scales well in real-world applications.
9. Best Practices
- Use async/await for cleaner asynchronous code.
- Secure credentials using dotenv and .env files.
- Always close connections when the app shuts down.
- Index frequently queried fields for performance.
- Avoid storing unnecessary large documents.
- Use transactions (supported in MongoDB 4.0+) when dealing with multiple operations across collections.
- Use Schema Validation to enforce document structure.
10. Conclusion
Using the official MongoDB driver gives you more control, better performance, and full access to MongoDB’s capabilities. It’s a great fit for lightweight services, microservices, or when you want to avoid abstraction overhead.