Node.js: Mongoose ODM

Q: How is the performance of populate ?

populate is not an SQL JOIN; it essentially involves running additional queries and then merging the results. Performance is good when there are few related documents; however, a large number of different related documents can cause an N+1 query problem. For high-frequency scenarios, consider embedding documents, manual $lookup , or caching.

Q: How do I handle validation errors?

Mongoose throws ValidationError when validation fails, and the errors object contains error details for each field. You can use Object.values(err.errors).map(e => e.message) to extract all messages and, in conjunction with Express error-handling middleware, return a uniform 400 status code.

Q: What does this refer to in the pre-save hook?

this refers to the Document instance that is about to be saved. Note: Using arrow functions will cause the this binding to be lost; the hook function must be a regular function. this.isModified('field') can be used to determine whether a field has been modified.

Q: Can I add fields after the schema has been defined?

Yes, you can use schema.add({ newField: String }) to add them dynamically. However, compiled models will not be updated automatically; you’ll need to recompile them or use the schema.plugin() extension. We recommend planning the field structure carefully at the beginning of the project.

Last updated: 2026-08-26

Bob’s data validation code, written using the native MongoDB driver, was scattered across various routes—the registration endpoint checked email format, the publish-article endpoint validated title length, and the change-password endpoint verified that the new and old passwords were different. Every time a new field was added, he had to add a piece of if (!field) logic to the corresponding controller, resulting in the same email validation regex being repeated across three routes. After switching to Mongoose, Bob centralized all validation rules in the schema definition—defining them once and applying them everywhere—which reduced the controller code by 60%.

You'll learn:

Relationships and Usage of the Three-Tier Architecture: Schema, Model, and Document
Declarative definitions of field types and validators (required / enum / min / max / match)
Calculated field patterns for the "virtual" attribute
Intercepting the lifecycle of pre/post hooks
Chained calls in the query builder
Indexes (index / unique) and Performance Optimization
Custom Extensions for Instance Methods and Static Methods
Use populate to implement join queries for cross-document references

1. Mongoose Core Architecture

Mongoose is an Object-Document Mapping (ODM) library for MongoDB that provides a schema-driven data modeling layer on top of the native driver. The core concept is organized into three layers: schema defines the structure → the model is compiled into a constructor → a document is an instance of the model.

▶ Example: (1) Schema → Model → Document Relationship

graph LR
    A["Schema<br/>Defining Structures and Verification"] -->|mongoose.model() Compilation| B["Model<br/>Constructor + Query Interface"]
    B -->|new Model() Instantiation| C["Document<br/>Examples of Verified Documents"]
    C -->|.save() Persistence| D[("MongoDB<br/>Gathering")]
    B -->|Model.find() etc.| D
    D -->|Back| C

(2) Installation and Connection

▶ Example: Installing Mongoose and Connecting to MongoDB

BASH

npm install mongoose

JAVASCRIPT

const mongoose = require('mongoose');

mongoose.connect('mongodb://localhost:27017/myapp')
  .then(() => console.log('MongoDB connected'))
  .catch(err => console.error('Connection error:', err));

(3) Minimal Schema and Model

▶ Example: Defining a User Schema and Creating a Model

JAVASCRIPT

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

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

▶ Try it Yourself

Concept	Role	Analogy
Schema	Blueprint / Structural Definition	Architectural Drawings
Model	Constructor + Database Operation Interface	Construction Crew
Document	Verified document examples	Completed houses

2. Schema Field Types

Mongoose provides rich type mappings for each field, far exceeding the lack of type constraints in the native driver.

(1) Quick Reference for Field Types

Mongoose Type	Corresponding JS Type	Example	Description
`String`	String	`name: String`	Auto-trim (requires configuration)
`Number`	Number	`age: Number`	Supports min / max
`Boolean`	Boolean	`active: Boolean`	Automatically converts to 0/1/"true"
`Date`	Date	`createdAt: Date`	Built-in Date methods
`ObjectId`	ObjectId	`author: mongoose.Schema.Types.ObjectId`	References to Other Documents
`Array`	Array	`tags: [String]`	Array of child documents or array of types
`Mixed`	Object	`meta: mongoose.Schema.Types.Mixed`	Any type, no validation
`Buffer`	Buffer	`avatar: Buffer`	Binary data
`Map`	Map	`prefs: { type: Map, of: String }`	ES6 Map structure
`Decimal128`	Decimal128	`price: mongoose.Schema.Types.Decimal128`	High-precision decimal

