Databases with Express

0 Week at a glance

• DBMS — software that stores, retrieves and updates data (MongoDB, MySQL, PostgreSQL…).
• MongoDB — a NoSQL, document database: your data looks like JSON objects, not rigid tables.
• Mongoose — the ODM that lets Node talk to MongoDB with tidy Schemas and Models.
• CRUD — create · find · updateOne · deleteOne — the four things every app does to data.

1 Databases & the DBMS

• A database (DB) is an organized collection of data.
• A DBMS (Database Management System) is the software that handles storing, retrieving and updating it.
• When people say "the database," they usually mean the data plus the DBMS managing it.

2 Why NoSQL?

Same two people, two ways to store them — flip between the views:

{
  "name": "Lori",
  "employer": "Self",
  "occupation": "Entrepreneur"
}

{
  "name": "Malia",
  "school": "Harvard"
}

3 How MongoDB is organized

{
  "_id": "665f1e...c296",
  "title": "Death Note",
  "studio": "Madhouse",
  "rating": 9
}

4 Local vs cloud — MongoDB Atlas

5 Meet Mongoose 🍃

npm install mongoose

Run it. Then break it: change the string to something without mongodb and watch .catch() fire.

const mongoose = require("mongoose");

mongoose.connect("mongodb+srv://me:pass@cluster0.mongodb.net/animeApp")
  .then(() => console.log("✅ MongoDB Connected"))
  .catch((err) => console.log("❌ " + err.message));

6 Schemas & Models

• A Schema describes the shape of a document — field names, types, and rules like required.
• A Model is your handle to a collection — you call find, create, etc. on it.
• Mongoose auto-pluralizes the model name for the collection: model "Anime" → collection animes.

const mongoose = require("mongoose");

// STEP 1 — a Schema: the shape + rules of a document
const animeSchema = new mongoose.Schema({
  title:  { type: String, required: true },
  studio: String,
  rating: Number,
  year:   Number
});

// STEP 2 — a Model from the schema (→ collection "animes")
const Anime = mongoose.model("Anime", animeSchema);

// STEP 3 — use it. create() inserts a new document.
const jjk = await Anime.create({ title: "Jujutsu Kaisen", studio: "MAPPA", rating: 9, year: 2020 });
console.log("Inserted (note the auto _id):", jjk);

console.log("The animes collection now holds:", await Anime.countDocuments());

7 Read — find & friends

const mongoose = require("mongoose");
const Anime = mongoose.model("Anime", new mongoose.Schema({
  title: String, studio: String, rating: Number, year: Number
}));

// find ALL matching → array. $gte = "greater than or equal"
const great = await Anime.find({ rating: { $gte: 9 } });
console.log("Rated 9+:", great.map(a => a.title));

// findOne → the FIRST match (or null)
const one = await Anime.findOne({ studio: "Madhouse" });
console.log("A Madhouse show:", one.title);

// operators: $lt (less than) and $regex (pattern match)
const older = await Anime.find({ year: { $lt: 2010 } });
console.log("Before 2010:", older.map(a => a.title));

const man = await Anime.find({ title: { $regex: "Man", $options: "i" } });
console.log("Title has 'man':", man.map(a => a.title));

// findById needs a real _id — grab one first
const first = await Anime.findOne();
console.log("Found by _id:", (await Anime.findById(first._id)).title);

8 Query playground 🎮

9 Update documents

const mongoose = require("mongoose");
const Anime = mongoose.model("Anime", new mongoose.Schema({
  title: String, studio: String, rating: Number
}));

// updateOne(filter, update) → change the FIRST match
const r1 = await Anime.updateOne({ title: "One Punch Man" }, { rating: 9 });
console.log("matched:", r1.matchedCount, "· modified:", r1.modifiedCount);

// $inc bumps a number; updateMany changes EVERY match
const r2 = await Anime.updateMany({ rating: { $lt: 10 } }, { $inc: { rating: 1 } });
console.log("bumped", r2.modifiedCount, "ratings by 1");

