Explore

f24 Full Stack Development Tuesday October 1

Note: The conclusion of this lab is an API Server. You can build the HTML client in this following lab to work with the Server:

⁠

Let’s start by making the College Enrollment System working with JSON in MONGO

A high level review of SQL, as we will now proceed from JSON predication joins to JSON projections

⁠

Refresher on basic SQL Concepts including the PREDICATE JOIN between Tables

⁠

Cartoon Superheros: Schema and Model

⁠

Today’s learning topics:

What we have done so far...

Adding Mongo Atlas to an Express project

Installing Mongoose

Adding the Mongo Connection String

Creating a Model

Creating a Schema

Creating an Express GET endpoint that performs a query (.find, .findById)

Insert a document

Update a document

Delete a document

*** -> Working with more than one collection (example: Employees and Vehicles, Books and Authors, etc) Given that I have already taught {Adding Mongo Atlas to an Express project

Installing Mongoose

Adding the Mongo Connection String

Creating a Model

Creating a Schema} ### although more reinforcement and exposure for our new learners is always beneficial

A learning script for Creating an Express GET endpoint that performs a query (.find, .findById)

Insert a document

Update a document

Delete a document

*** -> Working with more than one collection (example: Employees and Vehicles, Books and Authors, etc)

The BOOKSTORE Mongo DB Express Application

Let's create an example project working with two collections:

"Books" and "Authors".

This will allow us to demonstrate CRUD operations and working with multiple collections.

MongoDB Operations with Express

This lab covers all the basic CRUD operations and demonstrates working with multiple collections (Books and Authors).

Here's a breakdown of what each part does:

We define schemas and models for both Author and Book.

The Book schema includes a reference to Author.

GET endpoint to find all books:

Uses Book.find() to retrieve all books

Uses .populate('author') to include full author details

GET endpoint to find a book by ID:

Uses Book.findById(req.params.id) to find a specific book

Also populates the author field

POST endpoint to insert a new author:

Creates a new Author document

Saves it to the database

POST endpoint to insert a new book:

Creates a new Book document, including a reference to an author

Saves it to the database

PATCH endpoint to update a book:

Finds the book by ID

Updates the fields that are provided in the request

Saves the updated book

DELETE endpoint to delete a book:

Finds the book by ID

Removes it from the database

This script demonstrates how to work with multiple collections by using references between Books and Authors.

When we retrieve books, we can populate the author field to get the full author details.

To use this in your Express app:

Save this code in a separate file (e.g., bookRoutes.js)

In your main app file:

const bookRoutes = require('./bookRoutes');

app.use('/api', bookRoutes);

This sets up all these routes under the /api path.

GitHUB with this code:

⁠

Here's the complete code for bookRoutes.js that you can copy and paste into your project.

This code implements all the CRUD operations for books and authors, including the references between them:

Bookstore Express Routes with MongoDB - To use this in your Express app:

Save this code in a file named bookRoutes.js in your project directory.

In your main app file (e.g., app.js or server.js), add these lines:

const bookRoutes = require('./bookRoutes');

app.use('/api', bookRoutes);

This code sets up all the routes under the /api path.

Here's a breakdown of what each part does:

It defines schemas and models for both Author and Book.

The Book schema includes a reference to Author.

GET /api/books retrieves all books and populates author details.

GET /api/books/:id finds a specific book by ID and populates author details.

POST /api/authors creates a new Author document.

POST /api/books creates a new Book document, including a reference to an author.

PATCH /api/books/:id updates a book's information.

DELETE /api/books/:id removes a book from the database.

This setup demonstrates how to work with multiple collections by using references between Books and Authors. When we retrieve books, we use .populate('author') to get the full author details.

Remember to handle errors appropriately and validate input data in a production environment. Also, ensure that your MongoDB connection is set up correctly in your main application file.

Note the core importance of the router — this is the npm package to which we apply the operations of C R U D

// bookRoutes.js

const express = require('express');

const mongoose = require('mongoose');

const router = express.Router();