(2) The complete syntax for field definitions

▶ Example: Detailed Explanation of Field Options

JAVASCRIPT

const productSchema = new mongoose.Schema({
  name: {
    type: String,
    required: [true, 'The product name cannot be left blank.'],
    trim: true,
    minlength: 2,
    maxlength: 100
  },
  price: {
    type: Number,
    required: true,
    min: [0, 'Prices cannot be negative.'],
    default: 0
  },
  category: {
    type: String,
    enum: ['electronics', 'books', 'clothing', 'food'],
    lowercase: true
  },
  tags: [String],
  metadata: {
    type: mongoose.Schema.Types.Mixed,
    default: {}
  }
});

▶ Try it Yourself

3. Validator

Validation is at the heart of Mongoose—it frees data validation from controllers and centralizes it in schema declarations.

(1) Validator Quick Reference

Validator	Applicable Type	Description	Example
`required`	All	Required fields	`required: [true, 'Cannot be empty']`
`enum`	String	Enum value constraint	`enum: ['A', 'B', 'C']`
`min`	Number / Date	Minimum value	`min: 0`
`max`	Number / Date	Maximum value	`max: 150`
`minlength`	String	Minimum Length	`minlength: 6`
`maxlength`	String	Maximum Length	`maxlength: 200`
`match`	String	Regex match	`match: [/^\S+@\S+\.\S+$/, 'Invalid email format']`
`validate`	All	Custom Validation Functions	`validate: v => v > 0`

(2) Custom Validators

▶ Example: Custom Validators and Error Messages

JAVASCRIPT

const userSchema = new mongoose.Schema({
  password: {
    type: String,
    required: true,
    validate: {
      validator: function(v) {
        return /^(?=.*[A-Z])(?=.*\d).{8,}$/.test(v);
      },
      message: props => `${props.value} Password does not meet requirements: at least 8 characters, includes uppercase and digits`
    }
  },
  phone: {
    type: String,
    validate: {
      validator: function(v) {
        return /^1[3-9]\d{9}$/.test(v);
      },
      message: 'The phone number format is incorrect'
    }
  }
});

▶ Try it Yourself

(3) Verify the trigger timing

Verification is automatically triggered at the following times: new Model().save() and Model.create(). You can trigger it manually using the validate() method. updateOne() / updateMany(), etc., do not automatically trigger verification; you must configure the runValidators: true option.

▶ Example: Enabling validation for update operations

JAVASCRIPT

User.updateOne(
  { email: 'bob@test.com' },
  { age: -5 },
  { runValidators: true }
);

▶ Try it Yourself

4. Virtual Properties

Virtual attributes are not stored in the database; they are calculated dynamically only during queries, making them suitable for derived fields.

(1) Definition and Usage

▶ Example: "User Full Name" virtual attribute

JAVASCRIPT

const userSchema = new mongoose.Schema({
  firstName: String,
  lastName: String,
  email: String
});

userSchema.virtual('fullName')
  .get(function() {
    return `${this.firstName} ${this.lastName}`;
  })
  .set(function(v) {
    const parts = v.split(' ');
    this.firstName = parts[0];
    this.lastName = parts[1] || '';
  });

const User = mongoose.model('User', userSchema);
const user = new User({ firstName: 'Bob', lastName: 'Smith' });
console.log(user.fullName);

▶ Try it Yourself

TEXT 📖 Display only

Bob Smith

(2) `virtual` and `toJSON`

Virtual attributes are not included by default in the toJSON() and toObject() outputs. They must be explicitly enabled in the Schema options:

JAVASCRIPT

const userSchema = new mongoose.Schema({
  firstName: String,
  lastName: String
}, {
  toJSON: { virtuals: true },
  toObject: { virtuals: true }
});

5. Hooks (Middleware)

Hooks (Middleware) are automatically executed at specific stages of a document's lifecycle and are used for data preprocessing, logging, cascading operations, and more.

(1) Hook Types and Triggering Conditions

