10 Mongoose Interview Questions and Answers

Mongoose is a popular Object Data Modeling (ODM) library for MongoDB and Node.js. It provides a straightforward, schema-based solution to model application data, making it easier to work with MongoDB within a Node.js environment. Mongoose handles data validation, casting, and business logic, streamlining the development process and ensuring data integrity.

This article offers a curated selection of Mongoose-related interview questions and answers. By familiarizing yourself with these questions, you can gain a deeper understanding of Mongoose’s core concepts and functionalities, enhancing your ability to tackle technical challenges in interviews confidently.

Mongoose Interview Questions and Answers

1. How do you add validation rules to a schema? Provide an example.

In Mongoose, validation rules ensure data integrity by enforcing criteria on the data saved to the database. Mongoose offers built-in validators for common requirements like required fields, value ranges, and string length. Custom validation functions can also be defined for more complex logic.

Example:

const mongoose = require('mongoose');
const Schema = mongoose.Schema;

const userSchema = new Schema({
    username: {
        type: String,
        required: true,
        minlength: 3,
        maxlength: 30
    },
    email: {
        type: String,
        required: true,
        match: /.+\@.+\..+/
    },
    age: {
        type: Number,
        min: 18,
        max: 65
    }
});

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

In this example, the userSchema specifies validation rules for username, email, and age. The username must be between 3 and 30 characters, the email must match a regex pattern, and age must be between 18 and 65.

2. Explain how to set up and use middleware in Mongoose. Provide an example.

Middleware in Mongoose allows you to execute functions at specific stages of the document lifecycle, such as before or after events like validation, save, or remove. This is useful for tasks like logging or modifying documents before saving.

Example:

const mongoose = require('mongoose');
const Schema = mongoose.Schema;

const userSchema = new Schema({
  username: String,
  password: String
});

// Pre-save middleware to hash the password
userSchema.pre('save', function(next) {
  this.password = hashPassword(this.password);
  next();
});

// Post-save middleware to log a message
userSchema.post('save', function(doc) {
  console.log(`User ${doc.username} has been saved.`);
});

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

function hashPassword(password) {
  return `hashed_${password}`;
}

const newUser = new User({ username: 'john_doe', password: '123456' });
newUser.save();

3. How do you handle relationships between different schemas? Provide an example using populate.

In Mongoose, relationships between schemas are managed using references, storing the ObjectId of one document within another. The populate method fetches referenced documents, similar to foreign keys in relational databases.

Example:

const mongoose = require('mongoose');
const Schema = mongoose.Schema;

const authorSchema = new Schema({
  name: String,
  age: Number
});

const bookSchema = new Schema({
  title: String,
  author: { type: Schema.Types.ObjectId, ref: 'Author' }
});

const Author = mongoose.model('Author', authorSchema);
const Book = mongoose.model('Book', bookSchema);

Book.find()
  .populate('author')
  .exec((err, books) => {
    console.log(books);
  });

Here, bookSchema references authorSchema using the author field. The populate method replaces the author ObjectId with the actual author document when querying the Book collection.

4. Describe how to perform CRUD operations with Mongoose. Provide code snippets for each operation.

CRUD operations are fundamental in databases. Mongoose provides a straightforward way to perform these operations on MongoDB collections. Below are code snippets for each CRUD operation:

1. Create
Use the save or create method to add a new document.

   const mongoose = require('mongoose');
   const Schema = mongoose.Schema;

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

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

   const newUser = new User({ name: 'John Doe', age: 30 });
   newUser.save((err) => {
       if (err) return console.error(err);
       console.log('User created successfully');
   });

2. Read
Use the find method to retrieve documents.

   User.find({}, (err, users) => {
       if (err) return console.error(err);
       console.log(users);
   });

   User.findOne({ name: 'John Doe' }, (err, user) => {
       if (err) return console.error(err);
       console.log(user);
   });

3. Update
Use updateOne or findByIdAndUpdate to modify documents.

   User.updateOne({ name: 'John Doe' }, { age: 31 }, (err, res) => {
       if (err) return console.error(err);
       console.log('User updated successfully');
   });

   User.findByIdAndUpdate('user_id', { age: 32 }, (err, user) => {
       if (err) return console.error(err);
       console.log('User updated successfully');
   });

4. Delete
Use deleteOne or findByIdAndDelete to remove documents.

   User.deleteOne({ name: 'John Doe' }, (err) => {
       if (err) return console.error(err);
       console.log('User deleted successfully');
   });

   User.findByIdAndDelete('user_id', (err) => {
       if (err) return console.error(err);
       console.log('User deleted successfully');
   });

5. How do you handle indexing in Mongoose? Provide an example.

