Unire con $lookup

Fa parte della sezione Database con MongoDB del percorso Node.js di Coddy. Lezione 25 di 29.

Un libro memorizza il nome del suo autore, mentre i dettagli dell'autore si trovano in un'altra raccolta. Il cliente vuole entrambi in un'unica risposta.

Lo stage $lookup esegue un join. Per ogni documento, trova i documenti nella raccolta from in cui foreignField è uguale a localField di questo documento e li inserisce in un nuovo campo array denominato con as.

await orders.aggregate([
    { $match: { _id: orderId } },
    { $lookup: {
        from: 'customers',
        localField: 'customerEmail',
        foreignField: 'email',
        as: 'customer',
    } },
]).toArray();
// [{ _id: ..., customerEmail: 'ada@x.io', customer: [{ email: 'ada@x.io', ... }] }]

toArray() restituisce un array di ordini, che in questo caso ne contiene uno. Prendi il suo primo elemento per ottenere l'ordine stesso.

localField appartiene ai documenti nella pipeline, foreignField all'altra raccolta. Il risultato è un array, anche in caso di una sola corrispondenza.

La raccolta from fornisce ogni documento corrispondente nell'array denominato con as. La route fornita prende il primo risultato della pipeline per restituire il libro richiesto.

Sfida

Facile

Questo passaggio apre il progetto API di libreria preparato per il corso, anziché i file del tuo progetto di Aggregation Pipelines (incluso server.js). Il lavoro svolto in precedenza rimane nella sua lezione. Leggi i file forniti prima di modificare server.js. Questa copia contiene le route della libreria, il conteggio dei generi e la pipeline dei libri più apprezzati, oltre agli autori precaricati e alla gestione delle risposte.

Nella route GET /books/:id/full già predisposta in server.js, aggiungi uno stage di lookup dopo il match esistente. Unisci gli autori quando book.author è uguale ad author.name. Inserisci le corrispondenze in authorInfo. Mantieni il codice fornito che prende il primo risultato e restituisce 404 quando il libro non esiste.

Prova: GET /books e copia l’_id di Emma. GET /books/<Emma’s _id>/full restituisce Emma con un array authorInfo contenente Jane Austen e born 1775. Un libro con un autore sconosciuto restituisce authorInfo: []. Un id di libro valido ma inesistente restituisce comunque 404.

Provalo tu

import express from 'express';
import { MongoClient, ObjectId } from 'mongodb';
import { authorList } from './authors.js';

const client = new MongoClient('mongodb://localhost:27017');
const db = client.db('shelf');
const books = db.collection('books');
const ratings = db.collection('ratings');
const authors = db.collection('authors');

await books.createIndex({ isbn: 1 }, { unique: true });
await books.insertMany([
    { title: 'Dune', author: 'Frank Herbert', year: 1965, isbn: '9780441013593', genre: 'scifi' },
    { title: 'Kindred', author: 'Octavia E. Butler', year: 1979, isbn: '9780807083697', genre: 'scifi' },
    { title: 'Emma', author: 'Jane Austen', year: 1815, isbn: '9780141439587', genre: 'classic' },
]);
await authors.insertMany(authorList);

const app = express();
app.use(express.json());

// Ogni errore restituisce { error: message }.
function sendError(res, status, message) {
    res.status(status).json({ error: message });
}

// Restituisce :id come ObjectId, oppure null dopo aver risposto con 400 se l'id non è valido.
function parseId(req, res) {
    if (ObjectId.isValid(req.params.id)) {
        return new ObjectId(req.params.id);
    }
    sendError(res, 400, 'Not a valid id');
    return null;
}

app.get('/', (req, res) => {
    res.send('Bookshelf API');
});

app.get('/books', async (req, res) => {
    const filter = {};
    if (req.query.author) {
        filter.author = req.query.author;
    }
    if (req.query.from || req.query.to) {
        filter.year = {};
        if (req.query.from) {
            filter.year.$gte = Number(req.query.from);
        }
        if (req.query.to) {
            filter.year.$lte = Number(req.query.to);
        }
    }
    const list = await books.find(filter).toArray();
    res.json(list);
});

