This tutorial aims to guide MERN application developers on how to efficiently filter and obtain relevant posts based on user roles (such as lecturers) in MongoDB. The article will detail the definition of user roles through Mongoose models and show how to first query the user IDs of specific roles and then use these IDs to retrieve the posts published by them, thus solving the challenge of accessing user role information directly in the post query.

When building MERN (MongoDB, Express, React, Node.js) stack applications, it is often necessary to filter or restrict access to content based on user attributes such as roles. For example, in a learning platform, you may need to display all posts made by users with the "lecturer" role. This article will explain in detail how to implement this function through Mongoose and provide specific code examples.

1. Understand the data model

First, we need to look at the Post and User data models in our application. These models define the structure of data and the relationships between them.

1.1 Post model

The Post model contains the basic information of the post and is associated with the User model, indicating which user published the post.

 import mongoose from 'mongoose';

const PostSchema = new mongoose.Schema(
  {
    title: {
      type: String,
      required: true,
    },
    text: {
      type: String,
      required: true,
      unique: true,
    },
    tags: {
      type: Array,
      default: [],
    },
    viewsCount: {
      type: Number,
      default: 0,
    },
    user: {
      type: mongoose.Schema.Types.ObjectId,
      ref: 'User', // Reference the User model required: true,
    },
    imageUrl: String,
    comments: [{ type: mongoose.Schema.Types.ObjectId, ref: 'Comment' }],
  },
  {
    timestamps: true,
  },
);

export default mongoose.model('Post', PostSchema);

Please note the user field, which is of type mongoose.Schema.Types.ObjectId and points to the User model via ref: 'User'. This means that each post is associated with a specific user.

1.2 User model

The User model defines the user's attributes, the key of which is the role field, which clarifies the user's identity (student or lecturer).

 import mongoose from "mongoose";

const UserSchema = new mongoose.Schema({
    fullName: {
        type: String,
        required: true,
    },
    email: {
        type: String,
        required: true,
        unique: true,
    },
    passwordHash: {
        type: String,
        required: true,
    },
    role: {
        type: String,
        enum: ["student", "instructor"], // Define user role enumeration required: true,
      },
    avatarUrl: String,
},
{
    timestamps: true,
});

// You can add instance methods to check roles UserSchema.methods.isStudent = function () {
    return this.role === "student";
  };

UserSchema.methods.isInstructor = function () {
    return this.role === "instructor";
  };

export default mongoose.model('User', UserSchema);

The role field is a string whose value is restricted to "student" or "instructor". This is the key attribute for our screening.

2. Wrong attempts and cause analysis

A common erroneous attempt is to directly add the condition of the role field to the query of the Post model, for example:

 // Wrong attempt export const getAllByTeacher = async(req, res) => {
  try {
    // The Post model itself has no role field const posts = await PostModel.find({role: "instructor"}).populate('user').exec(); 
    res.json(posts);
} catch (e) {
    console.log(e);
    res.status(500).json({
        message: 'Can't get post'
    });
}
}

This approach is wrong because the Post model itself does not have a role field. The role field exists in the User model. Mongoose's find method matches the fields of the current model when executing a query. Although populate('user') can fill in the associated user data after the query results are returned, it cannot filter the data of the current model (Post) based on the fields of the associated model (User) during the initial find query phase.

3. Correct implementation plan

To correctly filter posts based on user roles, we need to adopt a two-step strategy:

1. Step 1: Find all users with a specific role.
2. Step 2: Use the IDs of these users to query their posts.

The following is the specific implementation code:

 import PostModel from '../models/Post.js'; // Assume your Post model is in this path import UserModel from '../models/User.js'; // Assume your User model is in this path export const getAllByInstructor = async (req, res) => {
    try {
        // 1. Find all users with the role "instructor" const instructors = await UserModel.find({ role: "instructor" }, '_id'); // Get only the _id field // Extract the ID list of these instructors // The instructors array now contains objects in the form of { _id: '...' } // Extract pure ID strings or ObjectId objects through .map const instructorIds = instructors.map(user => user._id);

        // 2. Use the instructor's ID list to query all posts posted by them // The $in operator is used to match any value of the user field in the instructorIds array const posts = await PostModel.find({ user: { $in: instructorIds } })
                                     .populate('user') // Fill in the associated user information.exec();

        res.json(posts);
    } catch (err) {
        console.error(err); // Use console.error to print errors res.status(500).json({
            message: 'Unable to obtain lecturer's posts',
        });
    }
};

3.1 Code analysis

1. const instructors = await UserModel.find({ role: "instructor" }, '_id');
   • We first query the UserModel and filter out all users whose role field is "instructor".
   • '_id' is a projection parameter, indicating that we only care about the _id field of the returned user document, which can reduce the amount of data transferred from the database and improve efficiency.
2. const instructorIds = instructors.map(user => user._id);
   • UserModel.find returns an array of user documents. We use the map method to traverse this array and extract the _id of each user, thus obtaining an array containing all instructor IDs.
3. const posts = await PostModel.find({ user: { $in: instructorIds } }).populate('user').exec();
   • This is the core query. We perform a find operation on PostModel.
   • { user: { $in: instructorIds } } is the query condition. The $in operator is a MongoDB query operator that allows us to find all posts where the value of the user field exists in the instructorIds array.
   • .populate('user'): After obtaining qualified posts, we use the populate method to fill the user field in each post document and convert it from an ObjectId to a complete User document object. In this way, when the client receives the post data, it can also obtain the publisher's detailed information (such as fullName, email, etc.).
   • .exec(): Execute Mongoose query.

4. Precautions and best practices

• Performance optimization : For large data sets, ensure that the role field in the User model and the user field in the Post model are indexed. This will significantly improve query performance.
  • Add role in UserSchema: { type: String, enum: ["student", "instructor"], required: true, index: true }
  • Add user in PostSchema: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true, index: true }
• Error handling : Always include try...catch blocks in asynchronous operations to gracefully handle possible database errors or server issues.
• Versatility : This two-step query pattern is very versatile and can be applied to any scenario where main documents need to be filtered based on associated document properties. For example, get all articles under a specific tag, or get all products under a certain category.
• Aggregation Pipeline : For more complex join queries and data transformations, MongoDB's aggregation pipeline ($lookup operator) may be a more powerful option, which can complete joins and filters in one database operation. However, for a simple "filter by relation ID" requirement like this one, a two-step query is usually more straightforward and performs well.

5. Summary

With the above approach, we successfully solved the challenge of filtering posts based on user roles in MERN applications. The key is to understand Mongoose's query mechanism and model association, and adopt a step-by-step query strategy: first identify the target users, and then use the IDs of these users to accurately retrieve relevant content. This pattern is a powerful and flexible way to handle linked data filtering in Mongoose.

The above is the detailed content of How to filter posts based on user role in MERN app: Take getting all lecturer posts as an example. For more information, please follow other related articles on the PHP Chinese website!