mongoose 6.3.0 → 6.3.3

package/lib/collection.js

@@ -23,13 +23,6 @@ function Collection(name, conn, opts) {
   if (opts === void 0) {
     opts = {};
   }
-  if (opts.capped === void 0) {
-    opts.capped = {};
-  }
-
-  if (typeof opts.capped === 'number') {
-    opts.capped = { size: opts.capped };
-  }
 
   this.opts = opts;
   this.name = name;

package/lib/connection.js

@@ -1357,7 +1357,8 @@ Connection.prototype.optionsProvideAuthenticationData = function(options) {
  * that this connection uses to talk to MongoDB.
  *
  * #### Example:
- *     const conn = await mongoose.createConnection('mongodb://localhost:27017/test');
+ *     const conn = await mongoose.createConnection('mongodb://localhost:27017/test').
+ *       asPromise();
  *
  *     conn.getClient(); // MongoClient { ... }
  *

package/lib/document.js

@@ -53,6 +53,7 @@ const populateModelSymbol = require('./helpers/symbols').populateModelSymbol;
 const scopeSymbol = require('./helpers/symbols').scopeSymbol;
 const schemaMixedSymbol = require('./schema/symbols').schemaMixedSymbol;
 const parentPaths = require('./helpers/path/parentPaths');
+
 let DocumentArray;
 let MongooseArray;
 let Embedded;
@@ -1048,7 +1049,6 @@ Document.prototype.$set = function $set(path, val, type, options) {
   const merge = options.merge;
   const adhoc = type && type !== true;
   const constructing = type === true;
-  const typeKey = this.$__schema.options.typeKey;
   let adhocs;
   let keys;
   let i = 0;
@@ -1150,14 +1150,15 @@ Document.prototype.$set = function $set(path, val, type, options) {
       }
     }
 
-    // Ensure all properties are in correct order by deleting and recreating every property.
-    for (const key of Object.keys(this.$__schema.tree)) {
-      if (this._doc.hasOwnProperty(key)) {
-        const val = this._doc[key];
-        delete this._doc[key];
-        this._doc[key] = val;
-      }
+    // Ensure all properties are in correct order
+    const orderedDoc = {};
+    const orderedKeys = Object.keys(this.$__schema.tree);
+    for (let i = 0, len = orderedKeys.length; i < len; ++i) {
+      (key = orderedKeys[i]) &&
+      (this._doc.hasOwnProperty(key)) &&
+      (orderedDoc[key] = undefined);
     }
+    this._doc = Object.assign(orderedDoc, this._doc);
 
     return this;
   }
@@ -1381,6 +1382,7 @@ Document.prototype.$set = function $set(path, val, type, options) {
     }
 
     let popOpts;
+    const typeKey = this.$__schema.options.typeKey;
     if (schema.options &&
         Array.isArray(schema.options[typeKey]) &&
         schema.options[typeKey].length &&
@@ -1400,7 +1402,7 @@ Document.prototype.$set = function $set(path, val, type, options) {
       // later in `$__set()` because we don't take `_doc` when we iterate through
       // a single nested doc. That's to make sure we get the correct context.
       // Otherwise we would double-call the setter, see gh-7196.
-      val = schema.applySetters(val, this, false, priorVal);
+      val = schema.applySetters(val, this, false, priorVal, options);
     }
 
     if (Array.isArray(val) &&
@@ -1454,14 +1456,18 @@ Document.prototype.$set = function $set(path, val, type, options) {
   }
 
   if (shouldSet) {
-    const doc = this.$isSubdocument ? this.ownerDocument() : this;
-    const savedState = doc.$__.savedState;
-    const savedStatePath = this.$isSubdocument ? this.$__.fullPath + '.' + path : path;
-    if (savedState != null) {
-      const firstDot = savedStatePath.indexOf('.');
-      const topLevelPath = firstDot === -1 ? savedStatePath : savedStatePath.slice(0, firstDot);
-      if (!savedState.hasOwnProperty(topLevelPath)) {
-        savedState[topLevelPath] = utils.clone(doc.$__getValue(topLevelPath));
+    let savedState = null;
+    let savedStatePath = null;
+    if (!constructing) {
+      const doc = this.$isSubdocument ? this.ownerDocument() : this;
+      savedState = doc.$__.savedState;
+      savedStatePath = this.$isSubdocument ? this.$__.fullPath + '.' + path : path;
+      if (savedState != null) {
+        const firstDot = savedStatePath.indexOf('.');
+        const topLevelPath = firstDot === -1 ? savedStatePath : savedStatePath.slice(0, firstDot);
+        if (!savedState.hasOwnProperty(topLevelPath)) {
+          savedState[topLevelPath] = utils.clone(doc.$__getValue(topLevelPath));
+        }
       }
     }
 
@@ -1618,7 +1624,6 @@ Document.prototype.$__set = function(pathToMark, path, options, constructing, pa
 
   const shouldModify = this.$__shouldModify(pathToMark, path, options, constructing, parts,
     schema, val, priorVal);
-  const _this = this;
 
   if (shouldModify) {
     this.markModified(pathToMark);
@@ -1634,14 +1639,6 @@ Document.prototype.$__set = function(pathToMark, path, options, constructing, pa
           item && item.__parentArray && (item.__parentArray = val);
         });
       }
-
-      // Small hack for gh-1638: if we're overwriting the entire array, ignore
-      // paths that were modified before the array overwrite
-      this.$__.activePaths.forEach(function(modifiedPath) {
-        if (modifiedPath.startsWith(path + '.')) {
-          _this.$__.activePaths.ignore(modifiedPath);
-        }
-      });
     }
   } else if (Array.isArray(val) && Array.isArray(priorVal) && utils.isMongooseArray(val) && utils.isMongooseArray(priorVal)) {
     val[arrayAtomicsSymbol] = priorVal[arrayAtomicsSymbol];
@@ -1832,7 +1829,6 @@ Document.prototype.$__path = function(path) {
  */
 
 Document.prototype.markModified = function(path, scope) {
-  // console.log('MarkModified', path, new Error().stack);
   this.$__.activePaths.modify(path);
   if (scope != null && !this.$isSubdocument) {
     this.$__.pathsToScopes = this.$__pathsToScopes || {};
@@ -2524,9 +2520,11 @@ function _getPathsToValidate(doc) {
   // the children as well
   for (const path of paths) {
     const _pathType = doc.$__schema.path(path);
+    if (!_pathType) {
+      continue;
+    }
 
-    if (!_pathType ||
-        !_pathType.$isMongooseArray ||
+    if (!_pathType.$isMongooseArray ||
         // To avoid potential performance issues, skip doc arrays whose children
         // are not required. `getPositionalPathType()` may be slow, so avoid
         // it unless we have a case of #6364
@@ -2538,8 +2536,7 @@ function _getPathsToValidate(doc) {
 
     // gh-11380: optimization. If the array isn't a document array and there's no validators
     // on the array type, there's no need to run validation on the individual array elements.
-    if (_pathType &&
-        _pathType.$isMongooseArray &&
+    if (_pathType.$isMongooseArray &&
         !_pathType.$isMongooseDocumentArray && // Skip document arrays...
         !_pathType.$embeddedSchemaType.$isMongooseArray && // and arrays of arrays
         _pathType.$embeddedSchemaType.validators.length === 0) {
@@ -3131,48 +3128,48 @@ Document.prototype.$isValid = function(path) {
 
 Document.prototype.$__reset = function reset() {
   let _this = this;
-  DocumentArray || (DocumentArray = require('./types/DocumentArray'));
 
-  this.$__.activePaths
-    .map('init', 'modify', function(i) {
-      return _this.$__getValue(i);
-    })
-    .filter(function(val) {
-      return val && Array.isArray(val) && utils.isMongooseDocumentArray(val) && val.length;
-    })
-    .forEach(function(array) {
-      let i = array.length;
-      while (i--) {
-        const doc = array[i];
-        if (!doc) {
-          continue;
+  // Skip for subdocuments
+  const subdocs = this.$parent() === this ? this.$getAllSubdocs() : [];
+  const resetArrays = new Set();
+  for (const subdoc of subdocs) {
+    const fullPathWithIndexes = subdoc.$__fullPathWithIndexes();
+    if (this.isModified(fullPathWithIndexes) || isParentInit(fullPathWithIndexes)) {
+      subdoc.$__reset();
+      if (subdoc.$isDocumentArrayElement) {
+        if (!resetArrays.has(subdoc.parentArray())) {
+          const array = subdoc.parentArray();
+          // Mark path to array as init for gh-6818
+          this.$__.activePaths.init(fullPathWithIndexes.replace(/\.\d+$/, '').slice(-subdoc.$basePath - 1));
+          array[arrayAtomicsBackupSymbol] = array[arrayAtomicsSymbol];
+          array[arrayAtomicsSymbol] = {};
+
+          resetArrays.add(array);
+        }
+      } else {
+        if (subdoc.$parent() === this) {
+          this.$__.activePaths.init(subdoc.$basePath);
+        } else if (subdoc.$parent() != null && subdoc.$parent().$isSubdocument) {
+          // If map path underneath subdocument, may end up with a case where
+          // map path is modified but parent still needs to be reset. See gh-10295
+          subdoc.$parent().$__reset();
         }
-        doc.$__reset();
       }
+    }
+  }
 
-      _this.$__.activePaths.init(array.$path());
-
-      array[arrayAtomicsBackupSymbol] = array[arrayAtomicsSymbol];
-      array[arrayAtomicsSymbol] = {};
-    });
-
-  this.$__.activePaths.
-    map('init', 'modify', function(i) {
-      return _this.$__getValue(i);
-    }).
-    filter(function(val) {
-      return val && !Array.isArray(val) && val.$isSingleNested;
-    }).
-    forEach(function(doc) {
-      doc.$__reset();
-      if (doc.$parent() === _this) {
-        _this.$__.activePaths.init(doc.$basePath);
-      } else if (doc.$parent() != null && doc.$parent().$isSubdocument) {
-        // If map path underneath subdocument, may end up with a case where
-        // map path is modified but parent still needs to be reset. See gh-10295
-        doc.$parent().$__reset();
+  function isParentInit(path) {
+    path = path.indexOf('.') === -1 ? [path] : path.split('.');
+    let cur = '';
+    for (let i = 0; i < path.length; ++i) {
+      cur += (cur.length ? '.' : '') + path[i];
+      if (_this.$__.activePaths[cur] === 'init') {
+        return true;
       }
-    });
+    }
+
+    return false;
+  }
 
   // clear atomics
   this.$__dirty().forEach(function(dirt) {

package/lib/error/cast.js

@@ -23,7 +23,7 @@ class CastError extends MongooseError {
       const stringValue = getStringValue(value);
       const valueType = getValueType(value);
       const messageFormat = getMessageFormat(schemaType);
-      const msg = formatMessage(null, type, stringValue, path, messageFormat, valueType);
+      const msg = formatMessage(null, type, stringValue, path, messageFormat, valueType, reason);
       super(msg);
       this.init(type, value, path, reason, schemaType);
     } else {
@@ -122,7 +122,7 @@ function getMessageFormat(schemaType) {
  * ignore
  */
 
-function formatMessage(model, kind, stringValue, path, messageFormat, valueType) {
+function formatMessage(model, kind, stringValue, path, messageFormat, valueType, reason) {
   if (messageFormat != null) {
     let ret = messageFormat.
       replace('{KIND}', kind).
@@ -140,6 +140,12 @@ function formatMessage(model, kind, stringValue, path, messageFormat, valueType)
     if (model != null) {
       ret += ' for model "' + model.modelName + '"';
     }
+    if (reason != null &&
+        typeof reason.constructor === 'function' &&
+        reason.constructor.name !== 'AssertionError' &&
+        reason.constructor.name !== 'Error') {
+      ret += ' because of "' + reason.constructor.name + '"';
+    }
     return ret;
   }
 }

package/lib/helpers/common.js

@@ -80,14 +80,6 @@ function modifiedPaths(update, path, result) {
 
     const _path = path + key;
     result[_path] = true;
-    if (_path.indexOf('.') !== -1) {
-      const sp = _path.split('.');
-      let cur = sp[0];
-      for (let i = 1; i < sp.length; ++i) {
-        result[cur] = true;
-        cur += '.' + sp[i];
-      }
-    }
     if (!Buffer.isBuffer(val) && isMongooseObject(val)) {
       val = val.toObject({ transform: false, virtuals: false });
     }

package/lib/helpers/immediate.js

@@ -7,7 +7,9 @@
 
 'use strict';
 
-const nextTick = process.nextTick.bind(process);
+const nextTick = typeof process !== 'undefined' && typeof process.nextTick === 'function' ?
+  process.nextTick.bind(process) :
+  cb => setTimeout(cb, 0); // Fallback for browser build
 
 module.exports = function immediate(cb) {
   return nextTick(cb);

package/lib/helpers/isAsyncFunction.js

@@ -1,10 +1,22 @@
 'use strict';
 
-const asyncFunctionPrototype = Object.getPrototypeOf(async function() {});
+let asyncFunctionPrototype = null;
+// try/catch for Babel compatibility, because Babel preset-env requires
+// regenerator-runtime for async/await and we don't want to include that
+// for a simple check.
+try {
+  asyncFunctionPrototype = Object.getPrototypeOf(async function() {});
+} catch (err) {}
 
-module.exports = function isAsyncFunction(v) {
-  return (
-    typeof v === 'function' &&
-    Object.getPrototypeOf(v) === asyncFunctionPrototype
-  );
-};
+if (asyncFunctionPrototype == null) {
+  module.exports = function isAsyncFunction() {
+    return false;
+  };
+} else {
+  module.exports = function isAsyncFunction(v) {
+    return (
+      typeof v === 'function' &&
+      Object.getPrototypeOf(v) === asyncFunctionPrototype
+    );
+  };
+}

package/lib/helpers/model/castBulkWrite.js

@@ -27,6 +27,12 @@ module.exports = function castBulkWrite(originalModel, op, options) {
         doc.$session(options.session);
       }
       op['insertOne']['document'] = doc;
+
+      if (options.skipValidation || op['insertOne'].skipValidation) {
+        callback(null);
+        return;
+      }
+
       op['insertOne']['document'].$validate({ __noPromise: true }, function(error) {
         if (error) {
           return callback(error, null);
@@ -154,6 +160,12 @@ module.exports = function castBulkWrite(originalModel, op, options) {
       }
       op['replaceOne']['replacement'] = doc;
 
+      if (options.skipValidation || op['replaceOne'].skipValidation) {
+        op['replaceOne']['replacement'] = op['replaceOne']['replacement'].toBSON();
+        callback(null);
+        return;
+      }
+
       op['replaceOne']['replacement'].$validate({ __noPromise: true }, function(error) {
         if (error) {
           return callback(error, null);

package/lib/helpers/populate/getModelsMapForPopulate.js

@@ -76,17 +76,20 @@ module.exports = function getModelsMapForPopulate(model, docs, options) {
     let schemaOptions = null;
     let modelNamesInOrder = null;
 
-    if (schema != null && schema.instance === 'Embedded' && schema.options.ref) {
-      const data = {
-        localField: options.path + '._id',
-        foreignField: '_id',
-        justOne: true
-      };
-      const res = _getModelNames(doc, schema, modelNameFromQuery, model);
+    if (schema != null && schema.instance === 'Embedded') {
+      if (schema.options.ref) {
+        const data = {
+          localField: options.path + '._id',
+          foreignField: '_id',
+          justOne: true
+        };
+        const res = _getModelNames(doc, schema, modelNameFromQuery, model);
 
-      const unpopulatedValue = mpath.get(options.path, doc);
-      const id = mpath.get('_id', unpopulatedValue);
-      addModelNamesToMap(model, map, available, res.modelNames, options, data, id, doc, schemaOptions, unpopulatedValue);
+        const unpopulatedValue = mpath.get(options.path, doc);
+        const id = mpath.get('_id', unpopulatedValue);
+        addModelNamesToMap(model, map, available, res.modelNames, options, data, id, doc, schemaOptions, unpopulatedValue);
+      }
+      // No-op if no `ref` set. See gh-11538
       continue;
     }
 

package/lib/helpers/query/cast$expr.js

@@ -4,7 +4,7 @@ const CastError = require('../../error/cast');
 const StrictModeError = require('../../error/strict');
 const castNumber = require('../../cast/number');
 
-const booleanComparison = new Set(['$and', '$or', '$not']);
+const booleanComparison = new Set(['$and', '$or']);
 const comparisonOperator = new Set(['$cmp', '$eq', '$lt', '$lte', '$gt', '$gte']);
 const arithmeticOperatorArray = new Set([
   // avoid casting '$add' or '$subtract', because expressions can be either number or date,
@@ -66,6 +66,7 @@ const dateOperators = new Set([
   '$isoWeek',
   '$millisecond'
 ]);
+const expressionOperator = new Set(['$not']);
 
 module.exports = function cast$expr(val, schema, strictQuery) {
   if (typeof val !== 'object' || val === null) {
@@ -106,6 +107,8 @@ function _castExpression(val, schema, strictQuery) {
       val[key] = castArithmetic(val[key], schema, strictQuery);
     } else if (arithmeticOperatorNumber.has(key)) {
       val[key] = castNumberOperator(val[key], schema, strictQuery);
+    } else if (expressionOperator.has(key)) {
+      val[key] = _castExpression(val[key], schema, strictQuery);
     }
   }
 

package/lib/helpers/schematype/handleImmutable.js

@@ -19,13 +19,16 @@ module.exports = function(schematype) {
 };
 
 function createImmutableSetter(path, immutable) {
-  return function immutableSetter(v) {
+  return function immutableSetter(v, _priorVal, _doc, options) {
     if (this == null || this.$__ == null) {
       return v;
     }
     if (this.isNew) {
       return v;
     }
+    if (options && options.overwriteImmutable) {
+      return v;
+    }
 
     const _immutable = typeof immutable === 'function' ?
       immutable.call(this, this) :

package/lib/helpers/timestamps/setupTimestamps.js

@@ -48,8 +48,8 @@ module.exports = function setupTimestamps(schema, timestamps) {
       currentTime() :
       this.ownerDocument().constructor.base.now();
 
-    if (!skipCreatedAt && this.isNew && createdAt && !this.$__getValue(createdAt) && this.$__isSelected(createdAt)) {
-      this.$set(createdAt, defaultTimestamp);
+    if (!skipCreatedAt && (this.isNew || this.$isSubdocument) && createdAt && !this.$__getValue(createdAt) && this.$__isSelected(createdAt)) {
+      this.$set(createdAt, defaultTimestamp, undefined, { overwriteImmutable: true });
     }
 
     if (!skipUpdatedAt && updatedAt && (this.isNew || this.$isModified())) {

package/lib/index.js

@@ -267,7 +267,7 @@ Mongoose.prototype.get = Mongoose.prototype.set;
  * @param {Number} [options.connectTimeoutMS=30000] How long the MongoDB driver will wait before killing a socket due to inactivity _during initial connection_. Defaults to 30000. This option is passed transparently to [Node.js' `socket#setTimeout()` function](https://nodejs.org/api/net.html#net_socket_settimeout_timeout_callback).
  * @param {Number} [options.socketTimeoutMS=30000] How long the MongoDB driver will wait before killing a socket due to inactivity _after initial connection_. A socket may be inactive because of either no activity or a long-running operation. This is set to `30000` by default, you should set this to 2-3x your longest running operation if you expect some of your database operations to run longer than 20 seconds. This option is passed to [Node.js `socket#setTimeout()` function](https://nodejs.org/api/net.html#net_socket_settimeout_timeout_callback) after the MongoDB driver successfully completes.
  * @param {Number} [options.family=0] Passed transparently to [Node.js' `dns.lookup()`](https://nodejs.org/api/dns.html#dns_dns_lookup_hostname_options_callback) function. May be either `0`, `4`, or `6`. `4` means use IPv4 only, `6` means use IPv6 only, `0` means try both.
- * @return {Connection} the created Connection object. Connections are thenable, so you can do `await mongoose.createConnection()`
+ * @return {Connection} the created Connection object. Connections are not thenable, so you can't do `await mongoose.createConnection()`. To await use mongoose.createConnection(uri).asPromise() instead.
  * @api public
  */
 

package/lib/internal.js

@@ -11,7 +11,6 @@ module.exports = exports = InternalCache;
 
 function InternalCache() {
   this.activePaths = new ActiveRoster();
-  this.strictMode = undefined;
 }
 
 InternalCache.prototype.fullPath = undefined;

package/lib/model.js

@@ -1067,13 +1067,33 @@ Model.prototype.$__deleteOne = Model.prototype.$__remove;
  *     doc.model('User').findById(id, callback);
  *
  * @param {String} name model name
+ * @method model
  * @api public
+ * @return {Model}
  */
 
 Model.prototype.model = function model(name) {
   return this[modelDbSymbol].model(name);
 };
 
+/**
+ * Returns another Model instance.
+ *
+ * #### Example:
+ *
+ *     const doc = new Tank;
+ *     doc.model('User').findById(id, callback);
+ *
+ * @param {String} name model name
+ * @method $model
+ * @api public
+ * @return {Model}
+ */
+
+Model.prototype.$model = function $model(name) {
+  return this[modelDbSymbol].model(name);
+};
+
 /**
  * Returns a document with `_id` only if at least one document exists in the database that matches
  * the given `filter`, and `null` otherwise.
@@ -1362,23 +1382,27 @@ Model.createCollection = function createCollection(options, callback) {
   }
 
   const schemaCollation = this &&
-  this.schema &&
-  this.schema.options &&
-  this.schema.options.collation || null;
+    this.schema &&
+    this.schema.options &&
+    this.schema.options.collation;
   if (schemaCollation != null) {
     options = Object.assign({ collation: schemaCollation }, options);
   }
   const capped = this &&
-  this.schema &&
-  this.schema.options &&
-   this.schema.options.capped;
-  if (capped) {
-    options = Object.assign({ capped: true }, capped, options);
+    this.schema &&
+    this.schema.options &&
+    this.schema.options.capped;
+  if (capped != null) {
+    if (typeof capped === 'number') {
+      options = Object.assign({ capped: true, size: capped }, options);
+    } else if (typeof capped === 'object') {
+      options = Object.assign({ capped: true }, capped, options);
+    }
   }
   const timeseries = this &&
-  this.schema &&
-  this.schema.options &&
-  this.schema.options.timeseries;
+    this.schema &&
+    this.schema.options &&
+    this.schema.options.timeseries;
   if (timeseries != null) {
     options = Object.assign({ timeseries }, options);
     if (options.expireAfterSeconds != null) {
@@ -2148,14 +2172,7 @@ Model.find = function find(conditions, projection, options, callback) {
 
   const mq = new this.Query({}, {}, this, this.$__collection);
   mq.select(projection);
-
   mq.setOptions(options);
-  if (this.schema.discriminatorMapping &&
-      this.schema.discriminatorMapping.isRoot &&
-      mq.selectedInclusively()) {
-    // Need to select discriminator key because original schema doesn't have it
-    mq.select(this.schema.options.discriminatorKey);
-  }
 
   callback = this.$handleCallbackError(callback);
 
@@ -2261,11 +2278,6 @@ Model.findOne = function findOne(conditions, projection, options, callback) {
   const mq = new this.Query({}, {}, this, this.$__collection);
   mq.select(projection);
   mq.setOptions(options);
-  if (this.schema.discriminatorMapping &&
-      this.schema.discriminatorMapping.isRoot &&
-      mq.selectedInclusively()) {
-    mq.select(this.schema.options.discriminatorKey);
-  }
 
   callback = this.$handleCallbackError(callback);
   return mq.findOne(conditions, callback);
@@ -3488,6 +3500,7 @@ function _setIsNew(doc, val) {
   const subdocs = doc.$getAllSubdocs();
   for (const subdoc of subdocs) {
     subdoc.$isNew = val;
+    subdoc.$emit('isNew', val);
   }
 }
 
@@ -3568,6 +3581,7 @@ function _setIsNew(doc, val) {
  * @param {String|number} [options.w=1] The [write concern](https://docs.mongodb.com/manual/reference/write-concern/). See [`Query#w()`](/docs/api.html#query_Query-w) for more information.
  * @param {number} [options.wtimeout=null] The [write concern timeout](https://docs.mongodb.com/manual/reference/write-concern/#wtimeout).
  * @param {Boolean} [options.j=true] If false, disable [journal acknowledgement](https://docs.mongodb.com/manual/reference/write-concern/#j-option)
+ * @param {Boolean} [options.skipValidation=false] Set to true to skip Mongoose schema validation on bulk write operations. Mongoose currently runs validation on `insertOne` and `replaceOne` operations by default.
  * @param {Boolean} [options.bypassDocumentValidation=false] If true, disable [MongoDB server-side schema validation](https://docs.mongodb.com/manual/core/schema-validation/) for all writes in this bulk.
  * @param {Boolean} [options.strict=null] Overwrites the [`strict` option](/docs/guide.html#strict) on schema. If false, allows filtering and writing fields not defined in the schema for all writes in this bulk.
  * @param {Function} [callback] callback `function(error, bulkWriteOpResult) {}`
@@ -4246,7 +4260,7 @@ Model.aggregate = function aggregate(pipeline, options, callback) {
  *     }
  *
  * @param {Object} obj
- * @param {Array} pathsToValidate
+ * @param {Array|String} pathsToValidate
  * @param {Object} [context]
  * @param {Function} [callback]
  * @return {Promise|undefined}
@@ -4265,7 +4279,7 @@ Model.validate = function validate(obj, pathsToValidate, context, callback) {
     let paths = Object.keys(schema.paths);
 
     if (pathsToValidate != null) {
-      const _pathsToValidate = new Set(pathsToValidate);
+      const _pathsToValidate = typeof pathsToValidate === 'string' ? new Set(pathsToValidate.split(' ')) : new Set(pathsToValidate);
       paths = paths.filter(p => {
         const pieces = p.split('.');
         let cur = pieces[0];
@@ -4561,9 +4575,9 @@ function populate(model, docs, options, callback) {
     }
     // If no models to populate but we have a nested populate,
     // keep trying, re: gh-8946
-    if (options.populate != null) {
-      const opts = utils.populate(options.populate).map(pop => Object.assign({}, pop, {
-        path: options.path + '.' + pop.path
+    if (populateOptions.populate != null) {
+      const opts = utils.populate(populateOptions.populate).map(pop => Object.assign({}, pop, {
+        path: populateOptions.path + '.' + pop.path
       }));
       return model.populate(docs, opts, callback);
     }

package/lib/query.js

@@ -53,6 +53,7 @@ const queryOptionMethods = new Set([
   'maxScan',
   'maxTimeMS',
   'maxscan',
+  'populate',
   'projection',
   'read',
   'select',
@@ -4609,7 +4610,10 @@ Query.prototype.transform = function(fn) {
  *     // Throws if no doc returned
  *     await Model.findOne({ foo: 'bar' }).orFail();
  *
- *     // Throws if no document was updated
+ *     // Throws if no document was updated. Note that `orFail()` will still
+ *     // throw if the only document that matches is `{ foo: 'bar', name: 'test' }`,
+ *     // because `orFail()` will throw if no document was _updated_, not
+ *     // if no document was _found_.
  *     await Model.updateOne({ foo: 'bar' }, { name: 'test' }).orFail();
  *
  *     // Throws "No docs found!" error if no docs match `{ foo: 'bar' }`
@@ -4976,7 +4980,7 @@ function castQuery(query) {
  * a response for each query has also been returned, the results are passed to
  * the callback.
  *
- * @param {Object|String} path either the path to populate or an object specifying all parameters
+ * @param {Object|String|Array<String>} path either the path(s) to populate or an object specifying all parameters
  * @param {Object|String} [select] Field selection for the population query
  * @param {Model} [model] The model you wish to use for population. If not specified, populate will look up the model by the name in the Schema's `ref` field.
  * @param {Object} [match] Conditions for the population query
@@ -5757,4 +5761,4 @@ Query.prototype.model;
  * Export
  */
 
-module.exports = Query;
+module.exports = Query;