MongoDB avec Node.js : exemples du driver (find, insert)

Pour utiliser MongoDB depuis Node.js, installez le driver officiel (npm install mongodb), connectez-vous avec new MongoClient(uri), choisissez une base avec client.db('name') et une collection avec db.collection('name'). Chaque opération (insertOne, find, updateOne, deleteOne) renvoie une promesse, donc vous l'attendez avec await. Les documents entrent et sortent sous forme d'objets JavaScript simples.

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();

Le programme affiche [ 'Dune', 'Neuromancer', 'Hyperion' ]. La base shop et la collection books n'existaient pas avant : MongoDB les crée au premier insert, et toArray() charge tous les documents vers lesquels pointe le curseur de find().

Chercher des documents avec filtres et projection

Un filtre est un objet qui décrit les documents voulus. Les valeurs simples correspondent exactement ; les opérateurs comme $gt, $lt, $in et $regex se placent dans un objet imbriqué. La projection du second argument choisit les champs renvoyés.

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 contient les deux livres les plus récents après 1960, Hyperion puis Neuromancer, avec seulement title et year ; findOne renvoie la première correspondance (ou null), et countDocuments compte 2 livres à 10 ou plus. Remplacez $gt: 1960 par $gt: 1985 et il ne reste qu'Hyperion.

Modifier et supprimer

updateOne(filter, update) modifie le premier document correspondant. La mise à jour utilise des opérateurs : $set remplace des champs, $inc ajoute à un nombre, $unset supprime un champ et $push ajoute à un tableau. updateMany et deleteMany agissent sur toutes les correspondances.

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();

La mise à jour a trouvé et modifié un document, donc Dune coûte maintenant 10 avec 2 en stock, et supprimer le livre sans stock en laisse 1. Une mise à jour doit utiliser des opérateurs : passez { price: 10 } sans $set et le driver la refuse (replaceOne est l'appel qui remplace un document entier).

ObjectId et index

Chaque document reçoit un _id ; si vous n'en définissez pas, le driver crée un ObjectId. Pour trouver un document à partir d'un id arrivé sous forme de chaîne (depuis une URL, par exemple), enveloppez-le dans new ObjectId(id). Un index rend la recherche sur un champ rapide, et un index unique fait refuser les doublons par MongoDB.

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();

Un ObjectId fait 24 caractères hexadécimaux sous forme de chaîne, et chercher avec la chaîne brute ne trouve rien, donc cette ligne affiche null. Le second insert viole l'index unique et échoue avec le code 11000, ce qui permet de détecter un « email déjà utilisé ».

Utiliser MongoDB dans une API Express

Connectez-vous une seule fois au démarrage du serveur et partagez la collection ; n'ouvrez pas une nouvelle connexion par requête. Le driver garde un pool de connexions et les réutilise.

// 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 renvoie les deux livres, chacun avec un _id. Copiez un id dans GET /books/<id> pour récupérer un seul livre, ou envoyez POST /books avec un corps JSON comme {"title": "Foundation", "year": 1951} et listez à nouveau les livres.

Une vraie application lit la chaîne de connexion depuis process.env.MONGODB_URI au lieu de l'écrire dans le code.

Si vous voulez des schémas et de la validation par-dessus le driver, Mongoose (npm install mongoose) l'enveloppe :

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

Erreurs fréquentes

Oublier toArray(). find() renvoie un curseur, pas des documents. L'afficher montre un objet curseur ; appelez toArray(), ou parcourez-le avec for await.

Se connecter à chaque requête. Chaque new MongoClient ouvre son propre pool. Créez un seul client au démarrage et réutilisez-le partout.

Ne jamais fermer le client dans un script. Un client ouvert garde le processus en vie une fois votre code terminé. Appelez await client.close() à la fin des scripts ; un serveur le garde ouvert pendant toute sa durée de vie.