https://www.perplexity.ai/page/npm-router-package-overview-hsWSi3WySCSNduB_QvvoAw⁠

⁠

https://www.npmjs.com/package/router⁠

⁠

// Define schemas

const authorSchema = new mongoose.Schema({

bio: String

});

const bookSchema = new mongoose.Schema({

title: String,

description: String,

publishedYear: Number,

author: { type: mongoose.Schema.Types.ObjectId, ref: 'Author' }

});

// Create models

const Author = mongoose.model('Author', authorSchema);

const Book = mongoose.model('Book', bookSchema);

// GET all books

router.get('/books', async (req, res) => {

try {

// JOIN between collections happens when you use the POPULATE METHOD:

const books = await Book.find().populate('author');

// remember in express.js res → response back to the requesting web page.

res.json(books);

} catch (err) {

res.status(500).json({ message: err.message });

}

});

// GET a specific book by ID

router.get('/books/:id', async (req, res) => {

try {

const book = await Book.findById(req.params.id).populate('author');

if (!book) {

return res.status(404).json({ message: 'Book not found' });

}

res.json(book);

} catch (err) {

res.status(500).json({ message: err.message });

}

});

// POST a new author

router.post('/authors', async (req, res) => {

const author = new Author({

bio: req.body.bio

});

try {

const newAuthor = await author.save();

res.status(201).json(newAuthor);

} catch (err) {

res.status(400).json({ message: err.message });

}

});

// POST a new book

router.post('/books', async (req, res) => {

const book = new Book({

title: req.body.title,

description: req.body.description,

publishedYear: req.body.publishedYear,

author: req.body.authorId

});

try {

const newBook = await book.save();

res.status(201).json(newBook);

} catch (err) {

res.status(400).json({ message: err.message });

}

});

// PATCH (update) a book

router.patch('/books/:id', async (req, res) => {

try {

const book = await Book.findById(req.params.id);

if (!book) {

return res.status(404).json({ message: 'Book not found' });

}

if (req.body.title) book.title = req.body.title;

if (req.body.description) book.description = req.body.description;

if (req.body.publishedYear) book.publishedYear = req.body.publishedYear;

if (req.body.authorId) book.author = req.body.authorId;

const updatedBook = await book.save();

res.json(updatedBook);

} catch (err) {

res.status(400).json({ message: err.message });

}

});

// DELETE a book

router.delete('/books/:id', async (req, res) => {

try {

const book = await Book.findById(req.params.id);

if (!book) {

return res.status(404).json({ message: 'Book not found' });

}

await book.remove();

res.json({ message: 'Book deleted' });

} catch (err) {

res.status(500).json({ message: err.message });

}

});

module.exports = router;

// app.js const express = require('express'); const mongoose = require('mongoose'); const bodyParser = require('body-parser'); require('dotenv').config();

const app = express(); const PORT = process.env.PORT || 3000;

// Middleware app.use(bodyParser.json());

// MongoDB Atlas Connection mongoose.connect(process.env.MONGODB_URI, { useNewUrlParser: true, useUnifiedTopology: true, }) .then(() => console.log('Connected to MongoDB Atlas')) .catch(err => console.error('Error connecting to MongoDB Atlas:', err));

// Define schemas const authorSchema = new mongoose.Schema({ name: String, birthYear: Number });

const bookSchema = new mongoose.Schema({ title: String, publishYear: Number, author: { type: mongoose.Schema.Types.ObjectId, ref: 'Author' } });

// Create models const Author = mongoose.model('Author', authorSchema); const Book = mongoose.model('Book', bookSchema);

// Routes

// GET all books app.get('/api/books', async (req, res) => { try { const books = await Book.find().populate('author'); res.json(books); } catch (err) { res.status(500).json({ message: err.message }); } });

// GET a book by ID app.get('/api/books/:id', async (req, res) => { try { const book = await Book.findById(req.params.id).populate('author'); if (book == null) { return res.status(404).json({ message: 'Book not found' }); } res.json(book); } catch (err) { res.status(500).json({ message: err.message }); } });

