MongoDB con Node.js: ejemplos del driver (find, insert)

Para usar MongoDB desde Node.js, instala el driver oficial (npm install mongodb), conéctate con new MongoClient(uri), elige una base de datos con client.db('name') y una colección con db.collection('name'). Cada operación (insertOne, find, updateOne, deleteOne) devuelve una promesa, así que la esperas con await. Los documentos entran y salen como objetos normales de 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();

Imprime [ 'Dune', 'Neuromancer', 'Hyperion' ]. La base de datos shop y la colección books no existían antes: MongoDB las crea con la primera inserción, y toArray() carga todos los documentos a los que apunta el cursor de find().

Buscar documentos con filtros y projection

Un filtro es un objeto que describe los documentos que quieres. Los valores simples coinciden de forma exacta; los operadores como $gt, $lt, $in y $regex van en un objeto anidado. La projection del segundo argumento elige qué campos se devuelven.

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 los dos libros más nuevos posteriores a 1960, Hyperion y después Neuromancer, solo con title y year; findOne devuelve la primera coincidencia (o null), y countDocuments cuenta 2 libros que cuestan 10 o más. Cambia $gt: 1960 por $gt: 1985 y solo queda Hyperion.

Actualizar y borrar

updateOne(filter, update) cambia el primer documento que coincide. La actualización usa operadores: $set reemplaza campos, $inc suma a un número, $unset elimina un campo y $push añade al final de un array. updateMany y deleteMany actúan sobre todas las coincidencias.

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 actualización encontró y modificó un documento, así que Dune ahora cuesta 10 con 2 en stock, y al borrar el libro sin stock queda 1. Una actualización tiene que usar operadores: pasa { price: 10 } sin $set y el driver la rechaza (replaceOne es la llamada que reemplaza un documento entero).

ObjectId e índices

Cada documento tiene un _id; si no lo defines tú, el driver crea un ObjectId. Para buscar un documento por un id que llegó como string (desde una URL, por ejemplo), envuélvelo en new ObjectId(id). Un índice hace que un campo sea rápido de buscar, y un índice único hace que MongoDB rechace duplicados.

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 son 24 caracteres hexadecimales como string, y buscar con el string tal cual no encuentra nada, así que esa línea imprime null. La segunda inserción rompe el índice único y falla con el código 11000, que es como detectas que "el email ya está en uso".

Usar MongoDB en una API con Express

Conéctate una sola vez al arrancar el servidor y comparte la colección; no abras una conexión nueva en cada petición. El driver mantiene un pool de conexiones y las reutiliza.

// 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 devuelve los dos libros, cada uno con un _id. Copia un id en GET /books/<id> para obtener un solo libro, o envía POST /books con un body JSON como {"title": "Foundation", "year": 1951} y vuelve a listar los libros.

Una app real lee el connection string de process.env.MONGODB_URI en lugar de escribirlo en el código.

Si quieres esquemas y validación encima del driver, Mongoose (npm install mongoose) lo envuelve:

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

Errores comunes

Olvidar toArray(). find() devuelve un cursor, no documentos. Si lo imprimes verás un objeto cursor; llama a toArray(), o recórrelo con for await.

Conectarse en cada petición. Cada new MongoClient abre su propio pool. Crea un cliente al arrancar y reutilízalo en todas partes.

No cerrar nunca el cliente en un script. Un cliente abierto mantiene vivo el proceso cuando tu código ya ha terminado. Llama a await client.close() al final de los scripts; un servidor lo mantiene abierto durante toda su vida.