Mongoose Schemas: Defining Required Fields and Data Types

1. What is a Mongoose Schema?

Before writing any code, it's important to understand the role of a schema. In Mongoose, everything starts with a schema. It maps directly to a MongoDB collection and defines the shape of the documents within that collection.

The video below gives a quick, clear explanation of how schemas and models work together.

2. Implementing Your First Schema

For your exam project, you'll be working with a collection of "items." Let's create the schema for these items. Following the project structure we've established, this will live in a models directory.

Action: Create the Item Model File

1. Inside your src/ directory, create a new folder named models.
2. Inside src/models, create a new file named Item.js.

This file will contain the blueprint for your Item documents.

3. Defining the Schema Structure

Now, let's write the code to define the itemSchema. A schema is an object that describes your data fields. For each field, you specify its type and any validation rules.

The basic data types you'll need for the exam are:

• String
• Number
• Boolean
• Date

You'll also use the required option to enforce that a field must have a value.

Action: Add the Schema Code to Item.js

Open src/models/Item.js and add the following code. We are defining a schema for an item that has a name, a quantity, a status, and a creation date.

const mongoose = require('mongoose');
const Schema = mongoose.Schema;

// Define the schema for our 'Item' collection
const itemSchema = new Schema({
    name: {
        type: String,
        required: true // This field must be provided
    },
    quantity: {
        type: Number,
        required: true,
        default: 1 // If not provided, defaults to 1
    },
    isPriority: {
        type: Boolean,
        default: false // If not provided, defaults to false
    },
    createdAt: {
        type: Date,
        default: Date.now // Sets the current date and time by default
    }
});

// The next step is to create and export the model, which we'll do in the next lesson.
// For now, this file only defines the schema structure.

Let's break down this code:

• We require mongoose.
• We create a new Schema.
• name: A String that is mandatory (required: true).
• quantity: A Number that is also required. We've also provided a default value.
• isPriority: A Boolean flag. If a value isn't provided when a new item is created, it will default to false.
• createdAt: A Date. The default: Date.now is a powerful feature that automatically sets the field to the current timestamp upon creation.

4. Advanced Schema Options

While the basic types cover most use cases for the exam, Mongoose offers more advanced options that you saw in the resources. The video below provides a more in-depth look at defining various data types and options like default values.

The key takeaway is that Mongoose schemas are not just about types; they are a central place to enforce your application's business logic and data rules.

Conclusion

You have now successfully defined the data structure for your API's primary resource. This schema is the foundation upon which all data creation, validation, and retrieval will be built.

Key Takeaways:

• A Mongoose Schema is a JavaScript object that defines the structure and validation rules for documents in a MongoDB collection.
• You define fields with specific data types like String, Number, Boolean, and Date.
• The required: true option makes a field mandatory, a critical validation for most APIs.
• The default option provides a fallback value if one isn't specified, which is useful for timestamps and status flags.

Your Item.js file currently defines the blueprint but doesn't yet provide a way to interact with the database. In the next lesson, you will use this schema to create a Mongoose Model, which is the tool you'll use to perform all CRUD (Create, Read, Update, Delete) operations.