Mongoose middleware (pre/post hooks) in Express

Introduction

Mongoose middleware lets you run code before or after certain actions on your data. It helps automate tasks like validation, logging, or modifying data.

You want to check or change data before saving it to the database.

You need to log information every time a document is deleted.

You want to update related data automatically after a document is updated.

You want to run cleanup tasks before removing a document.

You want to validate or modify data before running queries.

Syntax

Express

schema.pre('action', function(next) {
  // code to run before action
  next();
});

schema.post('action', function(doc, next) {
  // code to run after action
  next();
});

pre runs before the action, post runs after.

Always call next() to continue the process.

Examples

Sets a creation date before saving a user.

Express

userSchema.pre('save', function(next) {
  this.createdAt = new Date();
  next();
});

Logs a message after a user is removed.

Express

userSchema.post('remove', function(doc, next) {
  console.log(`User ${doc._id} was removed.`);
  next();
});

Updates the updatedAt field before updating a user.

Express

userSchema.pre('findOneAndUpdate', function(next) {
  this.set({ updatedAt: new Date() });
  next();
});

Sample Program

This example shows three middleware hooks: one sets createdAt before saving, one sets updatedAt before updating, and one logs a message after removing a user.

Express

import mongoose from 'mongoose';

const userSchema = new mongoose.Schema({
  name: String,
  createdAt: Date,
  updatedAt: Date
});

// Pre-save hook to set createdAt
userSchema.pre('save', function(next) {
  if (!this.createdAt) {
    this.createdAt = new Date();
  }
  next();
});

// Pre-update hook to set updatedAt
userSchema.pre('findOneAndUpdate', function(next) {
  this.set({ updatedAt: new Date() });
  next();
});

// Post-remove hook to log removal
userSchema.post('remove', function(doc) {
  console.log(`User ${doc._id} removed.`);
});

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

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

  // Create and save user
  const user = new User({ name: 'Alice' });
  await user.save();

  // Update user
  await User.findOneAndUpdate({ _id: user._id }, { name: 'Alice Updated' });

  // Remove user
  await user.remove();

  await mongoose.disconnect();
}

run().catch(console.error);

Important Notes

Middleware functions must call next() to continue the operation.

Use pre hooks to modify data before actions, and post hooks for side effects like logging.

For query middleware like findOneAndUpdate, use this.set() to change update data.

Summary

Mongoose middleware runs code before or after database actions.

Use pre hooks to prepare or validate data.

Use post hooks to perform tasks after actions, like logging.

Practice

1. What is the main purpose of pre middleware in Mongoose?

easy

A. To connect to the MongoDB database

B. To run code after a database operation completes

C. To define the schema structure

D. To run code before a database operation like save or remove

Solution

1. Step 1: Understand middleware timing

   Pre middleware runs before a database action, allowing preparation or validation.

2. Step 2: Differentiate pre and post hooks

   Post middleware runs after the action, so pre is for before actions.

3. Final Answer:

   To run code before a database operation like save or remove -> Option D

4. Quick Check:

   Pre middleware = before action [OK]

Hint: Pre means before the action starts [OK]

Common Mistakes:

• Confusing pre with post middleware
• Thinking pre defines schema structure
• Assuming pre connects to database

2. Which of the following is the correct syntax to add a pre-save hook in Mongoose?

easy

A. schema.on('save', function(next) { /* code */ next(); });

B. schema.pre('save', function(next) { /* code */ next(); });

C. schema.before('save', function() { /* code */ });

D. schema.post('save', function(next) { /* code */ next(); });

Solution

1. Step 1: Recall Mongoose middleware method names

   Mongoose uses pre and post methods for middleware, not before or on.

2. Step 2: Check syntax for pre-save hook

   The correct syntax is schema.pre('save', function(next) { ... next(); }); to run code before saving.

3. Final Answer:

   schema.pre('save', function(next) { /* code */ next(); }); -> Option B

4. Quick Check:

   Use schema.pre for pre hooks [OK]

Hint: Use schema.pre('event', fn) for pre hooks [OK]

Common Mistakes:

• Using schema.post instead of schema.pre for pre hooks
• Using non-existent methods like before or on
• Forgetting to call next() in middleware

3. Given this Mongoose pre-save middleware, what will be the value of doc.updatedAt after saving?

schema.pre('save', function(next) {
  this.updatedAt = new Date();
  next();
});

medium

A. Undefined because updatedAt is not set in schema

B. The date when the document was created

C. The current date and time when save is called

D. An error because next() is missing

Solution

1. Step 1: Understand pre-save middleware effect

   The middleware sets this.updatedAt to the current date before saving.

2. Step 2: Confirm middleware runs before save

   Since it runs before save, the document's updatedAt will be updated to the current time.

3. Final Answer:

   The current date and time when save is called -> Option C

4. Quick Check:

   Pre-save sets updatedAt = now [OK]

Hint: Pre-save runs before saving, so updatedAt is current time [OK]

Common Mistakes:

• Assuming updatedAt is undefined without schema field
• Confusing createdAt with updatedAt
• Thinking next() is missing causing error

4. What is wrong with this Mongoose middleware code?

schema.pre('remove', (next) => {
  console.log('Removing', this._id);
  next();
});

medium

A. Arrow function does not bind 'this', so 'this' is undefined inside middleware

B. Missing call to next() to continue middleware chain

C. Using 'remove' event is not supported in Mongoose

D. Middleware must be post, not pre, for remove

Solution

1. Step 1: Check function type in middleware

   Mongoose middleware requires normal functions to bind this to the document.

2. Step 2: Identify arrow function issue

   Arrow functions do not bind this, so this will be undefined inside the middleware.

3. Final Answer:

   Arrow function does not bind 'this', so 'this' is undefined inside middleware -> Option A

4. Quick Check:

   Use normal functions for middleware to access this [OK]

Hint: Use function() not arrow to access this in middleware [OK]

Common Mistakes:

• Using arrow functions in middleware
• Forgetting to call next() in async middleware
• Thinking remove event is unsupported

5. You want to log a message after a document is saved and also update a cache. Which Mongoose middleware setup is correct?

hard

A. Use schema.post('save', function(doc) { console.log('Saved:', this._id); updateCache(this); });

B. Use schema.pre('save', function(doc) { console.log('Saved:', this._id); updateCache(this); });

C. Use schema.post('save', (doc) => { console.log('Saved:', this._id); updateCache(this); });

D. Use schema.pre('save', (doc) => { console.log('Saved:', this._id); updateCache(this); });

Solution

1. Step 1: Identify when to run logging and cache update

   Logging and cache update should happen after saving, so use post middleware.

2. Step 2: Choose correct function syntax

   Post middleware receives the saved document as first argument; use normal function to access this if needed.

3. Final Answer:

   Use schema.post('save', function(doc) { console.log('Saved:', this._id); updateCache(this); }); -> Option A

4. Quick Check:

   Post-save + normal function for logging/cache [OK]

Hint: Use post-save with normal function for after-save tasks [OK]

Common Mistakes:

• Using pre instead of post for after-save tasks
• Using arrow functions losing this context
• Not passing doc argument in post middleware