const all = await Anime.find();
console.log(all.map(a => a.title + " → " + a.rating));

10 Delete documents

const mongoose = require("mongoose");
const Anime = mongoose.model("Anime", new mongoose.Schema({ title: String, rating: Number }));

console.log("before:", await Anime.countDocuments());

// deleteOne → first match only
const d1 = await Anime.deleteOne({ title: "Death Note" });
console.log("deleted:", d1.deletedCount);

// deleteMany → every match
const d2 = await Anime.deleteMany({ rating: { $lt: 9 } });
console.log("deleted", d2.deletedCount, "low-rated shows");

console.log("after:", await Anime.countDocuments());
console.log("remaining:", (await Anime.find()).map(a => a.title));

11 Wire it into Express (upgrade Week 11)

The controller barely changes — the methods just become async and read from the model:

let animeList = JSON.parse(
  fs.readFileSync(dataPath)
);

exports.index = (req, res) => {
  res.render("index", { anime: animeList });
};

const Anime = require("../models/Anime");

exports.index = async (req, res) => {
  const anime = await Anime.find();  // from DB
  res.render("index", { anime });
};

The model lives in its own file

const mongoose = require("mongoose");

const animeSchema = new mongoose.Schema({
  title:  { type: String, required: true },
  studio: String,
  rating: Number
});

module.exports = mongoose.model("Anime", animeSchema);

Routers — split your routes into feature files

const express = require("express");
const router = express.Router();          // ① create
const c = require("../controllers/animeController");

// define this feature's routes on the router
router.get("/", c.index);
router.get("/:id", c.details);
router.post("/add", c.create);
router.post("/:id/delete", c.remove);

module.exports = router;                   // ② export

const animeRoutes = require("./routes/anime");

// ③ attach: every route in that file is
// now prefixed with /anime
app.use("/anime", animeRoutes);

// so router.get("/:id") answers
//   GET /anime/42
// and router.post("/add") answers
//   POST /anime/add

Creating a view — res.render

When a controller calls res.render("index", { anime }), Express:

1. looks in the views/ folder for index.pug;
2. compiles it into HTML;
3. injects the data ({ anime }) into it;
4. sends the finished HTML to the browser.

The views are unchanged from Week 11 — only the data's source changed (a database, not an array). For user input, add a form and handle its submission in an Express route, exactly like the Add form in the Anime Collection app.

12 Test your API

GET  /anime        → 200  and a JSON array of documents
GET  /anime/BADID  → 404  (your "not found" handler)
POST /anime        → 201  and the new document (with its _id)
DELETE /anime/1    → 200  and { deletedCount: 1 }

13 Key takeaways

1. A DBMS manages your data; MongoDB is a NoSQL document database — JSON-like, flexible, no rigid tables.
2. Hierarchy: database → collection → document (≈ database → table → row). Every document gets an _id.
3. Atlas hosts MongoDB in the cloud (free 512 MB) and hands you a connection string.
4. Mongoose (an ODM) connects with mongoose.connect() and models data with a Schema → Model.
5. CRUD: create/save · find/findOne/findById · updateOne/updateMany · deleteOne/deleteMany.
6. Filters are objects; operators ($gte, $lt, $in, $regex, $inc) go inside a field. Every method returns a Promise — so await it.
7. In Express, keep a model file, read/write it from async controllers, and render the same Pug views. Data source changes; everything else stays.

14 Self-check quiz

No grades, instant feedback. Twelve questions — the last five really dig into queries & CRUD. Can you get them all?

Deeper dive — queries & CRUD:

15 Reading & cheat sheet

Grab the Mongoose cheat sheet

🍃 Mongoose & MongoDB CRUD

Download Open / print

• Mongoose documentation
• MongoDB Atlas — getting started
• MongoDB — query documents (operators)