app.post('/books', async (req, res) => {
    const book = req.body;
    try {
        await books.insertOne(book);
    } catch (err) {
        if (err.code === 11000) {
            return sendError(res, 409, 'That ISBN is already on the shelf');
        }
        throw err;
    }
    res.status(201).json(book);
});

app.get('/books/newest', async (req, res) => {
    const n = Number(req.query.n) || 3;
    const list = await books
        .find({}, { projection: { title: 1, year: 1, _id: 0 } })
        .sort({ year: -1 })
        .limit(n)
        .toArray();
    res.json(list);
});

app.get('/books/:id', async (req, res) => {
    const id = parseId(req, res);
    if (!id) return;
    const book = await books.findOne({ _id: id });
    if (!book) {
        return sendError(res, 404, 'No such book');
    }
    res.json(book);
});

app.patch('/books/:id', async (req, res) => {
    const id = parseId(req, res);
    if (!id) return;
    const result = await books.updateOne({ _id: id }, { $set: req.body });
    if (result.matchedCount === 0) {
        return sendError(res, 404, 'No such book');
    }
    res.json(await books.findOne({ _id: id }));
});

app.post('/books/:id/copies', async (req, res) => {
    const id = parseId(req, res);
    if (!id) return;
    const result = await books.updateOne({ _id: id }, { $inc: { copies: 1 } });
    if (result.matchedCount === 0) {
        return sendError(res, 404, 'No such book');
    }
    res.json(await books.findOne({ _id: id }));
});

app.post('/books/:id/tags', async (req, res) => {
    const id = parseId(req, res);
    if (!id) return;
    const result = await books.updateOne({ _id: id }, { $push: { tags: req.body.tag } });
    if (result.matchedCount === 0) {
        return sendError(res, 404, 'No such book');
    }
    res.json(await books.findOne({ _id: id }));
});

app.delete('/books/:id', async (req, res) => {
    const id = parseId(req, res);
    if (!id) return;
    const result = await books.deleteOne({ _id: id });
    if (result.deletedCount === 0) {
        return sendError(res, 404, 'No such book');
    }
    res.status(204).end();
});

app.put('/books/:id/ratings', async (req, res) => {
    const id = parseId(req, res);
    if (!id) return;
    const { user, stars } = req.body;
    await ratings.updateOne({ bookId: id, user }, { $set: { stars } }, { upsert: true });
    res.json({ user, stars });
});

app.get('/books/:id/ratings', async (req, res) => {
    const id = parseId(req, res);
    if (!id) return;
    res.json(await ratings.find({ bookId: id }).toArray());
});

app.get('/stats', async (req, res) => {
    const filter = req.query.genre ? { genre: req.query.genre } : {};
    res.json({
        books: await books.countDocuments(filter),
        ratings: await ratings.countDocuments(),
    });
});

app.get('/stats/genres', async (req, res) => {
    const genres = await books
        .aggregate([{ $group: { _id: '$genre', count: { $sum: 1 } } }])
        .toArray();
    res.json(genres);
});

app.get('/stats/top', async (req, res) => {
    const top = await ratings
        .aggregate([
            { $group: { _id: '$bookId', avg: { $avg: '$stars' }, count: { $sum: 1 } } },
            { $match: { count: { $gte: 2 } } },
            { $sort: { avg: -1 } },
            { $limit: 3 },
        ])
        .toArray();
    res.json(top);
});

app.get('/books/:id/full', async (req, res) => {
    const id = parseId(req, res);
    if (!id) return;
    const [book] = await books
        .aggregate([
            { $match: { _id: id } },

        ])
        .toArray();
    if (!book) {
        return sendError(res, 404, 'No such book');
    }
    res.json(book);
});

app.listen(3000, () => {
    console.log('Bookshelf is running on port 3000');
});

Esercitati da solo: Playground Express

Unire con $lookup

Tutte le lezioni di Database con MongoDB