MongoDB mit Node.js: Treiber-Beispiele für find und insert

Um MongoDB aus Node.js zu nutzen, installierst du den offiziellen Treiber (npm install mongodb), verbindest dich mit new MongoClient(uri), wählst eine Datenbank mit client.db('name') und eine Collection mit db.collection('name'). Jede Operation (insertOne, find, updateOne, deleteOne) gibt ein Promise zurück, du wartest also mit await darauf. Dokumente gehen als einfache JavaScript-Objekte hinein und kommen so wieder heraus.

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

Es gibt [ 'Dune', 'Neuromancer', 'Hyperion' ] aus. Die Datenbank shop und die Collection books existierten vorher nicht: MongoDB legt sie beim ersten Einfügen an, und toArray() lädt jedes Dokument, auf das der find()-Cursor zeigt.

Dokumente mit Filtern und Projection finden

Ein Filter ist ein Objekt, das die gewünschten Dokumente beschreibt. Einfache Werte passen exakt; Operatoren wie $gt, $lt, $in und $regex kommen in ein verschachteltes Objekt. Die projection im zweiten Argument wählt, welche Felder zurückkommen.

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 enthält die beiden neuesten Bücher nach 1960, erst Hyperion, dann Neuromancer, nur mit title und year; findOne gibt den ersten Treffer zurück (oder null), und countDocuments zählt 2 Bücher, die 10 oder mehr kosten. Ändere $gt: 1960 in $gt: 1985, und nur Hyperion bleibt übrig.

Ändern und löschen

updateOne(filter, update) ändert das erste passende Dokument. Das Update nutzt Operatoren: $set ersetzt Felder, $inc addiert zu einer Zahl, $unset entfernt ein Feld und $push hängt an ein Array an. updateMany und deleteMany wirken auf jeden Treffer.

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

Das Update hat ein Dokument gefunden und geändert, Dune kostet jetzt also 10 bei 2 auf Lager, und nach dem Löschen des Buchs ohne Bestand bleibt 1 übrig. Ein Update muss Operatoren nutzen: Übergib { price: 10 } ohne $set, und der Treiber lehnt es ab (replaceOne ist der Aufruf, der ein ganzes Dokument ersetzt).

ObjectId und Indexe

Jedes Dokument bekommt eine _id; wenn du keine setzt, erzeugt der Treiber eine ObjectId. Um ein Dokument über eine ID zu finden, die als String ankommt (etwa aus einer URL), pack sie in new ObjectId(id). Ein Index macht ein Feld schnell durchsuchbar, und ein Unique-Index lässt MongoDB Duplikate ablehnen.

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

Eine ObjectId ist als String 24 Hex-Zeichen lang, und die Suche mit dem einfachen String findet nichts, deshalb gibt diese Zeile null aus. Das zweite Einfügen verletzt den Unique-Index und schlägt mit Code 11000 fehl, so erkennst du "E-Mail schon vergeben".

MongoDB in einer Express-API nutzen

Verbinde dich einmal beim Serverstart und teil die Collection; öffne nicht pro Anfrage eine neue Verbindung. Der Treiber hält einen Pool von Verbindungen und verwendet sie wieder.

// 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 liefert beide Bücher, jedes mit einer _id. Kopier eine ID in GET /books/<id>, um ein einzelnes Buch abzurufen, oder sende POST /books mit einem JSON-Body wie {"title": "Foundation", "year": 1951} und lass dir die Bücher noch einmal auflisten.

Eine echte App liest den Connection String aus process.env.MONGODB_URI, statt ihn in den Code zu schreiben.

Wenn du Schemas und Validierung über dem Treiber willst, umhüllt ihn Mongoose (npm install mongoose):

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

Häufige Fehler

toArray() vergessen. find() gibt einen Cursor zurück, keine Dokumente. Loggst du ihn, siehst du ein Cursor-Objekt; ruf toArray() auf oder durchlauf ihn mit for await.

Bei jeder Anfrage neu verbinden. Jeder new MongoClient öffnet einen eigenen Pool. Erstell beim Start einen Client und verwende ihn überall.

Den Client in einem Skript nie schließen. Ein offener Client hält den Prozess am Leben, nachdem dein Code fertig ist. Ruf am Ende von Skripten await client.close() auf; ein Server hält ihn während seiner ganzen Laufzeit offen.