MongoDB - Defining Schemas and Models

Defining Schemas and Models in MongoDB 

Introduction to MongoDB Schemas and Models

MongoDB is a powerful NoSQL database that stores data in flexible, JSON-like documents. Unlike traditional relational databases, MongoDB does not enforce a strict schema by default. However, when building scalable and maintainable applications, defining schemas and models becomes essential. This is especially true when using libraries like Mongoose in Node.js applications.

In this detailed guide, we will explore how to define schemas and models in MongoDB using Mongoose, understand their importance, and learn best practices. 

What is a Schema in MongoDB?

A schema defines the structure of documents within a MongoDB collection. It specifies the fields, data types, default values, validation rules, and relationships between data. While MongoDB itself is schema-less, using schemas ensures consistency and improves data integrity.

Key Features of MongoDB Schema

• Defines structure of documents
• Specifies data types
• Supports validation rules
• Allows default values
• Enables indexing and constraints

What is a Model in MongoDB?

A model is a wrapper around a schema that provides an interface for interacting with a MongoDB collection. It allows developers to perform CRUD operations (Create, Read, Update, Delete) easily.

Key Features of Models

• Connect schema to a MongoDB collection
• Provides methods for database operations
• Acts as a bridge between application and database

Introduction to Mongoose

Mongoose is an Object Data Modeling (ODM) library for MongoDB and Node.js. It simplifies schema definition and provides powerful tools for validation and data manipulation.

Installing Mongoose

npm install mongoose

Connecting to MongoDB

const mongoose = require('mongoose');

mongoose.connect('mongodb://localhost:27017/mydatabase', {
  useNewUrlParser: true,
  useUnifiedTopology: true
})
.then(() => console.log("Connected to MongoDB"))
.catch(err => console.log(err));

Defining a Basic Schema

Schemas are defined using the Mongoose Schema class. Each field is assigned a data type and optional configurations.

const mongoose = require('mongoose');

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

Explanation

• name: String type
• age: Number type
• email: String type

Creating a Model from Schema

Once a schema is defined, a model can be created using mongoose.model().

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

This creates a collection named "users" in MongoDB.

Schema Data Types

Mongoose supports various data types:

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

Example

const productSchema = new mongoose.Schema({
  name: String,
  price: Number,
  inStock: Boolean,
  createdAt: Date
});

Schema Validation

Validation ensures that data stored in MongoDB meets certain criteria.

Required Fields

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

Custom Validation

const userSchema = new mongoose.Schema({
  age: {
    type: Number,
    validate: {
      validator: function(v) {
        return v >= 18;
      },
      message: "Age must be at least 18"
    }
  }
});

Default Values

Default values are assigned when no value is provided.

const userSchema = new mongoose.Schema({
  role: { type: String, default: 'user' }
});

Schema Methods

Methods can be defined inside schemas for custom logic.

userSchema.methods.getInfo = function() {
  return this.name + " - " + this.email;
};

Schema Static Methods

Static methods are defined on the model itself.

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

Middleware (Hooks)

Middleware functions are executed before or after certain events.

userSchema.pre('save', function(next) {
  console.log("Before saving user");
  next();
});

Indexes in Schema

Indexes improve query performance.

userSchema.index({ email: 1 });

Relationships in MongoDB

MongoDB supports relationships using references.

Example: Referencing Another Collection

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

Embedded Documents

Instead of references, documents can be embedded.

const blogSchema = new mongoose.Schema({
  title: String,
  comments: [
    {
      text: String,
      date: Date
    }
  ]
});

Schema Options

Schema options provide additional configuration.

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

Virtual Properties

Virtuals are computed properties not stored in MongoDB.

userSchema.virtual('fullInfo').get(function() {
  return this.name + " (" + this.email + ")";
});

Discriminators (Inheritance)

Discriminators allow schema inheritance.

const baseSchema = new mongoose.Schema({
  name: String
});

const Base = mongoose.model('Base', baseSchema);

const Child = Base.discriminator('Child', new mongoose.Schema({
  age: Number
}));

Defining schemas and models in MongoDB is a critical step in building robust applications. While MongoDB is schema-less, using tools like Mongoose ensures structured data, validation, and maintainability. By following best practices and understanding schema design, developers can build scalable and efficient applications.