MongoDB - Defining Schemas and Models

Defining Schemas and Models in MongoDB

Introduction

MongoDB is a NoSQL database that stores data in a flexible, JSON-like format. Unlike relational databases that use rigid schemas, MongoDB allows you to store documents of varying structures within the same collection. While this flexibility is powerful, it can lead to data inconsistencies. Mongoose, an ODM (Object Data Modeling) library for Node.js, addresses this issue by introducing schemas and models. These tools bring structure and validation to your data while working with MongoDB.

This document provides an in-depth guide to defining schemas and models using Mongoose. We will cover concepts, syntax, best practices, and real-world examples to help you understand and apply them effectively.

What is a Schema?

A schema in Mongoose defines the structure and rules for a document in a MongoDB collection. It acts like a blueprint for how your data should look, including field names, data types, default values, required fields, and custom validations.

Creating a Schema

You can create a schema using the mongoose.Schema constructor. Here's a basic example:

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

const userSchema = new Schema({
    name: String,
    age: Number,
    email: String
});

Schema Types

Mongoose supports a variety of schema types that map directly to native JavaScript types:

• String
• Number
• Date
• Buffer
• Boolean
• Mixed
• ObjectId
• Array
• Decimal128
• Map

Example with Multiple Types

const productSchema = new Schema({
    name: String,
    price: Number,
    isAvailable: Boolean,
    tags: [String],
    metadata: {
        weight: Number,
        manufacturer: String
    }
});

Adding Validation Rules

1. Required Fields

You can make a field required by setting required: true.

const userSchema = new Schema({
    username: {
        type: String,
        required: true
    }
});

2. Custom Error Messages

const userSchema = new Schema({
    email: {
        type: String,
        required: [true, 'User email is required']
    }
});

3. String Validation

const userSchema = new Schema({
    username: {
        type: String,
        minlength: 4,
        maxlength: 12,
        match: /^[a-zA-Z0-9]+$/
    }
});

4. Number Validation

const ratingSchema = new Schema({
    score: {
        type: Number,
        min: 0,
        max: 5
    }
});

Default Values

You can assign default values to fields that will be used if no value is provided.

const postSchema = new Schema({
    title: String,
    createdAt: {
        type: Date,
        default: Date.now
    }
});

Nested Objects and Subdocuments

You can define nested schemas to structure documents more effectively.

const addressSchema = new Schema({
    street: String,
    city: String,
    zipCode: String
});

const userSchema = new Schema({
    name: String,
    address: addressSchema
});

Arrays in Schemas

Arrays can be used to store multiple values of a certain type.

const blogSchema = new Schema({
    title: String,
    tags: [String],
    comments: [{
        body: String,
        date: Date
    }]
});

Enums and Custom Validators

1. Enums

const userSchema = new Schema({
    role: {
        type: String,
        enum: ['user', 'admin', 'moderator']
    }
});

2. Custom Validator

const productSchema = new Schema({
    price: {
        type: Number,
        validate: {
            validator: function(v) {
                return v > 0;
            },
            message: props => `${props.value} is not a positive number!`
        }
    }
});

What is a Model?

A model in Mongoose is a constructor compiled from a schema. An instance of a model is called a document. Models are responsible for creating and reading documents from the underlying MongoDB database.

Defining a Model

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

Creating Documents

const newUser = new User({
    name: 'John Doe',
    email: 'john@example.com',
    age: 30
});

newUser.save()
    .then(user => console.log(user))
    .catch(err => console.error(err));

Querying the Model

User.find({ age: { $gt: 18 } })
    .then(users => console.log(users));

Schema Methods

Schema methods allow you to define custom functions that can be called on document instances.

userSchema.methods.sayHello = function() {
    return `Hello, my name is ${this.name}`;
};

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

const user = new User({ name: 'Mike' });
console.log(user.sayHello());

Static Methods

Statics are functions that are called on the model itself.

userSchema.statics.findByEmail = function(email) {
    return this.findOne({ email });
};

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

User.findByEmail('test@example.com')
    .then(user => console.log(user));

Virtual Properties

Virtuals are document properties that are not stored in MongoDB but computed on the fly.

userSchema.virtual('fullName')
    .get(function() {
        return `${this.firstName} ${this.lastName}`;
    });

Indexes

Indexes improve the performance of read operations.

userSchema.index({ email: 1 }, { unique: true });

Middleware (Hooks)

Middleware are functions that run during different phases of a model’s lifecycle.

Pre Middleware

userSchema.pre('save', function(next) {
    console.log('About to save user...');
    next();
});

Post Middleware

userSchema.post('save', function(doc) {
    console.log(`${doc.name} was saved.`);
});

Discriminators

Discriminators allow you to create multiple models from the same schema with slight variations.

const options = { discriminatorKey: 'kind' };
const eventSchema = new Schema({ time: Date }, options);

const Event = mongoose.model('Event', eventSchema);

const ClickedLink = Event.discriminator('ClickedLink',
  new Schema({ url: String }, options));

Populating References

References allow you to store ObjectId references to other documents and populate them as needed.

const commentSchema = new Schema({
    user: {
        type: mongoose.Schema.Types.ObjectId,
        ref: 'User'
    },
    text: String
});

Comment.find()
    .populate('user')
    .exec()
    .then(comments => console.log(comments));