MongoDB e Node.js: esempi del driver (find, insert, update)

Per usare MongoDB da Node.js installa il driver ufficiale (npm install mongodb), connettiti con new MongoClient(uri), scegli un database con client.db('name') e una collection con db.collection('name'). Ogni operazione (insertOne, find, updateOne, deleteOne) restituisce una promise, quindi fai await. I documenti entrano ed escono come semplici oggetti JavaScript.

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

Stampa [ 'Dune', 'Neuromancer', 'Hyperion' ]. Il database shop e la collection books prima non esistevano: MongoDB li crea al primo inserimento, e toArray() carica tutti i documenti a cui punta il cursore di find().

Cercare documenti con filtri e projection

Un filtro è un oggetto che descrive i documenti che vuoi. I valori semplici devono corrispondere esattamente; operatori come $gt, $lt, $in e $regex vanno in un oggetto annidato. La projection del secondo argomento sceglie quali campi tornano indietro.

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 contiene i due libri più recenti dopo il 1960, prima Hyperion poi Neuromancer, con solo title e year; findOne restituisce la prima corrispondenza (o null), e countDocuments conta 2 libri che costano 10 o più. Cambia $gt: 1960 in $gt: 1985 e resta solo Hyperion.

Aggiornare ed eliminare

updateOne(filter, update) modifica il primo documento che corrisponde. L'aggiornamento usa degli operatori: $set sostituisce campi, $inc aggiunge a un numero, $unset toglie un campo e $push aggiunge in fondo a un array. updateMany e deleteMany agiscono su tutte le corrispondenze.

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

L'aggiornamento ha trovato e modificato un documento, quindi ora Dune costa 10 con 2 copie in magazzino, ed eliminando il libro senza scorte ne resta 1. Un aggiornamento deve usare gli operatori: passa { price: 10 } senza $set e il driver lo rifiuta (replaceOne è la chiamata che sostituisce un documento intero).

ObjectId e indici

Ogni documento riceve un _id; se non lo imposti tu, il driver crea un ObjectId. Per trovare un documento da un id arrivato come stringa (da un URL, per esempio), avvolgilo in new ObjectId(id). Un indice rende veloce la ricerca su un campo, e un indice unique fa rifiutare a MongoDB i duplicati.

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 come stringa è lungo 24 caratteri esadecimali, e cercare con la stringa semplice non trova niente, quindi quella riga stampa null. Il secondo inserimento viola l'indice unique e fallisce con il codice 11000, che è il modo di capire che "l'email è già usata".

Usare MongoDB in un'API Express

Connettiti una volta sola all'avvio del server e condividi la collection; non aprire una nuova connessione per ogni richiesta. Il driver tiene un pool di connessioni e le riusa.

// 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 restituisce entrambi i libri, ognuno con un _id. Copia un id in GET /books/<id> per leggere un singolo libro, oppure invia POST /books con un body JSON come {"title": "Foundation", "year": 1951} ed elenca di nuovo i libri.

Un'app vera legge la stringa di connessione da process.env.MONGODB_URI invece di scriverla nel codice.

Se vuoi schemi e validazione sopra il driver, Mongoose (npm install mongoose) lo avvolge:

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

Errori comuni

Dimenticare toArray(). find() restituisce un cursore, non documenti. Stamparlo mostra un oggetto cursore; chiama toArray() oppure scorrilo con for await.

Connettersi a ogni richiesta. Ogni new MongoClient apre il suo pool. Crea un solo client all'avvio e riusalo ovunque.

Non chiudere mai il client in uno script. Un client aperto tiene vivo il processo dopo che il codice ha finito. Chiama await client.close() alla fine degli script; un server lo tiene aperto per tutta la sua vita.