Se connecter avec le pilote Node.js officiel

The Official MongoDB Node.js Driver

// Install the driver
// npm install mongodb

// Or with yarn:
// yarn add mongodb

// The driver exports MongoClient as its main entry point
const { MongoClient, ObjectId, ServerApiVersion } = require('mongodb');
// or ES module:
// import { MongoClient, ObjectId } from 'mongodb';

Creating a MongoClient

const { MongoClient, ServerApiVersion } = require('mongodb');

const uri = process.env.MONGODB_URI;
// URI format: mongodb+srv://<user>:<password>@cluster0.xxxxx.mongodb.net/?retryWrites=true

const client = new MongoClient(uri, {
  serverApi: {
    version: ServerApiVersion.v1,
    strict: true,
    deprecationErrors: true
  }
});

// client is not yet connected — connecting happens lazily or via connect()

Connecting to MongoDB

async function main() {
  try {
    await client.connect();
    console.log('Connected to MongoDB');

    // Get database reference
    const db = client.db('myDatabase');
    
    // Ping the server to verify connection
    await db.command({ ping: 1 });
    console.log('Ping successful');

    // Run your application logic here...
  } finally {
    // Always close when done
    await client.close();
  }
}

main().catch(console.error);

Singleton Pattern for Web Servers

// db.js — module-level singleton
const { MongoClient } = require('mongodb');

let client;
let db;

async function connectToDatabase() {
  if (db) return db; // return existing connection
  client = new MongoClient(process.env.MONGODB_URI);
  await client.connect();
  db = client.db(process.env.DB_NAME || 'myapp');
  return db;
}

module.exports = { connectToDatabase };

// In your Express app:
// const { connectToDatabase } = require('./db');
// const db = await connectToDatabase();
// app.locals.db = db;

Getting Collection References

const db = client.db('ecommerce');

// Get collection references
const usersCollection = db.collection('users');
const ordersCollection = db.collection('orders');
const productsCollection = db.collection('products');

// TypeScript: provide a document type for type safety
// const users = db.collection<UserDocument>('users');

// Collections can also be retrieved inline:
async function getUser(id) {
  return client.db('ecommerce').collection('users').findOne({ _id: id });
}

CRUD Operations: Insert

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

// Insert one document
const insertResult = await products.insertOne({
  name: 'Mechanical Keyboard',
  price: 149.99,
  category: 'Electronics',
  stock: 50
});
console.log('Inserted ID:', insertResult.insertedId);

// Insert multiple documents
const bulkResult = await products.insertMany([
  { name: 'Mouse Pad', price: 19.99, category: 'Accessories' },
  { name: 'USB Hub', price: 39.99, category: 'Electronics' }
]);
console.log('Inserted count:', bulkResult.insertedCount);

CRUD Operations: Read

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

// Find a single user by email
const user = await users.findOne(
  { email: 'alice@example.com' },
  { projection: { password: 0 } }  // exclude sensitive fields
);

// Find multiple documents with options
const activeUsers = await users.find(
  { active: true, role: 'admin' },
  {
    projection: { name: 1, email: 1 },
    sort: { createdAt: -1 },
    limit: 50
  }
).toArray();

// Iterate large results without loading all into memory
const cursor = users.find({ active: true });
for await (const user of cursor) {
  await processUser(user);
}

CRUD Operations: Update

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

// Update one order's status
const updateResult = await orders.updateOne(
  { _id: orderId },
  { $set: { status: 'shipped', shippedAt: new Date() } }
);
console.log('Modified:', updateResult.modifiedCount);

// Atomic: find, update, and return the updated document
const updatedOrder = await orders.findOneAndUpdate(
  { _id: orderId },
  { $set: { status: 'delivered' }, $push: { statusHistory: { status: 'delivered', at: new Date() } } },
  { returnDocument: 'after' }  // return the document AFTER update
);

CRUD Operations: Delete

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

// Delete one session
const deleteResult = await sessions.deleteOne({ _id: sessionId });
console.log('Deleted:', deleteResult.deletedCount);

// Delete all expired sessions — test filter first!
const thirtyDaysAgo = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000);

// 1. Test: how many would be deleted?
const count = await sessions.countDocuments({ expiresAt: { $lt: thirtyDaysAgo } });
console.log('Would delete:', count);

// 2. Only delete after confirming the count looks right
if (count < 10000) { // sanity check
  await sessions.deleteMany({ expiresAt: { $lt: thirtyDaysAgo } });
}

Running Aggregation Pipelines

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

// Revenue report by category
const report = await orders.aggregate([
  { $match: { status: 'completed', createdAt: { $gte: new Date('2024-01-01') } } },
  { $group: { _id: '$category', total: { $sum: '$amount' }, count: { $sum: 1 } } },
  { $sort: { total: -1 } }
]).toArray();

console.log('Revenue report:', report);

// For large aggregations, iterate the cursor:
const cursor = orders.aggregate([...largeComplexPipeline]);
for await (const doc of cursor) {
  await writeToReport(doc);
}

Connection Pool Configuration

const client = new MongoClient(uri, {
  maxPoolSize: 20,           // max 20 connections to the server
  minPoolSize: 5,            // keep at least 5 connections warm
  connectTimeoutMS: 5000,   // fail fast if can't connect in 5s
  socketTimeoutMS: 45000,   // idle socket timeout
  serverSelectionTimeoutMS: 5000  // how long to wait to find an available server
});

Quick Check

Lesson Recap