Defining schemas and models in Express

Introduction

We use schemas and models to organize and control how data is saved and used in a database. It helps keep data clean and easy to work with.

When you want to save user information like names and emails in a database.

When you need to keep track of products in an online store with details like price and description.

When you want to make sure data follows certain rules before saving it.

When you want to easily find, update, or delete data in your app.

Syntax

Express

const mongoose = require('mongoose');

const schemaName = new mongoose.Schema({
  field1: { type: String, required: true },
  field2: String
  // more fields
});

const ModelName = mongoose.model('ModelName', schemaName);

A schema defines the shape and rules for your data.

A model is a tool to work with that data in the database.

Examples

This example creates a user schema with name, email, and age fields. Name and email are required.

Express

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

const User = mongoose.model('User', userSchema);

This example defines a product with title, price (required), and inStock status.

Express

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

const Product = mongoose.model('Product', productSchema);

Sample Program

This program connects to a MongoDB database, defines a book schema and model, saves a new book, then finds and prints it.

Express

const mongoose = require('mongoose');

async function run() {
  await mongoose.connect('mongodb://localhost:27017/testdb');

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

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

  const newBook = new Book({ title: 'Learn Express', author: 'Jane Doe', pages: 150 });
  await newBook.save();

  const foundBook = await Book.findOne({ title: 'Learn Express' });
  console.log(foundBook);

  await mongoose.connection.close();
}

run();

Important Notes

Always close the database connection when done to avoid issues.

Use required: true to make sure important data is always provided.

Models let you easily add, find, update, or delete data in your app.

Summary

Schemas define how your data looks and what rules it follows.

Models let you work with that data in the database.

Using schemas and models helps keep your app's data organized and reliable.

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