Make hydrate() recursively hydrate virtual populate docs if hydratedPopulatedDocs is set

lib/helpers/populate/getModelsMapForPopulate.js

@@ -410,26 +410,12 @@ function _virtualPopulate(model, docs, options, _virtualRes) {
  justOne = options.justOne;
  }
 
+ modelNames = virtual._getModelNamesForPopulate(doc);
  if (virtual.options.refPath) {
- modelNames =
- modelNamesFromRefPath(virtual.options.refPath, doc, options.path);
  justOne = !!virtual.options.justOne;
  data.isRefPath = true;
  } else if (virtual.options.ref) {
- let normalizedRef;
- if (typeof virtual.options.ref === 'function' && !virtual.options.ref[modelSymbol]) {
- normalizedRef = virtual.options.ref.call(doc, doc);
- } else {
- normalizedRef = virtual.options.ref;
- }
  justOne = !!virtual.options.justOne;
- // When referencing nested arrays, the ref should be an Array
- // of modelNames.
- if (Array.isArray(normalizedRef)) {
- modelNames = normalizedRef;
- } else {
- modelNames = [normalizedRef];
- }
  }
 
  data.isVirtual = true;

lib/schema.js

@@ -2297,7 +2297,10 @@ Schema.prototype.virtual = function(name, options) {
  throw new Error('Reference virtuals require `foreignField` option');
  }
 
- this.pre('init', function virtualPreInit(obj) {
+ const virtual = this.virtual(name);
+ virtual.options = options;
+
+ this.pre('init', function virtualPreInit(obj, opts) {
  if (mpath.has(name, obj)) {
  const _v = mpath.get(name, obj);
  if (!this.$$populatedVirtuals) {
@@ -2314,13 +2317,26 @@ Schema.prototype.virtual = function(name, options) {
  _v == null ? [] : [_v];
  }
 
+ if (opts?.hydratedPopulatedDocs && !options.count) {
+ const modelNames = virtual._getModelNamesForPopulate(this);
+ const populatedVal = this.$$populatedVirtuals[name];
+ if (!Array.isArray(populatedVal) && !populatedVal.$__ && modelNames?.length === 1) {
+ const PopulateModel = this.db.model(modelNames[0]);
+ this.$$populatedVirtuals[name] = PopulateModel.hydrate(populatedVal);
+ } else if (Array.isArray(populatedVal) && modelNames?.length === 1) {
+ const PopulateModel = this.db.model(modelNames[0]);
+ for (let i = 0; i < populatedVal.length; ++i) {
+ if (!populatedVal[i].$__) {
+ populatedVal[i] = PopulateModel.hydrate(populatedVal[i]);
+ }
+ }
+ }
+ }
+
  mpath.unset(name, obj);
  }
  });
 
- const virtual = this.virtual(name);
- virtual.options = options;
-
  virtual.
  set(function(v) {
  if (!this.$$populatedVirtuals) {

lib/virtualType.js

@@ -1,7 +1,10 @@
 'use strict';
 
+const modelNamesFromRefPath = require('./helpers/populate/modelNamesFromRefPath');
 const utils = require('./utils');
 
+const modelSymbol = require('./helpers/symbols').modelSymbol;
+
 /**
  * VirtualType constructor
  *
@@ -168,6 +171,32 @@ VirtualType.prototype.applySetters = function(value, doc) {
  return v;
 };
 
+/**
+ * Get the names of models used to populate this model given a doc
+ *
+ * @param {Document} doc
+ * @return {Array<string> | null}
+ * @api private
+ */
+
+VirtualType.prototype._getModelNamesForPopulate = function _getModelNamesForPopulate(doc) {
+ if (this.options.refPath) {
+ return modelNamesFromRefPath(this.options.refPath, doc, this.path);
+ }
+
+ let normalizedRef = null;
+ if (typeof this.options.ref === 'function' && !this.options.ref[modelSymbol]) {
+ normalizedRef = this.options.ref.call(doc, doc);
+ } else {
+ normalizedRef = this.options.ref;
+ }
+ if (normalizedRef != null && !Array.isArray(normalizedRef)) {
+ return [normalizedRef];
+ }
+
+ return normalizedRef;
+};
+
 /*!
  * exports
  */

test/model.hydrate.test.js

@@ -117,5 +117,61 @@ describe('model', function() {
  const C = Company.hydrate(company, null, { hydratedPopulatedDocs: true });
  assert.equal(C.users[0].name, 'Val');
  });
+ it('should hydrate documents in virtual populate (gh-14503)', async function() {
+ const StorySchema = new Schema({
+ userId: {
+ type: Schema.Types.ObjectId,
+ ref: 'User'
+ },
+ title: {
+ type: String
+ }
+ }, { timestamps: true });
+
+ const UserSchema = new Schema({
+ name: String
+ }, { timestamps: true });
+
+ UserSchema.virtual('stories', {
+ ref: 'Story',
+ localField: '_id',
+ foreignField: 'userId'
+ });
+ UserSchema.virtual('storiesCount', {
+ ref: 'Story',
+ localField: '_id',
+ foreignField: 'userId',
+ count: true
+ });
+
+ const User = db.model('User', UserSchema);
+ const Story = db.model('Story', StorySchema);
+
+ const user = await User.create({ name: 'Alex' });
+ const story1 = await Story.create({ title: 'Ticket 1', userId: user._id });
+ const story2 = await Story.create({ title: 'Ticket 2', userId: user._id });
+
+ const populated = await User.findOne({ name: 'Alex' }).populate(['stories', 'storiesCount']).lean();
+ const hydrated = User.hydrate(
+ JSON.parse(JSON.stringify(populated)),
+ null,
+ { hydratedPopulatedDocs: true }
+ );
+
+ assert.equal(hydrated.stories[0]._id.toString(), story1._id.toString());
+ assert(typeof hydrated.stories[0]._id == 'object', typeof hydrated.stories[0]._id);
+ assert(hydrated.stories[0]._id instanceof mongoose.Types.ObjectId);
+ assert(typeof hydrated.stories[0].createdAt == 'object');
+ assert(hydrated.stories[0].createdAt instanceof Date);
+
+ assert.equal(hydrated.stories[1]._id.toString(), story2._id.toString());
+ assert(typeof hydrated.stories[1]._id == 'object');
+
+ assert(hydrated.stories[1]._id instanceof mongoose.Types.ObjectId);
+ assert(typeof hydrated.stories[1].createdAt == 'object');
+ assert(hydrated.stories[1].createdAt instanceof Date);
+
+ assert.strictEqual(hydrated.storiesCount, 2);
+ });
  });
 });