MongoDB with Mongoose in Node.js

Mongoose is the most popular MongoDB library for Node.js. It adds schemas, validation, and more.

Setup

npm install mongoose

Connect to MongoDB

const mongoose = require('mongoose');

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

Define a Schema

const userSchema = new mongoose.Schema({
  name: {
    type: String,
    required: true,
    trim: true
  },
  email: {
    type: String,
    required: true,
    unique: true,
    lowercase: true
  },
  age: {
    type: Number,
    min: 0,
    max: 120
  },
  role: {
    type: String,
    enum: ['user', 'admin'],
    default: 'user'
  },
  createdAt: {
    type: Date,
    default: Date.now
  }
});

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

Create Documents

// Method 1: new + save
const user = new User({
  name: 'Alice',
  email: 'alice@example.com',
  age: 25
});
await user.save();

// Method 2: create
const user2 = await User.create({
  name: 'Bob',
  email: 'bob@example.com'
});

Read Documents

// Find all
const users = await User.find();

// Find with conditions
const admins = await User.find({ role: 'admin' });

// Find one
const user = await User.findOne({ email: 'alice@example.com' });

// Find by ID
const user = await User.findById('507f1f77bcf86cd799439011');

// Select specific fields
const users = await User.find().select('name email');

// Sort
const users = await User.find().sort({ createdAt: -1 });

// Limit
const users = await User.find().limit(10);

// Pagination
const page = 2;
const limit = 10;
const users = await User.find()
  .skip((page - 1) * limit)
  .limit(limit);

Update Documents

// Find and update
const user = await User.findByIdAndUpdate(
  '507f1f77bcf86cd799439011',
  { name: 'Alice Smith' },
  { new: true }  // Return updated document
);

// Update many
await User.updateMany(
  { role: 'user' },
  { $set: { verified: true } }
);

Delete Documents

// Delete one
await User.findByIdAndDelete('507f1f77bcf86cd799439011');

// Delete many
await User.deleteMany({ role: 'guest' });

Schema Options

const postSchema = new mongoose.Schema({
  title: String,
  content: String,
  author: {
    type: mongoose.Schema.Types.ObjectId,
    ref: 'User'  // Reference to User model
  },
  tags: [String],  // Array of strings
  metadata: {
    views: { type: Number, default: 0 },
    likes: { type: Number, default: 0 }
  }
}, {
  timestamps: true  // Adds createdAt, updatedAt
});

Populate (Join)

// Get posts with author details
const posts = await Post.find()
  .populate('author', 'name email');

// Result includes full author object
// { title: '...', author: { name: 'Alice', email: '...' } }

Instance Methods

userSchema.methods.getPublicProfile = function() {
  return {
    id: this._id,
    name: this.name,
    email: this.email
  };
};

const user = await User.findById(id);
const profile = user.getPublicProfile();

Static Methods

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

const user = await User.findByEmail('alice@example.com');

Middleware (Hooks)

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

// After saving
userSchema.post('save', function(doc) {
  console.log('User saved:', doc.email);
});

Express Integration

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

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

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

// routes/users.js
const User = require('../models/User');

router.get('/', async (req, res) => {
  const users = await User.find();
  res.json(users);
});

router.post('/', async (req, res) => {
  const user = await User.create(req.body);
  res.status(201).json(user);
});

Key Takeaway

Mongoose provides schemas for MongoDB. Define schemas with types and validation, create models, then use find/create/update/delete. Use populate for joins, middleware for hooks. It's the standard way to work with MongoDB in Node.js.