Hook Type	Triggering Conditions	Common Uses
`pre('save')`	Before saving	Password hashing, data formatting, update timestamp
`post('save')`	After saving	Send notifications, log entries
`pre('remove')`	Before Deletion	Cascade Deletion of Associated Documents
`post('remove')`	After deletion	Clean up resources and logs
`pre('find')`	Before query	Default filter criteria (e.g., soft delete)
`post('find')`	After query	Data anonymization
`pre('updateOne')`	Before Update	Update Timestamp
`post('aggregate')`	After aggregation	Logging

(2) for Hooks

▶ Example: Automatically hash passwords before saving

JAVASCRIPT

const bcrypt = require('bcrypt');

userSchema.pre('save', async function(next) {
  if (!this.isModified('password')) return next();
  this.password = await bcrypt.hash(this.password, 10);
  next();
});

▶ Try it Yourself

(3) Post Hooks

▶ Example: Send a welcome email after saving

JAVASCRIPT

userSchema.post('save', function(doc, next) {
  console.log(`User ${doc.email} Saved`);
  next();
});

▶ Try it Yourself

(4) Query Hooks

▶ Example: Automatically filter out deleted documents during a query

JAVASCRIPT

userSchema.pre('find', function() {
  this.where({ deletedAt: null });
});

▶ Try it Yourself

6. Query Builder

Mongoose's query builder supports chained calls, which are more intuitive than the object parameters used by the native driver.

(1) Chain Query Method

▶ Example: Chained Query Builder Calls

JAVASCRIPT

const users = await User.find()
  .where('age').gte(18).lte(65)
  .where('role').equals('admin')
  .sort({ createdAt: -1 })
  .select('name email age')
  .limit(10)
  .skip(0);

console.log(users);

▶ Try it Yourself

(2) Comparison of Common Query Methods

Native Driver Implementation	Mongoose Query Builder	Description
`db.users.find({ age: { $gte: 18 } })`	`User.find().where('age').gte(18)`	Condition Search
`db.users.find().sort({ name: 1 })`	`User.find().sort({ name: 1 })`	Sort
`db.users.find().limit(10)`	`User.find().limit(10)`	Number of entries limited to
`db.users.find().skip(20)`	`User.find().skip(20)`	Skip
`db.users.find({}, { name: 1 })`	`User.find().select('name')`	Field Filter

(3) Encapsulation of Paginated Queries

▶ Example: Auxiliary Functions for Paginated Queries

JAVASCRIPT

async function paginate(Model, filter = {}, page = 1, limit = 10) {
  const skip = (page - 1) * limit;
  const [docs, total] = await Promise.all([
    Model.find(filter).skip(skip).limit(limit).sort({ createdAt: -1 }),
    Model.countDocuments(filter)
  ]);
  return {
    data: docs,
    total,
    page,
    totalPages: Math.ceil(total / limit)
  };
}

const result = await paginate(User, { role: 'user' }, 2, 10);

▶ Try it Yourself

7. Index

Indexes are key to database query performance. Mongoose supports declarative index definition in the schema.

(1) Single-Column Indexes and Composite Indexes

▶ Example: Defining an Index in the Schema

JAVASCRIPT

const userSchema = new mongoose.Schema({
  email: {
    type: String,
    required: true,
    unique: true
  },
  username: {
    type: String,
    index: true
  },
  region: String,
  status: String
});

userSchema.index({ region: 1, status: 1 });

▶ Try it Yourself

Index Type	Definition	Description
Unique Index	`unique: true`	Field values must be unique
Regular Index	`index: true`	Accelerated Query
Composite Index	`schema.index({ a: 1, b: -1 })`	Multi-field Composite Index
Text Index	`schema.index({ title: 'text' })`	Full-Text Search

▶ Example: (2) Automatic Index Creation in the Development Environment

JAVASCRIPT

mongoose.connect(uri, { autoIndex: true });

▶ Try it Yourself

In a production environment, it is recommended to disable autoIndex and manually create indexes using the migration script to avoid startup delays.

8. Instance Methods and Static Methods

Mongoose allows you to extend a schema with custom methods, which are divided into two categories: instance methods and static methods.

(1) Instance Methods

Instance methods operate on a single document; use this to access the current document.

▶ Example: Password Comparison Example Method

JAVASCRIPT

userSchema.methods.comparePassword = function(candidate) {
  return bcrypt.compare(candidate, this.password);
};

