How to use Mongoose in Node.js
Łukasz Holeczek
Follow Łukasz Holeczek on GitHub
Connect with Łukasz Holeczek on LinkedIn
Follow Łukasz Holeczek on X (Twitter)
Using Mongoose in Node.js provides an elegant MongoDB object modeling solution with built-in type casting, validation, query building, and business logic hooks. As the creator of CoreUI with extensive Node.js experience since 2014, I’ve implemented Mongoose in numerous enterprise applications for document-based data modeling and MongoDB operations. The most effective approach involves defining schemas with validation rules, creating models for data operations, and using Mongoose’s query API for database interactions. This method provides robust data modeling with automatic validation and type checking while maintaining clean, readable code for MongoDB operations.
Install Mongoose and create schemas with models for MongoDB document operations in Node.js applications.
const mongoose = require('mongoose')
// Connect to MongoDB
async function connectDB() {
try {
await mongoose.connect('mongodb://localhost:27017/myapp', {
useNewUrlParser: true,
useUnifiedTopology: true
})
console.log('MongoDB connected successfully')
} catch (error) {
console.error('Database connection failed:', error)
process.exit(1)
}
}
// Define User schema
const userSchema = new mongoose.Schema({
email: {
type: String,
required: [true, 'Email is required'],
unique: true,
lowercase: true,
match: [/\S+@\S+\.\S+/, 'Invalid email format']
},
name: {
type: String,
required: [true, 'Name is required'],
trim: true,
maxlength: [50, 'Name cannot exceed 50 characters']
},
age: {
type: Number,
min: [18, 'Must be at least 18 years old'],
max: [120, 'Age cannot exceed 120']
},
posts: [{
type: mongoose.Schema.Types.ObjectId,
ref: 'Post'
}]
}, {
timestamps: true
})
// Add instance methods
userSchema.methods.getPublicProfile = function() {
return {
id: this._id,
name: this.name,
email: this.email,
createdAt: this.createdAt
}
}
// Add static methods
userSchema.statics.findByEmail = function(email) {
return this.findOne({ email: email.toLowerCase() })
}
// Create User model
const User = mongoose.model('User', userSchema)
// Define Post schema
const postSchema = new mongoose.Schema({
title: {
type: String,
required: true,
trim: true
},
content: {
type: String,
required: true
},
author: {
type: mongoose.Schema.Types.ObjectId,
ref: 'User',
required: true
},
tags: [String],
published: {
type: Boolean,
default: false
}
}, {
timestamps: true
})
const Post = mongoose.model('Post', postSchema)
// CRUD operations
async function createUser(userData) {
try {
const user = new User(userData)
await user.save()
return user
} catch (error) {
throw error
}
}
async function findUserWithPosts(userId) {
try {
const user = await User.findById(userId).populate('posts')
return user
} catch (error) {
throw error
}
}
async function updateUser(userId, updateData) {
try {
const user = await User.findByIdAndUpdate(
userId,
updateData,
{ new: true, runValidators: true }
)
return user
} catch (error) {
throw error
}
}
module.exports = { connectDB, User, Post, createUser, findUserWithPosts, updateUser }
This code demonstrates complete Mongoose integration with schema definition, validation rules, instance and static methods, and model relationships using population. The setup includes connection handling, schema validation with custom error messages, and common CRUD operations with proper error handling. Mongoose provides automatic type casting, built-in validators, and query building capabilities while maintaining MongoDB’s document-based flexibility.
Best Practice Note:
This is the Mongoose integration pattern we use in CoreUI backend services for scalable MongoDB document management. Always use schema validation, implement proper error handling, and leverage Mongoose middleware for business logic hooks and data consistency.
