Merge branch 'master' into 8.4

Author: vkarpov15

lib/document.js

@@ -3831,16 +3831,14 @@ Document.prototype.$toObject = function(options, json) {
   // need the original options the user passed in, plus `_isNested` and
   // `_parentOptions` for checking whether we need to depopulate.
   const cloneOptions = {
+    ...options,
     _isNested: true,
     json: json,
     minimize: _minimize,
     flattenMaps: flattenMaps,
     flattenObjectIds: flattenObjectIds,
     _seen: (options && options._seen) || new Map(),
-    _calledWithOptions: options._calledWithOptions,
-    virtuals: options.virtuals,
-    getters: options.getters,
-    depopulate: options.depopulate
+    _calledWithOptions: options._calledWithOptions
   };
 
   const depopulate = options.depopulate ||

lib/model.js

@@ -3264,6 +3264,14 @@ Model.$__insertMany = function(arr, options, callback) {
 
     // Quickly escape while there aren't any valid docAttributes
     if (docAttributes.length === 0) {
+      if (throwOnValidationError) {
+        return callback(new MongooseBulkWriteError(
+          validationErrors,
+          results,
+          null,
+          'insertMany'
+        ));
+      }
       if (rawResult) {
         const res = {
           acknowledged: true,
@@ -3623,6 +3631,14 @@ Model.bulkWrite = async function bulkWrite(ops, options) {
     validOps = validOps.sort().map(index => ops[index]);
 
     if (validOps.length === 0) {
+      if (options.throwOnValidationError && validationErrors.length) {
+        throw new MongooseBulkWriteError(
+          validationErrors,
+          results,
+          res,
+          'bulkWrite'
+        );
+      }
       return getDefaultBulkwriteResult();
     }
 

test/document.test.js

@@ -520,6 +520,34 @@ describe('document', function() {
     docs.toObject({ transform: true });
   });
 
+  it('propagates toObject transform function to all subdocuments (gh-14589)', async function() {
+    const schema = new mongoose.Schema({
+      name: String,
+      docArr: [{ name: String }],
+      subdoc: new mongoose.Schema({ name: String })
+    });
+    const TestModel = db.model('Test', schema);
+
+    const doc = new TestModel({
+      name: 'test',
+      docArr: [{ name: 'test' }],
+      subdoc: { name: 'test' }
+    });
+
+    // pass the transform as an inline option. Deletes `_id` property
+    // from both the top-level document and the subdocument.
+    const obj = doc.toObject({ transform: deleteId });
+
+    assert.equal(obj._id, undefined);
+    assert.equal(obj.subdoc._id, undefined);
+    assert.equal(obj.docArr[0]._id, undefined);
+
+    function deleteId(doc, ret) {
+      delete ret._id;
+      return ret;
+    }
+  });
+
   it('disabling aliases in toObject options (gh-7548)', function() {
     const schema = new mongoose.Schema({
       name: {

test/model.test.js

@@ -4062,7 +4062,32 @@ describe('Model', function() {
         assert.ok(doc.createdAt.valueOf() >= now.valueOf());
         assert.ok(doc.updatedAt);
         assert.ok(doc.updatedAt.valueOf() >= now.valueOf());
+      });
+
+      it('throwOnValidationError (gh-14572)', async function() {
+        const schema = new Schema({
+          num: Number
+        });
+
+        const M = db.model('Test', schema);
+
+        const ops = [
+          {
+            insertOne: {
+              document: {
+                num: 'not a number'
+              }
+            }
+          }
+        ];
 
+        const err = await M.bulkWrite(
+          ops,
+          { ordered: false, throwOnValidationError: true }
+        ).then(() => null, err => err);
+        assert.ok(err);
+        assert.equal(err.name, 'MongooseBulkWriteError');
+        assert.equal(err.validationErrors[0].errors['num'].name, 'CastError');
       });
 
       it('with child timestamps and array filters (gh-7032)', async function() {
@@ -6602,14 +6627,14 @@ describe('Model', function() {
     });
 
     it('insertMany should throw an error if there were operations that failed validation, ' +
-        'but all operations that passed validation succeeded (gh-13256)', async function() {
+        'but all operations that passed validation succeeded (gh-14572) (gh-13256)', async function() {
       const userSchema = new Schema({
         age: { type: Number }
       });
 
       const User = db.model('User', userSchema);
 
-      const err = await User.insertMany([
+      let err = await User.insertMany([
         new User({ age: 12 }),
         new User({ age: 12 }),
         new User({ age: 'NaN' })
@@ -6623,7 +6648,20 @@ describe('Model', function() {
       assert.ok(err.results[2] instanceof Error);
       assert.equal(err.results[2].errors['age'].name, 'CastError');
 
-      const docs = await User.find();
+      let docs = await User.find();
+      assert.deepStrictEqual(docs.map(doc => doc.age), [12, 12]);
+
+      err = await User.insertMany([
+        new User({ age: 'NaN' })
+      ], { ordered: false, throwOnValidationError: true })
+        .then(() => null)
+        .catch(err => err);
+
+      assert.ok(err);
+      assert.equal(err.name, 'MongooseBulkWriteError');
+      assert.equal(err.validationErrors[0].errors['age'].name, 'CastError');
+
+      docs = await User.find();
       assert.deepStrictEqual(docs.map(doc => doc.age), [12, 12]);
     });