const user = await User.findOne({ email: 'bob@test.com' });
const isMatch = await user.comparePassword('mypassword');

▶ Try it Yourself

(2) Static Methods

Static methods are defined on the Model and do not depend on document instances, making them suitable for query support.

▶ Example: Finding static methods by role

JAVASCRIPT

userSchema.statics.findByRole = function(role) {
  return this.find({ role }).sort({ createdAt: -1 });
};

const admins = await User.findByRole('admin');

▶ Try it Yourself

Type	Definition	Invocation	this Reference
Instance Methods	`schema.methods.xxx = function`	`doc.xxx()`	Document Instance
Static Method	`schema.statics.xxx = function`	`Model.xxx()`	Model

9. Populate Joined Queries

Mongoose's populate() implements the resolution of references between MongoDB documents, similar to a SQL JOIN.

(1) Reference Definitions and Joins

▶ Example: Articles Associated with Authors

JAVASCRIPT

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

const Post = mongoose.model('Post', postSchema);

const posts = await Post.find().populate('author', 'firstName lastName email');

▶ Try it Yourself

(2) Multi-level populate and conditional filtering

▶ Example: Multi-level Joins and Filters

JAVASCRIPT

const commentSchema = new mongoose.Schema({
  content: String,
  author: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
  post: { type: mongoose.Schema.Types.ObjectId, ref: 'Post' }
});

const Comment = mongoose.model('Comment', commentSchema);

const comments = await Comment.find()
  .populate('author', 'firstName lastName')
  .populate({
    path: 'post',
    select: 'title content',
    match: { status: 'published' }
  });

▶ Try it Yourself

(3) Performance Considerations for `populate`

populate() Essentially, this involves issuing additional queries and then merging the results; it is not a true JOIN. The N+1 problem still persists—if 100 articles are associated with 100 different authors, it will trigger 101 queries. For scenarios with frequent associations, consider embedding documents or $lookup aggregation.

10. Comparison of Mongoose and the Native Driver

Dimension	Native MongoDB Driver	Mongoose ODM
Data Validation	Hand-coded if/else statements scattered throughout the controller	Schema-based declarative validation, centrally managed
Type Constraints	None; any field can store any value	Schema-enforced types; automatic conversion
Joined Queries	Manual `$lookup` Aggregation	`populate()` Done in One Line
Lifecycle Hooks	None	Pre/Post Hooks
Virtual Attribute	None	Virtual Dynamically Calculated Field
Index Management	Manual `createIndex()`	Schema Declaration + Automatic Creation
Query API	Object Parameters `find({ age: { $gte: 18 } })`	Chained Builder + Object Parameters
Learning Curve	Low; closely resembles MongoDB's native syntax	Medium; requires an understanding of schema, model, and document
Flexibility	High, full control	Medium, fields outside the schema are ignored by default
Performance	Slightly better, no intermediate layer	Slightly lower, overhead from validation and hooks

11. Comprehensive Example: User and Article Data Models

Combine schemas, validation, hooks, virtual attributes, instance methods, and join queries to form a complete data model system.

▶ Example: models/User.js

JAVASCRIPT 📖 Display only

const mongoose = require('mongoose');
const bcrypt = require('bcrypt');

const userSchema = new mongoose.Schema({
  firstName: {
    type: String,
    required: [true, 'The last name cannot be left blank.'],
    trim: true
  },
  lastName: {
    type: String,
    required: [true, 'The name cannot be empty'],
    trim: true
  },
  email: {
    type: String,
    required: [true, 'The email address cannot be left blank.'],
    unique: true,
    lowercase: true,
    match: [/^\S+@\S+\.\S+$/, 'The email address format is incorrect.']
  },
  password: {
    type: String,
    required: [true, 'The password cannot be empty.'],
    minlength: 8,
    validate: {
      validator: function(v) {
        return /^(?=.*[A-Z])(?=.*\d).{8,}$/.test(v);
      },
      message: 'Password must be at least 8 characters, must include uppercase and digits'
    }
  },
  role: {
    type: String,
    enum: ['user', 'admin'],
    default: 'user'
  },
  age: {
    type: Number,
    min: [0, 'Age cannot be a negative number.'],
    max: [150, 'Age must not exceed150']
  },
  createdAt: {
    type: Date,
    default: Date.now
  }
}, {
  toJSON: { virtuals: true },
  toObject: { virtuals: true }
});

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

