Hey there! Let's tackle that population issue you're facing with your User schema. The core problem here is twofold: your nested documentId fields don't explicitly reference the Media collection, and populating references inside arrays requires a specific syntax (or virtual setup) to work correctly.

Option 1: Add ref to Nested Subschemas (Recommended) #

This is the cleanest approach since it leverages Mongoose's built-in population capabilities. Here's how to adjust your schema:

Step 1: Define Subschemas with ref #

First, create dedicated subschemas for your education, experience, and certification arrays, adding the ref property to the documentId field to point to your Media collection:

const mongoose = require('mongoose');

// Subschema for education entries
const educationSubSchema = new mongoose.Schema({
  title: String,
  description: String,
  year: String,
  verified: Boolean,
  documentId: { type: mongoose.Schema.Types.ObjectId, ref: 'Media' } // Link to Media collection
});

// Repeat for experience and certification
const experienceSubSchema = new mongoose.Schema({
  title: String,
  description: String,
  year: String,
  verified: Boolean,
  documentId: { type: mongoose.Schema.Types.ObjectId, ref: 'Media' }
});

const certificationSubSchema = new mongoose.Schema({
  title: String,
  description: String,
  year: String,
  verified: Boolean,
  documentId: { type: mongoose.Schema.Types.ObjectId, ref: 'Media' }
});

Step 2: Update Your User Schema #

Now integrate these subschemas into your existing User schema setup:

exports.User = schema => {
  schema.add({
    username: { type: String, index: true },
    education: [educationSubSchema],
    experience: [experienceSubSchema],
    certification: [certificationSubSchema]
  });
  schema.set('toObject', { virtuals: true });
  schema.set('toJSON', { virtuals: true });
};

Step 3: Populate the Nested References #

When querying users, use the nested path syntax to populate each documentId inside the arrays:

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

// Example: Fetch a single user with populated media documents
User.findOne({ username: 'yourUsername' })
  .populate('education.documentId')
  .populate('experience.documentId')
  .populate('certification.documentId')
  .then(user => {
    // Each entry in education/experience/certification will have documentId replaced with the full Media document
    console.log(JSON.stringify(user, null, 2));
  })
  .catch(err => console.error('Population error:', err));

You can also populate all three in one go using an array for cleaner code:

User.findOne({ username: 'yourUsername' })
  .populate([
    { path: 'education.documentId', model: 'Media' },
    { path: 'experience.documentId', model: 'Media' },
    { path: 'certification.documentId', model: 'Media' }
  ])
  .then(user => /* handle result */);

Option 2: Use Aggregation (If You Can't Modify the Schema) #

If you're unable to update the schema (e.g., existing production data), you can use MongoDB's aggregation pipeline to manually join the collections:

User.aggregate([
  // Join Media documents for education entries
  {
    $lookup: {
      from: 'medias', // Name of your Media collection (note: MongoDB uses pluralized names by default)
      localField: 'education.documentId',
      foreignField: '_id',
      as: 'educationMedia'
    }
  },
  // Merge media data into matching education entries
  {
    $addFields: {
      education: {
        $map: {
          input: '$education',
          as: 'edu',
          in: {
            $mergeObjects: [
              '$$edu',
              {
                document: {
                  $arrayElemAt: [
                    '$educationMedia',
                    { $indexOfArray: ['$educationMedia._id', '$$edu.documentId'] }
                  ]
                }
              }
            ]
          }
        }
      }
    }
  },
  // Repeat the lookup/merge for experience and certification
  {
    $lookup: {
      from: 'medias',
      localField: 'experience.documentId',
      foreignField: '_id',
      as: 'experienceMedia'
    }
  },
  {
    $addFields: {
      experience: {
        $map: {
          input: '$experience',
          as: 'exp',
          in: {
            $mergeObjects: [
              '$$exp',
              {
                document: {
                  $arrayElemAt: [
                    '$experienceMedia',
                    { $indexOfArray: ['$experienceMedia._id', '$$exp.documentId'] }
                  ]
                }
              }
            ]
          }
        }
      }
    }
  },
  {
    $lookup: {
      from: 'medias',
      localField: 'certification.documentId',
      foreignField: '_id',
      as: 'certificationMedia'
    }
  },
  {
    $addFields: {
      certification: {
        $map: {
          input: '$certification',
          as: 'cert',
          in: {
            $mergeObjects: [
              '$$cert',
              {
                document: {
                  $arrayElemAt: [
                    '$certificationMedia',
                    { $indexOfArray: ['$certificationMedia._id', '$$cert.documentId'] }
                  ]
                }
              }
            ]
          }
        }
      }
    }
  },
  // Clean up temporary media arrays
  { $project: { educationMedia: 0, experienceMedia: 0, certificationMedia: 0 } }
])
.then(users => console.log('Aggregated users with media:', users))
.catch(err => console.error('Aggregation error:', err));

Key Notes #

• Make sure your Media collection is properly defined and exists in your database.
• If you're using virtual population (not shown here), ensure your virtuals are correctly mapped with localField and foreignField, but the subschema + nested populate method is far simpler for this use case.

内容的提问来源于stack exchange，提问作者Hoàng Minh Phan