Defining schemas and models in Express - Mini Project: Build & Apply

Defining Schemas and Models in Express with Mongoose

📖 Scenario: You are building a simple Express app to manage a list of books in a library. Each book has a title, author, and number of pages.

🎯 Goal: Create a Mongoose schema and model for the books collection to store book details in MongoDB.

📋 What You'll Learn

Create a Mongoose schema named bookSchema with fields title, author, and pages

Add a model named Book using the bookSchema

Use correct Mongoose types: String for title and author, Number for pages

Export the Book model

💡 Why This Matters

🌍 Real World

Defining schemas and models is essential for structuring data in MongoDB when building backend applications with Express and Mongoose.

💼 Career

Backend developers often create schemas and models to ensure data consistency and to interact with databases efficiently.

1

Set up Mongoose import and connection

Write the code to import mongoose and connect to a MongoDB database at mongodb://localhost:27017/library.

Express

// Import mongoose and connect to MongoDB
// Your code here

Hint

Use require('mongoose') to import mongoose. Use mongoose.connect() with the given URL.

2

Create the bookSchema with fields

Create a Mongoose schema called bookSchema with fields: title and author as String, and pages as Number.

Express

const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost:27017/library');

// Define bookSchema with title, author, and pages
// Your code here

Hint

Use new mongoose.Schema({ ... }) and define each field with its type.

3

Create the Book model from bookSchema

Create a Mongoose model named Book using mongoose.model with the schema bookSchema.

Express

const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost:27017/library');

const bookSchema = new mongoose.Schema({
  title: String,
  author: String,
  pages: Number
});

// Create Book model from bookSchema
// Your code here

Hint

Use mongoose.model('Book', bookSchema) to create the model.

4

Export the Book model

Export the Book model using module.exports.

Express

const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost:27017/library');

const bookSchema = new mongoose.Schema({
  title: String,
  author: String,
  pages: Number
});

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

// Export the Book model
// Your code here

Hint

Use module.exports = Book to export the model for use in other files.

Practice

1. What is the main purpose of defining a schema in an Express app using Mongoose?

easy

A. To specify the structure and rules for the data stored in the database

B. To create the server routes for handling requests

C. To style the frontend components

D. To manage user authentication sessions

Solution

1. Step 1: Understand what a schema does

   A schema defines the shape and rules of data in the database, like what fields exist and their types.

2. Step 2: Differentiate from other app parts

   Server routes handle requests, styling is frontend, and sessions manage users, none define data structure.

3. Final Answer:

   To specify the structure and rules for the data stored in the database -> Option A

4. Quick Check:

   Schema = data structure rules [OK]

Hint: Schemas define data shape and rules, not routes or styles [OK]

Common Mistakes:

• Confusing schema with routing logic
• Thinking schema handles frontend styling
• Mixing schema with session management

2. Which of the following is the correct way to define a Mongoose schema for a user with a required name field of type String?

easy

A. const userSchema = new mongoose.Schema({ name: String, required: true });

B. const userSchema = new mongoose.Schema({ name: { type: String, required: true } });

C. const userSchema = mongoose.Schema({ name: String, required: true });

D. const userSchema = new Schema({ name: String, required: true });

Solution

1. Step 1: Check correct schema syntax

   Mongoose schema requires fields as objects with type and options, e.g., { name: { type: String, required: true } }.

2. Step 2: Identify errors in other options

   const userSchema = new mongoose.Schema({ name: String, required: true }); puts required outside the field object, C misses 'new' keyword, D misses 'mongoose.' prefix.

3. Final Answer:

   const userSchema = new mongoose.Schema({ name: { type: String, required: true } }); -> Option B

4. Quick Check:

   Field options go inside an object with type [OK]

Hint: Use { field: { type: Type, required: true } } syntax [OK]

Common Mistakes:

• Placing 'required' outside the field object
• Forgetting 'new' keyword before mongoose.Schema
• Omitting 'mongoose.' prefix for Schema

3. Given the following code, what will be the output when creating a new user without the 'age' field?

const userSchema = new mongoose.Schema({ name: { type: String, required: true }, age: Number });
const User = mongoose.model('User', userSchema);
const newUser = new User({ name: 'Alice' });
console.log(newUser.age);

medium

A. 0

B. null

C. undefined

D. Throws an error because age is missing

Solution

1. Step 1: Understand default values in schema

   Since 'age' is defined as Number but not required and no default is set, missing 'age' means its value is undefined.

2. Step 2: Check behavior when logging missing field

   Logging newUser.age prints undefined, no error occurs because 'age' is optional.

3. Final Answer:

   undefined -> Option C

4. Quick Check:

   Optional fields without default = undefined [OK]

Hint: Missing optional fields default to undefined, not error [OK]

Common Mistakes:

• Assuming missing number fields default to 0
• Expecting null instead of undefined
• Thinking missing optional fields cause errors

4. Identify the error in this schema definition:

const productSchema = new mongoose.Schema({
  title: { type: String, required: true },
  price: { type: Number, required: 'Price is required' }
});

medium

A. Missing comma after the title field definition

B. Price field type should be String, not Number

C. Schema must use 'new Schema' without 'mongoose.' prefix

D. The required field should be a boolean, not a string message

Solution

1. Step 1: Check 'required' field usage

   In Mongoose, 'required' can be a boolean or an array with message, but a string alone is invalid.

2. Step 2: Validate other syntax parts

   Commas are correct, 'mongoose.Schema' is valid, and price as Number is appropriate.

3. Final Answer:

   The required field should be a boolean, not a string message -> Option D

4. Quick Check:

   'required' must be boolean or [boolean, message] [OK]

Hint: Use true or [true, 'msg'] for required, not just string [OK]

Common Mistakes:

• Using string alone for 'required' option
• Confusing schema constructor syntax
• Wrong data type for price field

5. You want to create a Mongoose model for a blog post with a title (required string), content (string), and tags (array of strings). Which schema definition correctly models this?

hard

A. const postSchema = new mongoose.Schema({ title: { type: String, required: true }, content: String, tags: [String] });

B. const postSchema = new mongoose.Schema({ title: String, required: true, content: String, tags: Array });

C. const postSchema = new mongoose.Schema({ title: { type: String }, content: String, tags: { type: [String], required: true } });

D. const postSchema = new mongoose.Schema({ title: { type: String, required: true }, content: String, tags: { type: String[] } });

Solution

1. Step 1: Check required title field syntax

   const postSchema = new mongoose.Schema({ title: { type: String, required: true }, content: String, tags: [String] }); correctly sets title as { type: String, required: true }.

2. Step 2: Verify tags as array of strings

   const postSchema = new mongoose.Schema({ title: { type: String, required: true }, content: String, tags: [String] }); uses tags: [String], which is the correct way to define an array of strings in Mongoose.

3. Step 3: Identify errors in other options

   A uses invalid { type: String[] } syntax for tags; B places 'required' outside title field object and uses invalid tags: Array; C makes tags required incorrectly.

4. Final Answer:

   const postSchema = new mongoose.Schema({ title: { type: String, required: true }, content: String, tags: [String] }); -> Option A

5. Quick Check:

   Array of strings = [String], required inside field object [OK]

Hint: Use [String] for string arrays and required inside field object [OK]

Common Mistakes:

• Placing 'required' outside field object
• Using 'String[]' instead of [String]
• Setting array type incorrectly