Merge branch 'master' into 8.18

Author: vkarpov15

CHANGELOG.md

@@ -1,3 +1,12 @@
+8.17.1 / 2025-08-07
+===================
+ * fix(query): propagate read preference and read concern to populate if read() called after populate() #15567 #15553
+ * fix(model): call correct function in autoSearchIndex #15569 #15565
+ * fix(model): allow setting statics option on discriminator schema #15568 #15556
+ * fix(model): remove unnecessary conversion of undefined -> null in findById #15566 #15551
+ * types: allow passing in projections without as const #15564 #15557
+ * types: support maxLength and minLength in SchemaTypeOptions #15570 #4720
+
 8.17.0 / 2025-07-30
 ===================
  * feat: upgrade mongodb -> 6.18.0 #15552

lib/model.js

@@ -4304,6 +4304,10 @@ Model.validate = async function validate(obj, pathsOrOptions, context) {
   let remaining = paths.size;
 
   return new Promise((resolve, reject) => {
+    if (remaining === 0) {
+      return settle();
+    }
+
     for (const path of paths) {
       const schemaType = schema.path(path);
       if (schemaType == null) {
@@ -4328,13 +4332,17 @@ Model.validate = async function validate(obj, pathsOrOptions, context) {
       }, context, { path: path });
     }
 
+    function settle() {
+      if (error) {
+        reject(error);
+      } else {
+        resolve(obj);
+      }
+    }
+
     function _checkDone() {
       if (--remaining <= 0) {
-        if (error) {
-          reject(error);
-        } else {
-          resolve(obj);
-        }
+        return settle();
       }
     }
   });

lib/query.js

@@ -2133,6 +2133,29 @@ Query.prototype._optionsForExec = function(model) {
     }
   }
 
+  if (this._mongooseOptions.populate) {
+    if (options.readPreference) {
+      for (const pop of Object.values(this._mongooseOptions.populate)) {
+        if (pop.options?.readPreference === undefined) {
+          if (!pop.options) {
+            pop.options = {};
+          }
+          pop.options.readPreference = options.readPreference;
+        }
+      }
+    }
+    if (options.readConcern) {
+      for (const pop of Object.values(this._mongooseOptions.populate)) {
+        if (pop.options?.readConcern === undefined) {
+          if (!pop.options) {
+            pop.options = {};
+          }
+          pop.options.readConcern = options.readConcern;
+        }
+      }
+    }
+  }
+
   return options;
 };
 
@@ -4918,24 +4941,6 @@ Query.prototype.populate = function() {
 
   const res = utils.populate.apply(null, args);
 
-  // Propagate readConcern and readPreference and lean from parent query,
-  // unless one already specified
-  if (this.options != null) {
-    const readConcern = this.options.readConcern;
-    const readPref = this.options.readPreference;
-
-    for (const populateOptions of res) {
-      if (readConcern != null && (populateOptions && populateOptions.options && populateOptions.options.readConcern) == null) {
-        populateOptions.options = populateOptions.options || {};
-        populateOptions.options.readConcern = readConcern;
-      }
-      if (readPref != null && (populateOptions && populateOptions.options && populateOptions.options.readPreference) == null) {
-        populateOptions.options = populateOptions.options || {};
-        populateOptions.options.readPreference = readPref;
-      }
-    }
-  }
-
   const opts = this._mongooseOptions;
 
   if (opts.lean != null) {

package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "8.17.0",
+  "version": "8.17.1",
   "author": "Guillermo Rauch <[email protected]>",
   "keywords": [
     "mongodb",

test/model.populate.test.js

@@ -5569,6 +5569,7 @@ describe('model: populate:', function() {
         const Model = db.model('Test1', schema);
 
         const q = Model.find().read('secondaryPreferred').populate('ref');
+        await q.exec();
         assert.equal(q._mongooseOptions.populate['ref'].options.readPreference.mode,
           'secondaryPreferred');
       });

test/model.validate.test.js

@@ -206,4 +206,28 @@ describe('model: validate: ', function() {
     assert.equal(err.errors['myNumber'].name, 'CastError');
     assert.equal(err.errors['invalid1'].name, 'ValidatorError');
   });
+
+  it('should return cast errors when validating only paths that fail casting', async function() {
+    const Model = mongoose.model('Test', new Schema({
+      validPath: {
+        type: String,
+        required: true
+      },
+      invalidPath1: {
+        type: Number,
+        required: true
+      },
+      invalidPath2: {
+        type: Number,
+        required: true
+      }
+    }));
+
+    const err = await Model.validate({ validPath: 'foo', invalidPath1: 'not a number', invalidPath2: 'not a number' }, ['invalidPath1', 'invalidPath2']).
+      then(() => null, err => err);
+    assert.ok(err);
+    assert.deepEqual(Object.keys(err.errors).sort(), ['invalidPath1', 'invalidPath2']);
+    assert.equal(err.errors['invalidPath1'].name, 'CastError');
+    assert.equal(err.errors['invalidPath2'].name, 'CastError');
+  });
 });

test/query.test.js

@@ -4469,6 +4469,51 @@ describe('Query', function() {
     });
   });
 
+  it('propagates readPreference to populate options if read() is called after populate() (gh-15553)', async function() {
+    const schema = new Schema({ name: String, age: Number, friends: [{ type: 'ObjectId', ref: 'Person' }] });
+    const Person = db.model('Person', schema);
+
+    let query = Person.find({}).populate('friends');
+    query.read('secondaryPreferred');
+    await query.exec();
+    assert.strictEqual(query._mongooseOptions.populate.friends.options.readPreference.mode, 'secondaryPreferred');
+
+    query = Person.find({}).read('secondary').populate('friends');
+    query.read('secondaryPreferred');
+    await query.exec();
+    assert.strictEqual(query._mongooseOptions.populate.friends.options.readPreference.mode, 'secondaryPreferred');
+
+    query = Person.find({}).read('secondaryPreferred').populate('friends');
+    await query.exec();
+    assert.strictEqual(query._mongooseOptions.populate.friends.options.readPreference.mode, 'secondaryPreferred');
+
+    query = Person.find({}).read('primaryPreferred').populate({ path: 'friends', options: { readPreference: 'secondaryPreferred' } });
+    await query.exec();
+    assert.strictEqual(query._mongooseOptions.populate.friends.options.readPreference, 'secondaryPreferred');
+  });
+
+  it('propagates readConcern to populate options if readConcern() is called after populate() (gh-15553)', async function() {
+    const schema = new Schema({ name: String, age: Number, friends: [{ type: 'ObjectId', ref: 'Person' }] });
+    const Person = db.model('Person', schema);
+
+    let query = Person.find({}).populate('friends');
+    query.readConcern('majority');
+    await query.exec();
+    assert.strictEqual(query._mongooseOptions.populate.friends.options.readConcern.level, 'majority');
+
+    query = Person.find({}).readConcern('local').populate('friends');
+    query.readConcern('majority');
+    await query.exec();
+    assert.strictEqual(query._mongooseOptions.populate.friends.options.readConcern.level, 'majority');
+
+    query = Person.find({}).readConcern('majority').populate('friends');
+    await query.exec();
+    assert.strictEqual(query._mongooseOptions.populate.friends.options.readConcern.level, 'majority');
+
+    query = Person.find({}).readConcern('majority').populate({ path: 'friends', options: { readConcern: 'local' } });
+    await query.exec();
+    assert.strictEqual(query._mongooseOptions.populate.friends.options.readConcern, 'local');
+  });
 
   describe('Query with requireFilter', function() {
     let Person;