Merge branch '7.x' into IslandRhythms/cleanup

Author: vkarpov15

lib/helpers/populate/assignVals.js

@@ -144,7 +144,7 @@ module.exports = function assignVals(o) {
 
     const parts = _path.split('.');
     let cur = docs[i];
-    const curPath = parts[0];
+    let curPath = parts[0];
     for (let j = 0; j < parts.length - 1; ++j) {
       // If we get to an array with a dotted path, like `arr.foo`, don't set
       // `foo` on the array.
@@ -167,6 +167,7 @@ module.exports = function assignVals(o) {
         cur[parts[j]] = {};
       }
       cur = cur[parts[j]];
+      curPath += parts[j + 1] ? `.${parts[j + 1]}` : '';
       // If the property in MongoDB is a primitive, we won't be able to populate
       // the nested path, so skip it. See gh-7545
       if (typeof cur !== 'object') {

test/model.populate.test.js

@@ -8259,6 +8259,58 @@ describe('model: populate:', function() {
       assert.deepEqual(populatedRides[1].files, []);
     });
 
+    it('doesnt insert empty document when lean populating a path within an underneath non-existent document array (gh-14098)', async function() {
+      const userSchema = new mongoose.Schema({
+        fullName: String,
+        company: String
+      });
+      const User = db.model('User', userSchema);
+
+      const fileSchema = new mongoose.Schema({
+        _id: String,
+        uploaderId: {
+          type: mongoose.ObjectId,
+          ref: 'User'
+        }
+      }, { toObject: { virtuals: true }, toJSON: { virtuals: true } });
+      fileSchema.virtual('uploadedBy', {
+        ref: 'User',
+        localField: 'uploaderId',
+        foreignField: '_id',
+        justOne: true
+      });
+
+      const contentSchema = new mongoose.Schema({
+        memo: String,
+        files: { type: [fileSchema], default: [] }
+      }, { toObject: { virtuals: true }, toJSON: { virtuals: true }, _id: false });
+
+      const postSchema = new mongoose.Schema({
+        title: String,
+        content: { type: contentSchema }
+      }, { toObject: { virtuals: true }, toJSON: { virtuals: true } });
+      const Post = db.model('Test1', postSchema);
+
+      const user = await User.create({ fullName: 'John Doe', company: 'GitHub' });
+      await Post.create([
+        { title: 'London-Paris' },
+        {
+          title: 'Berlin-Moscow',
+          content: {
+            memo: 'Not Easy',
+            files: [{ _id: '123', uploaderId: user._id }]
+          }
+        }
+      ]);
+      await Post.updateMany({}, { $unset: { 'content.files': 1 } });
+      const populatedRides = await Post.find({}).populate({
+        path: 'content.files.uploadedBy',
+        justOne: true
+      }).lean();
+      assert.equal(populatedRides[0].content.files, undefined);
+      assert.equal(populatedRides[1].content.files, undefined);
+    });
+
     it('sets empty array if populating undefined path (gh-8455)', async function() {
       const TestSchema = new Schema({
         thingIds: [mongoose.ObjectId]

test/types/models.test.ts

@@ -758,3 +758,11 @@ function gh13957() {
   const repository = new RepositoryBase<ITest>(TestModel);
   expectType<Promise<ITest[]>>(repository.insertMany([{ name: 'test' }]));
 }
+
+async function gh14003() {
+  const schema = new Schema({ name: String });
+  const TestModel = model('Test', schema);
+
+  await TestModel.validate({ name: 'foo' }, ['name']);
+  await TestModel.validate({ name: 'foo' }, { pathsToSkip: ['name'] });
+}

types/models.d.ts

@@ -461,8 +461,9 @@ declare module 'mongoose' {
 
     /** Casts and validates the given object against this model's schema, passing the given `context` to custom validators. */
     validate(): Promise<void>;
-    validate(optional: any): Promise<void>;
-    validate(optional: any, pathsToValidate: PathsToValidate): Promise<void>;
+    validate(obj: any): Promise<void>;
+    validate(obj: any, pathsOrOptions: PathsToValidate): Promise<void>;
+    validate(obj: any, pathsOrOptions: { pathsToSkip?: pathsToSkip }): Promise<void>;
 
     /** Watches the underlying collection for changes using [MongoDB change streams](https://www.mongodb.com/docs/manual/changeStreams/). */
     watch<ResultType extends mongodb.Document = any, ChangeType extends mongodb.ChangeStreamDocument = any>(pipeline?: Array<Record<string, unknown>>, options?: mongodb.ChangeStreamOptions & { hydrate?: boolean }): mongodb.ChangeStream<ResultType, ChangeType>;