Defining schemas and models in Express - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import Mongoose in an Express app.

Express

const mongoose = require('[1]');

Drag options to blanks, or click blank then click option'

Amongoose

Bexpress

Cbody-parser

Dcors

Attempts:

3 left

💡 Hint

Common Mistakes

Importing 'express' instead of 'mongoose'.

Using a package unrelated to schemas like 'cors'.

You need to import mongoose to define schemas and models.

2fill in blank

medium

Complete the code to create a new Mongoose schema.

Express

const userSchema = new mongoose.[1]({ name: String, age: Number });

Drag options to blanks, or click blank then click option'

ASchema

BCollection

CDocument

DModel

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'Model' instead of 'Schema' to define structure.

Confusing 'Document' or 'Collection' with schema.

The Schema class defines the structure of documents in a collection.

3fill in blank

hard

Fix the error in the code to create a model from a schema.

Express

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

Drag options to blanks, or click blank then click option'

AUserSchema

Busers

CuserSchema

DUser

Attempts:

3 left

💡 Hint

Common Mistakes

Using lowercase or plural names like 'users'.

Passing the schema variable name instead of model name.

The first argument to mongoose.model is the singular model name, capitalized.

4fill in blank

hard

Fill both blanks to define a schema with a required string field and create a model.

Express

const productSchema = new mongoose.[1]({ title: { type: String, [2]: true } });
const Product = mongoose.model('Product', productSchema);

Drag options to blanks, or click blank then click option'

ASchema

Brequired

Cunique

Ddefault

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'unique' instead of 'required' for mandatory fields.

Confusing 'default' with 'required'.

Use Schema to define the schema and required: true to make the field mandatory.

5fill in blank

hard

Fill all three blanks to define a schema with a default number field, create a model, and export it.

Express

const orderSchema = new mongoose.[1]({ quantity: { type: Number, [2]: 1 } });
const Order = mongoose.model('[3]', orderSchema);
module.exports = Order;

Drag options to blanks, or click blank then click option'

ASchema

Bdefault

COrder

DModel

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'Model' instead of 'Schema' for the first blank.

Using 'required' instead of 'default' for the second blank.

Using lowercase or plural model names.

Define the schema with Schema, set a default value with default, and name the model 'Order'.

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