userSchema.pre('save', async function(next) {
  if (!this.isModified('password')) return next();
  this.password = await bcrypt.hash(this.password, 10);
  next();
});

userSchema.methods.comparePassword = function(candidate) {
  return bcrypt.compare(candidate, this.password);
};

userSchema.statics.findByRole = function(role) {
  return this.find({ role }).sort({ createdAt: -1 });
};

module.exports = mongoose.model('User', userSchema);

64 logic lines (exceeds 40-line limit, display only)

▶ Example: models/Post.js

JAVASCRIPT 📖 Display only

const mongoose = require('mongoose');

const postSchema = new mongoose.Schema({
  title: {
    type: String,
    required: [true, 'The title cannot be left blank.'],
    trim: true,
    minlength: [2, 'Title must be at least2characters'],
    maxlength: [200, 'Most Titles200characters']
  },
  content: {
    type: String,
    required: [true, 'Content cannot be empty']
  },
  author: {
    type: mongoose.Schema.Types.ObjectId,
    ref: 'User',
    required: true
  },
  status: {
    type: String,
    enum: ['draft', 'published', 'archived'],
    default: 'draft'
  },
  tags: [{
    type: String,
    lowercase: true
  }],
  viewCount: {
    type: Number,
    default: 0,
    min: 0
  },
  createdAt: {
    type: Date,
    default: Date.now
  },
  updatedAt: {
    type: Date,
    default: Date.now
  }
});

postSchema.index({ status: 1, createdAt: -1 });
postSchema.index({ tags: 1 });

postSchema.virtual('excerpt').get(function() {
  return this.content.substring(0, 100) + '...';
});

postSchema.pre('save', function(next) {
  if (this.isModified('content')) {
    this.updatedAt = new Date();
  }
  next();
});

postSchema.post('remove', async function(doc) {
  await mongoose.model('Comment').deleteMany({ post: doc._id });
});

postSchema.statics.findPublished = function() {
  return this.find({ status: 'published' })
    .populate('author', 'firstName lastName email')
    .sort({ createdAt: -1 });
};

module.exports = mongoose.model('Post', postSchema);

61 logic lines (exceeds 40-line limit, display only)

▶ Example: Queries and Joins

JAVASCRIPT

const mongoose = require('mongoose');
const User = require('./models/User');
const Post = require('./models/Post');

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

  const user = await User.create({
    firstName: 'Bob',
    lastName: 'Smith',
    email: 'bob@example.com',
    password: 'Secure123',
    role: 'admin',
    age: 28
  });

  const post = await Post.create({
    title: 'Mongoose Getting Started Guide',
    content: 'Mongoose is MongoDB ODM library, providing schema-driven data modeling...',
    author: user._id,
    status: 'published',
    tags: ['mongodb', 'mongoose', 'nodejs']
  });

  const published = await Post.findPublished();
  console.log(published[0].excerpt);
  console.log(published[0].author.fullName);

  const match = await user.comparePassword('Secure123');
  console.log('Password match:', match);

  await mongoose.connection.close();
}

main();

▶ Try it Yourself

BASH

node app.js

TEXT 📖 Display only

Mongoose is MongoDB ODM library, providing schema-driven data modeling......
Bob Smith
Password match: true

❓ FAQ

Q How do I choose between Mongoose and the native driver?

A Choose the native driver for small projects or when you need maximum flexibility; choose Mongoose for medium to large projects, team collaboration, or when you need validation and hooks. You can also use both together—Mongoose supports accessing native collections via Model.collection.

Q What is the difference between a Schema and a Model?

A A Schema is a blueprint that defines field types, validation rules, and hooks; a Model is a constructor generated from a Schema that provides an interface for CRUD methods. A single Schema can generate only one Model.

Q Are virtual fields not stored in the database?

A Yes, virtual fields are calculated only in memory and are not written to MongoDB. If you need to persist them, use a regular field and the pre-save hook to calculate and assign the value. By default, virtual fields do not appear in the JSON output; you must set toJSON: { virtuals: true }.

Q How is the performance of populate?