// POST a new author app.post('/api/authors', async (req, res) => { const author = new Author({ name: req.body.name, birthYear: req.body.birthYear });

try { const newAuthor = await author.save(); res.status(201).json(newAuthor); } catch (err) { res.status(400).json({ message: err.message }); } });

// POST a new book app.post('/api/books', async (req, res) => { const book = new Book({ title: req.body.title, publishYear: req.body.publishYear, author: req.body.authorId });

try { const newBook = await book.save(); res.status(201).json(newBook); } catch (err) { res.status(400).json({ message: err.message }); } });

// PATCH (update) a book app.patch('/api/books/:id', async (req, res) => { try { const book = await Book.findById(req.params.id); if (book == null) { return res.status(404).json({ message: 'Book not found' }); }

if (req.body.title != null) { book.title = req.body.title; } if (req.body.publishYear != null) { book.publishYear = req.body.publishYear; } if (req.body.authorId != null) { book.author = req.body.authorId; }

const updatedBook = await book.save(); res.json(updatedBook); } catch (err) { res.status(400).json({ message: err.message }); } });

// DELETE a book app.delete('/api/books/:id', async (req, res) => { try { const book = await Book.findById(req.params.id); if (book == null) { return res.status(404).json({ message: 'Book not found' }); }

await book.deleteOne(); res.json({ message: 'Book deleted' }); } catch (err) { res.status(500).json({ message: err.message }); } });

// Start the server app.listen(PORT, () => { console.log(`Server is running on port ${PORT}`); });

"Highlights reel" lecture that spotlights how each CRUD (Create, Read, Update, Delete) operation is implemented in our MongoDB with Express lab code.

This will help students focus on the key parts of each operation.

MongoDB with Express: CRUD Operations Highlights

This "highlights reel" lecture provides a concise overview of how each CRUD operation is implemented in the lab code. Here are some key points to emphasize when presenting this to students:

Consistency in structure: Note how each route follows a similar pattern of trying an operation and catching any errors.

Asynchronous operations: All database operations are asynchronous and use async/await for cleaner code.

Error handling: Each operation includes error handling to send appropriate status codes and messages.

Use of Mongoose methods: Point out how we use Mongoose methods like find(), findById(), save(), and deleteOne() to interact with the database.

Working with related data: In the READ operations, we use populate() to fill in author details, demonstrating how to work with related collections.

Partial updates: In the UPDATE operation, we only modify fields that are provided in the request, showing how to handle partial updates.

Checking for existence: Before updating or deleting, we first check if the document exists, providing appropriate feedback if it doesn't.

By focusing on these highlights, students can get a clear understanding of how CRUD operations are implemented in a MongoDB with Express application, without getting lost in the details of the full codebase.

MongoDB with Express: CRUD Operations Highlights

1. Create (INSERT)

We have two CREATE operations in our code: one for authors and one for books.

Creating an Author:

javascript

Copy

app.post('/api/authors', async (req, res) => {

const author = new Author({

birthYear: req.body.birthYear

});

try {

const newAuthor = await author.save();

res.status(201).json(newAuthor);

} catch (err) {

res.status(400).json({ message: err.message });

}

});

Key points:

We use the new Author() constructor to create a new author document.

author.save() is used to insert the new document into the database.

We return the newly created author with a 201 status code on success.

Creating a Book:

javascript

Copy

app.post('/api/books', async (req, res) => {

const book = new Book({

title: req.body.title,

publishYear: req.body.publishYear,

author: req.body.authorId

});

try {

const newBook = await book.save();

res.status(201).json(newBook);

} catch (err) {

res.status(400).json({ message: err.message });

}

});

Key points:

Similar to creating an author, we use new Book() to create a book document.

We reference the author by their ID in the author field.

book.save() inserts the new book into the database.

2. Read (FIND)

We have two READ operations: one to get all books and one to get a specific book by ID.

Reading All Books:

javascript

Copy

app.get('/api/books', async (req, res) => {

Want to print your doc?
This is not the way.

Try clicking the ⋯ next to your doc name or using a keyboard shortcut (

CtrlP

) instead.