Indexing in Mongoose enhances query performance by creating special data structures that store a portion of the collection’s data in an easy-to-traverse form. You can create indexes using the schema definition, specifying the index field and type.

Example:

const mongoose = require('mongoose');

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

// Compound index
userSchema.index({ username: 1, email: 1 });

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

In this example, a unique index is added to username and email, and a single-field index to age. A compound index is also created on username and email.

6. Explain how to use Mongoose with TypeScript. Provide an example.

Mongoose is an ODM library for MongoDB and Node.js. When using TypeScript, you can leverage static typing to catch errors at compile time. Define interfaces for your data models and use them with Mongoose schemas.

First, install the necessary packages:

npm install mongoose @types/mongoose

Define an interface for your data model and create a Mongoose schema:

import mongoose, { Document, Schema } from 'mongoose';

interface IUser extends Document {
  name: string;
  email: string;
  age: number;
}

const UserSchema: Schema = new Schema({
  name: { type: String, required: true },
  email: { type: String, required: true },
  age: { type: Number, required: true }
});

const User = mongoose.model<IUser>('User', UserSchema);

export default User;

In your application, use the User model with TypeScript’s type safety:

import mongoose from 'mongoose';
import User from './models/User';

const run = async () => {
  await mongoose.connect('mongodb://localhost:27017/test');

  const user = new User({
    name: 'John Doe',
    email: '[email protected]',
    age: 30
  });

  await user.save();
  console.log('User saved:', user);
};

run().catch(err => console.error(err));

7. How do you perform bulk write operations in Mongoose? Provide an example.

Bulk write operations in Mongoose allow multiple write operations in a single request, improving performance when dealing with large datasets. The bulkWrite method accepts an array of operations.

Example:

const mongoose = require('mongoose');
const Schema = mongoose.Schema;

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

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

async function performBulkWrite() {
  const bulkOps = [
    {
      insertOne: {
        document: { name: 'Alice', age: 25 }
      }
    },
    {
      updateOne: {
        filter: { name: 'Bob' },
        update: { $set: { age: 30 } }
      }
    },
    {
      deleteOne: {
        filter: { name: 'Charlie' }
      }
    }
  ];

  try {
    const result = await User.bulkWrite(bulkOps);
    console.log(result);
  } catch (error) {
    console.error(error);
  }
}

performBulkWrite();

8. Describe how to implement soft deletes in Mongoose. Provide an example.

Soft deletes in Mongoose can be implemented by adding a field to indicate whether a document is deleted. This field can be a boolean or a timestamp. When a document is “deleted,” this field is updated instead of removing the document. Queries can then exclude documents marked as deleted.

Example:

const mongoose = require('mongoose');

const userSchema = new mongoose.Schema({
    name: String,
    email: String,
    isDeleted: {
        type: Boolean,
        default: false
    }
});

userSchema.methods.softDelete = function() {
    this.isDeleted = true;
    return this.save();
};

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

// Usage
User.findById(userId).then(user => {
    if (user) {
        user.softDelete().then(() => {
            console.log('User soft deleted');
        });
    }
});

9. How do you handle transactions in Mongoose? Provide an example.

To handle transactions in Mongoose, use MongoDB’s session-based transactions. Start a session, execute operations within it, and commit or abort the transaction based on the outcome.

Example:

const mongoose = require('mongoose');

async function runTransaction() {
    const session = await mongoose.startSession();
    session.startTransaction();

    try {
        await User.create([{ name: 'Alice' }], { session });
        await Order.create([{ item: 'Book', quantity: 1 }], { session });

        await session.commitTransaction();
        console.log('Transaction committed.');
    } catch (error) {
        await session.abortTransaction();
        console.error('Transaction aborted due to error:', error);
    } finally {
        session.endSession();
    }
}

runTransaction();

10. Explain how to use custom error handling in Mongoose. Provide an example.

Custom error handling in Mongoose allows developers to manage errors during database operations. Define custom error messages and handle validation, casting, and other errors.

Example:

const mongoose = require('mongoose');

const userSchema = new mongoose.Schema({
  username: {
    type: String,
    required: [true, 'Username is required'],
    unique: true
  },
  email: {
    type: String,
    required: [true, 'Email is required'],
    match: [/.+\@.+\..+/, 'Please fill a valid email address']
  }
});

userSchema.post('save', function(error, doc, next) {
  if (error.name === 'MongoError' && error.code === 11000) {
    next(new Error('There was a duplicate key error'));
  } else {
    next(error);
  }
});

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

const newUser = new User({ username: 'testuser', email: 'invalidemail' });

newUser.save((err) => {
  if (err) {
    console.error('Error:', err.message);
  } else {
    console.log('User saved successfully');
  }
});