Menu
CoddyTech
Inizia a imparare

Incorporare o fare riferimento

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

Sia le recensioni sia le valutazioni appartengono a un libro, ma il posto migliore in cui memorizzarle è diverso.

L'incorporamento inserisce i dati correlati nel documento, così una sola lettura recupera il libro e le sue recensioni. È adatto ai dati che vengono letti insieme al documento principale e che rimangono di dimensioni contenute. Il riferimento conserva i dati in una raccolta separata insieme all'id del documento principale, come avviene per ratings. È adatto ai dati che crescono senza limiti o che vengono interrogati separatamente, come la media di tutte le valutazioni.

Un documento può contenere al massimo 16 MB, quindi è necessario porre un limite a un array incorporato. All'interno di $push, $each elenca i valori da aggiungere e $slice: -3 mantiene gli ultimi tre.

await players.updateOne(
    { name: 'Ada' },
    { $push: { recentScores: { $each: [120], $slice: -3 } } }
);
challenge icon

Sfida

Facile

Le recensioni sono brevi, vengono sempre mostrate insieme al libro e ogni libro ne mostra solo le 5 più recenti. Quindi conservale nel documento del libro, in un array reviews, e non lasciare mai che quell’array superi 5 elementi.

  1. In server.js, aggiungi POST /books/:id/reviews. Il corpo della richiesta ha questo aspetto: { "user": "ada", "text": "Loved it" }. Usa parseId per gestire un ID non valido: la risposta sarà 400.
  2. Con un solo aggiornamento, aggiungi la recensione, per esempio { "user": "ada", "text": "Loved it" }, alla fine dell’array reviews del libro. Nello stesso aggiornamento, riduci l’array agli ultimi 5 elementi, in modo che la recensione più vecchia venga rimossa. Se un libro non ha recensioni, verrà creato un nuovo array.
  3. Se non esiste alcun libro con quell’_id, rispondi con 404.
  4. Altrimenti, rispondi con stato 201 e solo l’array reviews del libro, non con l’intero libro, dalla recensione più vecchia alla più recente. Dopo la prima recensione, la risposta è:
    [ { "user": "ada", "text": "Loved it" } ]
    Prova: invia GET /books e copia l’_id di Dune. Invia POST /books/<Dune's _id>/reviews con { "user": "ada", "text": "Loved it" }: riceverai 201 e l’array qui sopra. Invia altre cinque recensioni, con i testi da "Review 2" a "Review 6". L’ultima risposta contiene cinque recensioni, da Review 2 a Review 6, e Loved it non c’è più. Invia GET /books/<Dune's _id>: Dune contiene le stesse cinque recensioni in reviews e la scheda Data le mostra all’interno del libro.

Provalo tu

import express from 'express';
import { z } from 'zod';
import { ObjectId } from 'mongodb';
import { books, ratings } from './db.js';

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 per un 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;
}

const BookInput = z.object({
    title: z.string().min(1),
    author: z.string().min(1),
    year: z.number().int(),
    isbn: z.string().min(1),
    genre: z.string().min(1),
});

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 page = Number(req.query.page) || 1;
    const limit = Number(req.query.limit) || 10;
    const items = await books
        .find(filter)
        .skip((page - 1) * limit)
        .limit(limit)
        .toArray();
    const total = await books.countDocuments(filter);
    res.json({ items, total });
});

app.post('/books', async (req, res) => {
    const parsed = BookInput.safeParse(req.body);
    if (!parsed.success) {
        const issue = parsed.error.issues[0];
        return sendError(res, 400, `${issue.path.join('.')}: ${issue.message}`);
    }
    const book = parsed.data;
    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 } },
            {
                $lookup: {
                    from: 'authors',
                    localField: 'author',
                    foreignField: 'name',
                    as: 'authorInfo',
                },
            },
        ])
        .toArray();
    if (!book) {
        return sendError(res, 404, 'No such book');
    }
    res.json(book);
});

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

Questa lezione include un breve quiz. Inizia la lezione per rispondere e tenere traccia dei tuoi progressi.

Tutte le lezioni di Database con MongoDB

1Documenti

Un libro come documentoRaccolte e databaseConnessione a MongoDBLettura dei documenti memorizzatiInserimento di documentiRicerca di un documentoRicerca tramite ObjectIdConfronto tra numeriFiltri di queryScelta dei campi restituitiOrdinamento dei risultati della queryMantenere i primi risultatiProiezione, ordinamento e limite

4Struttura

Un modulo per il databasePaginazione nel databaseLezione di progettoValidare prima di salvareLezione di progettoIncorporare o fare riferimentoLezione di progetto

2Modifica dei documenti

Aggiornamento dei documentiOperatori di aggiornamentoLezione di progettoEliminazione dei documentiLezione di progettoIndici univociLezione di progettoUpsertLezione di progetto

3Aggregazione

Conteggio dei documentiUna pipeline di fasiRaggruppare con $groupMedie all'interno dei gruppiFiltrare i risultati dei gruppiPipeline di aggregazioneUnire con $lookup

Esercitati da solo: Playground Express