A populate is not an SQL JOIN; it essentially involves running additional queries and then merging the results. Performance is good when there are few related documents; however, a large number of different related documents can cause an N+1 query problem. For high-frequency scenarios, consider embedding documents, manual $lookup, or caching.

Q How do I handle validation errors?

A Mongoose throws ValidationError when validation fails, and the errors object contains error details for each field. You can use Object.values(err.errors).map(e => e.message) to extract all messages and, in conjunction with Express error-handling middleware, return a uniform 400 status code.

Q What does this refer to in the pre-save hook?

A this refers to the Document instance that is about to be saved. Note: Using arrow functions will cause the this binding to be lost; the hook function must be a regular function. this.isModified('field') can be used to determine whether a field has been modified.

Q Can I add fields after the schema has been defined?

A Yes, you can use schema.add({ newField: String }) to add them dynamically. However, compiled models will not be updated automatically; you’ll need to recompile them or use the schema.plugin() extension. We recommend planning the field structure carefully at the beginning of the project.

📖 Summary

Key Concepts and Usage of the Mongoose Core Architecture
Core Concepts and Usage of Schema Field Types
Core Concepts and Usage of Validators
Core Concepts and Usage of Virtual Properties
Core Concepts and Usage of Hooks (Middleware)
Core Concepts and Usage of the Query Builder
Core Concepts and Usage of Indexes
Core Concepts and Usage of Instance Methods and Static Methods

📝 Exercises

Complete all the code examples in this lesson and make sure each one runs correctly.
Modify the comprehensive example and add your own extensions
Review the official documentation, identify 1–2 APIs not covered in this lesson, and write test code for them.
Reflection: How would you apply what you’ve learned in this lesson to a real-world project?
Try to combine what you’ve learned in this lesson with material from previous lessons to build a small project.

Web-Tutorial Tech Team

A team of developers maintaining programming tutorials. Each tutorial is written and reviewed by developers with expertise in that field. We work to keep our content accurate and reliable — if you spot an issue, please let us know.

About Us

Node.js: Mongoose ODM

1. Mongoose Core Architecture

▶ Example: (1) Schema → Model → Document Relationship

(2) Installation and Connection

▶ Example: Installing Mongoose and Connecting to MongoDB

(3) Minimal Schema and Model

▶ Example: Defining a User Schema and Creating a Model

2. Schema Field Types

(1) Quick Reference for Field Types

(2) The complete syntax for field definitions

▶ Example: Detailed Explanation of Field Options

3. Validator

(1) Validator Quick Reference

(2) Custom Validators

▶ Example: Custom Validators and Error Messages

(3) Verify the trigger timing

▶ Example: Enabling validation for update operations

4. Virtual Properties

(1) Definition and Usage

▶ Example: "User Full Name" virtual attribute

(2) virtual and toJSON

5. Hooks (Middleware)

(1) Hook Types and Triggering Conditions

(2) for Hooks

▶ Example: Automatically hash passwords before saving

(3) Post Hooks

▶ Example: Send a welcome email after saving

(4) Query Hooks

▶ Example: Automatically filter out deleted documents during a query

6. Query Builder

(1) Chain Query Method

▶ Example: Chained Query Builder Calls

(2) Comparison of Common Query Methods

(3) Encapsulation of Paginated Queries

▶ Example: Auxiliary Functions for Paginated Queries

7. Index

(1) Single-Column Indexes and Composite Indexes

▶ Example: Defining an Index in the Schema

▶ Example: (2) Automatic Index Creation in the Development Environment

8. Instance Methods and Static Methods

(1) Instance Methods

▶ Example: Password Comparison Example Method

(2) Static Methods

▶ Example: Finding static methods by role

9. Populate Joined Queries

(1) Reference Definitions and Joins

▶ Example: Articles Associated with Authors

(2) Multi-level populate and conditional filtering

▶ Example: Multi-level Joins and Filters

(3) Performance Considerations for populate

10. Comparison of Mongoose and the Native Driver

11. Comprehensive Example: User and Article Data Models

▶ Example: models/User.js

▶ Example: models/Post.js

▶ Example: Queries and Joins

❓ FAQ

📖 Summary

📝 Exercises

🙏 帮我们做得更好

(2) `virtual` and `toJSON`

(3) Performance Considerations for `populate`