mongoose 5.4.23 → 5.5.3

package/lib/plugins/validateBeforeSave.js

@@ -26,7 +26,13 @@ module.exports = function(schema) {
 
     // Validate
     if (shouldValidate) {
-      this.validate(function(error) {
+      const hasValidateModifiedOnlyOption = options &&
+          (typeof options === 'object') &&
+          ('validateModifiedOnly' in options);
+      const validateOptions = hasValidateModifiedOnlyOption ?
+        {validateModifiedOnly: options.validateModifiedOnly} :
+        null;
+      this.validate(validateOptions, function(error) {
         return _this.schema.s.hooks.execPost('save:error', _this, [ _this], { error: error }, function(error) {
           next(error);
         });

package/lib/query.js

@@ -845,6 +845,47 @@ Query.prototype.mod = function() {
  * @api public
  */
 
+/**
+ * Get/set the current projection (AKA fields). Pass `null` to remove the
+ * current projection.
+ *
+ * Unlike `projection()`, the `select()` function modifies the current
+ * projection in place. This function overwrites the existing projection.
+ *
+ * ####Example:
+ *
+ *     const q = Model.find();
+ *     q.projection(); // null
+ *
+ *     q.select('a b');
+ *     q.projection(); // { a: 1, b: 1 }
+ *
+ *     q.projection({ c: 1 });
+ *     q.projection(); // { c: 1 }
+ *
+ *     q.projection(null);
+ *     q.projection(); // null
+ *
+ *
+ * @method projection
+ * @memberOf Query
+ * @instance
+ * @param {Object|null} arg
+ * @return {Object} the current projection
+ * @api public
+ */
+
+Query.prototype.projection = function(arg) {
+  if (arguments.length === 0) {
+    return this._fields;
+  }
+
+  this._fields = {};
+  this._userProvidedFields = {};
+  this.select(arg);
+  return this._fields;
+};
+
 /**
  * Specifies which document fields to include or exclude (also known as the query "projection")
  *
@@ -2305,6 +2346,27 @@ Query.prototype.countDocuments = function(conditions, callback) {
   return this;
 };
 
+/**
+ * Thunk around findOne()
+ *
+ * @param {Function} [callback]
+ * @see findOne http://docs.mongodb.org/manual/reference/method/db.collection.findOne/
+ * @api private
+ */
+
+Query.prototype.__distinct = wrapThunk(function __distinct(callback) {
+  this._castConditions();
+
+  if (this.error()) {
+    callback(this.error());
+    return null;
+  }
+
+  // don't pass in the conditions because we already merged them in
+  this._collection.collection.
+    distinct(this._distinct, this._conditions, callback);
+});
+
 /**
  * Declares or executes a distict() operation.
  *
@@ -2351,16 +2413,16 @@ Query.prototype.distinct = function(field, conditions, callback) {
     this.error(new ObjectParameterError(conditions, 'filter', 'distinct'));
   }
 
-  if (callback != null) {
-    this._castConditions();
+  if (field != null) {
+    this._distinct = field;
+  }
+  this.op = 'distinct';
 
-    if (this.error() != null) {
-      callback(this.error());
-      return this;
-    }
+  if (callback != null) {
+    this.__distinct(callback);
   }
 
-  return Query.base.distinct.call(this, {}, field, callback);
+  return this;
 };
 
 /**
@@ -3357,12 +3419,7 @@ Query.prototype._findAndModify = function(type, callback) {
       if (error) {
         return callback(error);
       }
-      if (castedDoc && castedDoc.toBSON) {
-        castedDoc = castedDoc.toBSON();
-      }
-      _this._collection.findAndModify(castedQuery, castedDoc, opts, _wrapThunkCallback(_this, function(error, res) {
-        return cb(error, res ? res.value : res, res);
-      }));
+      _legacyFindAndModify.call(_this, castedQuery, castedDoc, opts, callback);
     };
 
     try {
@@ -3371,12 +3428,7 @@ Query.prototype._findAndModify = function(type, callback) {
       callback(error);
     }
   } else {
-    if (castedDoc && castedDoc.toBSON) {
-      castedDoc = castedDoc.toBSON();
-    }
-    this._collection.findAndModify(castedQuery, castedDoc, opts, _wrapThunkCallback(_this, function(error, res) {
-      return cb(error, res ? res.value : res, res);
-    }));
+    _legacyFindAndModify.call(_this, castedQuery, castedDoc, opts, callback);
   }
 
   return this;
@@ -3393,6 +3445,23 @@ function _completeOneLean(doc, res, opts, callback) {
   return callback(null, doc);
 }
 
+
+/*!
+ * ignore
+ */
+
+const _legacyFindAndModify = util.deprecate(function(filter, update, opts, cb) {
+  if (update && update.toBSON) {
+    update = update.toBSON();
+  }
+  const collection = this._collection;
+  collection.findAndModify(filter, update, opts, _wrapThunkCallback(this, function(error, res) {
+    return cb(error, res ? res.value : res, res);
+  }));
+}, 'Mongoose: `findOneAndUpdate()` and `findOneAndDelete()` without the ' +
+  '`useFindAndModify` option set to false are deprecated. See: ' +
+  'https://mongoosejs.com/docs/deprecations.html#-findandmodify-');
+
 /*!
  * Override mquery.prototype._mergeUpdate to handle mongoose objects in
  * updates.
@@ -3654,9 +3723,16 @@ Query.prototype._replaceOne = wrapThunk(function(callback) {
  * @param {Object} [doc] the update command
  * @param {Object} [options]
  * @param {Boolean} [options.multipleCastError] by default, mongoose only returns the first error that occurred in casting the query. Turn on this option to aggregate all the cast errors.
- * @param {Function} [callback] optional, params are (error, writeOpResult)
+ * @param {Boolean} [options.omitUndefined=false] If true, delete any properties whose value is `undefined` when casting an update. In other words, if this is set, Mongoose will delete `baz` from the update in `Model.updateOne({}, { foo: 'bar', baz: undefined })` before sending the update to the server.
+ * @param {Boolean|String} [options.strict] overwrites the schema's [strict mode option](http://mongoosejs.com/docs/guide.html#strict)
+ * @param {Boolean} [options.upsert=false] if true, and no documents found, insert a new document
+ * @param {Object} [options.writeConcern=null] sets the [write concern](https://docs.mongodb.com/manual/reference/write-concern/) for replica sets. Overrides the [schema-level write concern](/docs/guide.html#writeConcern)
+ * @param {Boolean} [options.omitUndefined=false] If true, delete any properties whose value is `undefined` when casting an update. In other words, if this is set, Mongoose will delete `baz` from the update in `Model.updateOne({}, { foo: 'bar', baz: undefined })` before sending the update to the server.
+ * @param {Boolean} [options.timestamps=null] If set to `false` and [schema-level timestamps](/docs/guide.html#timestamps) are enabled, skip timestamps for this update. Does nothing if schema-level timestamps are not set.
+ * @param {Function} [callback] params are (error, writeOpResult)
  * @return {Query} this
  * @see Model.update #model_Model.update
+ * @see Query docs https://mongoosejs.com/docs/queries.html
  * @see update http://docs.mongodb.org/manual/reference/method/db.collection.update/
  * @see writeOpResult http://mongodb.github.io/node-mongodb-native/2.2/api/Collection.html#~WriteOpResult
  * @see MongoDB docs https://docs.mongodb.com/manual/reference/command/update/#update-command-output
@@ -3714,9 +3790,15 @@ Query.prototype.update = function(conditions, doc, options, callback) {
  * @param {Object} [options]
  * @param {Boolean} [options.multipleCastError] by default, mongoose only returns the first error that occurred in casting the query. Turn on this option to aggregate all the cast errors.
  * @param {Boolean} [options.omitUndefined=false] If true, delete any properties whose value is `undefined` when casting an update. In other words, if this is set, Mongoose will delete `baz` from the update in `Model.updateOne({}, { foo: 'bar', baz: undefined })` before sending the update to the server.
- * @param {Function} [callback] optional params are (error, writeOpResult)
+ * @param {Boolean|String} [options.strict] overwrites the schema's [strict mode option](http://mongoosejs.com/docs/guide.html#strict)
+ * @param {Boolean} [options.upsert=false] if true, and no documents found, insert a new document
+ * @param {Object} [options.writeConcern=null] sets the [write concern](https://docs.mongodb.com/manual/reference/write-concern/) for replica sets. Overrides the [schema-level write concern](/docs/guide.html#writeConcern)
+ * @param {Boolean} [options.omitUndefined=false] If true, delete any properties whose value is `undefined` when casting an update. In other words, if this is set, Mongoose will delete `baz` from the update in `Model.updateOne({}, { foo: 'bar', baz: undefined })` before sending the update to the server.
+ * @param {Boolean} [options.timestamps=null] If set to `false` and [schema-level timestamps](/docs/guide.html#timestamps) are enabled, skip timestamps for this update. Does nothing if schema-level timestamps are not set.
+ * @param {Function} [callback] params are (error, writeOpResult)
  * @return {Query} this
  * @see Model.update #model_Model.update
+ * @see Query docs https://mongoosejs.com/docs/queries.html
  * @see update http://docs.mongodb.org/manual/reference/method/db.collection.update/
  * @see writeOpResult http://mongodb.github.io/node-mongodb-native/2.2/api/Collection.html#~WriteOpResult
  * @see MongoDB docs https://docs.mongodb.com/manual/reference/command/update/#update-command-output
@@ -3775,9 +3857,15 @@ Query.prototype.updateMany = function(conditions, doc, options, callback) {
  * @param {Object} [options]
  * @param {Boolean} [options.multipleCastError] by default, mongoose only returns the first error that occurred in casting the query. Turn on this option to aggregate all the cast errors.
  * @param {Boolean} [options.omitUndefined=false] If true, delete any properties whose value is `undefined` when casting an update. In other words, if this is set, Mongoose will delete `baz` from the update in `Model.updateOne({}, { foo: 'bar', baz: undefined })` before sending the update to the server.
+ * @param {Boolean|String} [options.strict] overwrites the schema's [strict mode option](http://mongoosejs.com/docs/guide.html#strict)
+ * @param {Boolean} [options.upsert=false] if true, and no documents found, insert a new document
+ * @param {Object} [options.writeConcern=null] sets the [write concern](https://docs.mongodb.com/manual/reference/write-concern/) for replica sets. Overrides the [schema-level write concern](/docs/guide.html#writeConcern)
+ * @param {Boolean} [options.omitUndefined=false] If true, delete any properties whose value is `undefined` when casting an update. In other words, if this is set, Mongoose will delete `baz` from the update in `Model.updateOne({}, { foo: 'bar', baz: undefined })` before sending the update to the server.
+ * @param {Boolean} [options.timestamps=null] If set to `false` and [schema-level timestamps](/docs/guide.html#timestamps) are enabled, skip timestamps for this update. Does nothing if schema-level timestamps are not set.
  * @param {Function} [callback] params are (error, writeOpResult)
  * @return {Query} this
  * @see Model.update #model_Model.update
+ * @see Query docs https://mongoosejs.com/docs/queries.html
  * @see update http://docs.mongodb.org/manual/reference/method/db.collection.update/
  * @see writeOpResult http://mongodb.github.io/node-mongodb-native/2.2/api/Collection.html#~WriteOpResult
  * @see MongoDB docs https://docs.mongodb.com/manual/reference/command/update/#update-command-output
@@ -3832,10 +3920,17 @@ Query.prototype.updateOne = function(conditions, doc, options, callback) {
  * @param {Object} [criteria]
  * @param {Object} [doc] the update command
  * @param {Object} [options]
+ * @param {Boolean} [options.multipleCastError] by default, mongoose only returns the first error that occurred in casting the query. Turn on this option to aggregate all the cast errors.
  * @param {Boolean} [options.omitUndefined=false] If true, delete any properties whose value is `undefined` when casting an update. In other words, if this is set, Mongoose will delete `baz` from the update in `Model.updateOne({}, { foo: 'bar', baz: undefined })` before sending the update to the server.
- * @param {Function} [callback] optional params are (error, writeOpResult)
+ * @param {Boolean|String} [options.strict] overwrites the schema's [strict mode option](http://mongoosejs.com/docs/guide.html#strict)
+ * @param {Boolean} [options.upsert=false] if true, and no documents found, insert a new document
+ * @param {Object} [options.writeConcern=null] sets the [write concern](https://docs.mongodb.com/manual/reference/write-concern/) for replica sets. Overrides the [schema-level write concern](/docs/guide.html#writeConcern)
+ * @param {Boolean} [options.omitUndefined=false] If true, delete any properties whose value is `undefined` when casting an update. In other words, if this is set, Mongoose will delete `baz` from the update in `Model.updateOne({}, { foo: 'bar', baz: undefined })` before sending the update to the server.
+ * @param {Boolean} [options.timestamps=null] If set to `false` and [schema-level timestamps](/docs/guide.html#timestamps) are enabled, skip timestamps for this update. Does nothing if schema-level timestamps are not set.
+ * @param {Function} [callback] params are (error, writeOpResult)
  * @return {Query} this
  * @see Model.update #model_Model.update
+ * @see Query docs https://mongoosejs.com/docs/queries.html
  * @see update http://docs.mongodb.org/manual/reference/method/db.collection.update/
  * @see writeOpResult http://mongodb.github.io/node-mongodb-native/2.2/api/Collection.html#~WriteOpResult
  * @see MongoDB docs https://docs.mongodb.com/manual/reference/command/update/#update-command-output
@@ -4241,10 +4336,10 @@ function castDoc(query, overwrite) {
  *     })
  *
  *     Kitten.find().populate({
- *         path: 'owner'
- *       , select: 'name'
- *       , match: { color: 'black' }
- *       , options: { sort: { name: -1 }}
+ *       path: 'owner',
+ *       select: 'name',
+ *       match: { color: 'black' },
+ *       options: { sort: { name: -1 } }
  *     }).exec(function (err, kittens) {
  *       console.log(kittens[0].owner.name) // Zoopa
  *     })
@@ -4254,13 +4349,21 @@ function castDoc(query, overwrite) {
  *       console.log(kittens[0].owner.name) // Zoopa
  *     })
  *
- * Paths are populated after the query executes and a response is received. A separate query is then executed for each path specified for population. After a response for each query has also been returned, the results are passed to the callback.
+ * Paths are populated after the query executes and a response is received. A
+ * separate query is then executed for each path specified for population. After
+ * 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} [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
  * @param {Object} [options] Options for the population query (sort, etc)
+ * @param {String} [options.path=null] The path to populate.
+ * @param {boolean} [options.retainNullValues=false] by default, Mongoose removes null and undefined values from populated arrays. Use this option to make `populate()` retain `null` and `undefined` array entries.
+ * @param {boolean} [options.getters=false] if true, Mongoose will call any getters defined on the `localField`. By default, Mongoose gets the raw value of `localField`. For example, you would need to set this option to `true` if you wanted to [add a `lowercase` getter to your `localField`](/docs/schematypes.html#schematype-options).
+ * @param {boolean} [options.clone=false] When you do `BlogPost.find().populate('author')`, blog posts with the same author will share 1 copy of an `author` doc. Enable this option to make Mongoose clone populated docs before assigning them.
+ * @param {Object|Function} [options.match=null] Add an additional filter to the populate query. Can be a filter object containing [MongoDB query syntax](https://docs.mongodb.com/manual/tutorial/query-documents/), or a function that returns a filter object.
  * @see population ./populate.html
  * @see Query#select #query_Query-select
  * @see Model.populate #model_Model.populate
@@ -4504,13 +4607,16 @@ Query.prototype.cursor = function cursor(opts) {
     this.setOptions(opts);
   }
 
+  const options = Object.assign({}, this.options, {
+    projection: this.projection()
+  });
   try {
     this.cast(this.model);
   } catch (err) {
-    return (new QueryCursor(this, this.options))._markError(err);
+    return (new QueryCursor(this, options))._markError(err);
   }
 
-  return new QueryCursor(this, this.options);
+  return new QueryCursor(this, options);
 };
 
 // the rest of these are basically to support older Mongoose syntax with mquery

package/lib/schema/array.js

@@ -146,6 +146,56 @@ SchemaArray.options = { castNonArrays: true };
 SchemaArray.prototype = Object.create(SchemaType.prototype);
 SchemaArray.prototype.constructor = SchemaArray;
 
+/*!
+ * ignore
+ */
+
+SchemaArray._checkRequired = SchemaType.prototype.checkRequired;
+
+/**
+ * Override the function the required validator uses to check whether an array
+ * passes the `required` check.
+ *
+ * ####Example:
+ *
+ *     // Require non-empty array to pass `required` check
+ *     mongoose.Schema.Types.Array.checkRequired(v => Array.isArray(v) && v.length);
+ *
+ *     const M = mongoose.model({ arr: { type: Array, required: true } });
+ *     new M({ arr: [] }).validateSync(); // `null`, validation fails!
+ *
+ * @param {Function} fn
+ * @return {Function}
+ * @function checkRequired
+ * @static
+ * @api public
+ */
+
+SchemaArray.checkRequired = SchemaType.checkRequired;
+
+/**
+ * Check if the given value satisfies the `required` validator.
+ *
+ * @param {Any} value
+ * @param {Document} doc
+ * @return {Boolean}
+ * @api public
+ */
+
+SchemaArray.prototype.checkRequired = function checkRequired(value, doc) {
+  if (SchemaType._isRef(this, value, doc, true)) {
+    return !!value;
+  }
+
+  // `require('util').inherits()` does **not** copy static properties, and
+  // plugins like mongoose-float use `inherits()` for pre-ES6.
+  const _checkRequired = typeof this.constructor.checkRequired == 'function' ?
+    this.constructor.checkRequired() :
+    SchemaArray.checkRequired();
+
+  return _checkRequired(value);
+};
+
 /**
  * Adds an enum validator if this is an array of strings. Equivalent to
  * `SchemaString.prototype.enum()`

package/lib/schema/documentarray.js

@@ -13,6 +13,8 @@ const util = require('util');
 const utils = require('../utils');
 const getDiscriminatorByValue = require('../queryhelpers').getDiscriminatorByValue;
 
+const arrayParentSymbol = require('../helpers/symbols').arrayParentSymbol;
+
 let MongooseDocumentArray;
 let Subdocument;
 
@@ -207,8 +209,8 @@ DocumentArray.prototype.doValidate = function(array, fn, scope, options) {
       // If you set the array index directly, the doc might not yet be
       // a full fledged mongoose subdoc, so make it into one.
       if (!(doc instanceof Subdocument)) {
-        doc = array[i] = new _this.casterConstructor(doc, array, undefined,
-          undefined, i);
+        const Constructor = getConstructor(_this, array[i]);
+        doc = array[i] = new Constructor(doc, array, undefined, undefined, i);
       }
 
       doc.$__validate(callback);
@@ -255,8 +257,8 @@ DocumentArray.prototype.doValidateSync = function(array, scope) {
     // If you set the array index directly, the doc might not yet be
     // a full fledged mongoose subdoc, so make it into one.
     if (!(doc instanceof Subdocument)) {
-      doc = array[i] = new this.casterConstructor(doc, array, undefined,
-        undefined, i);
+      const Constructor = getConstructor(this, array[i]);
+      doc = array[i] = new Constructor(doc, array, undefined, undefined, i);
     }
 
     const subdocValidateError = doc.validateSync();
@@ -290,15 +292,16 @@ DocumentArray.prototype.getDefault = function(scope) {
   }
 
   ret = new MongooseDocumentArray(ret, this.path, scope);
-  const _parent = ret._parent;
-  ret._parent = null;
+  const _parent = ret[arrayParentSymbol];
+  ret[arrayParentSymbol] = null;
 
   for (let i = 0; i < ret.length; ++i) {
-    ret[i] = new this.Constructor(ret[i], ret, undefined,
+    const Constructor = getConstructor(this, ret[i]);
+    ret[i] = new Constructor(ret[i], ret, undefined,
       undefined, i);
   }
 
-  ret._parent = _parent;
+  ret[arrayParentSymbol] = _parent;
 
   return ret;
 };
@@ -349,24 +352,11 @@ DocumentArray.prototype.cast = function(value, doc, init, prev, options) {
       continue;
     }
 
-    let Constructor = this.casterConstructor;
-    if (Constructor.discriminators &&
-        Constructor.schema &&
-        Constructor.schema.options &&
-        typeof value[i][Constructor.schema.options.discriminatorKey] === 'string') {
-      if (Constructor.discriminators[value[i][Constructor.schema.options.discriminatorKey]]) {
-        Constructor = Constructor.discriminators[value[i][Constructor.schema.options.discriminatorKey]];
-      } else {
-        const constructorByValue = getDiscriminatorByValue(Constructor, value[i][Constructor.schema.options.discriminatorKey]);
-        if (constructorByValue) {
-          Constructor = constructorByValue;
-        }
-      }
-    }
+    const Constructor = getConstructor(this, value[i]);
 
     // Check if the document has a different schema (re gh-3701)
     if ((value[i].$__) &&
-        value[i].schema !== Constructor.schema) {
+        !(value[i] instanceof Constructor)) {
       value[i] = value[i].toObject({ transform: false, virtuals: false });
     }
 
@@ -417,6 +407,30 @@ DocumentArray.prototype.cast = function(value, doc, init, prev, options) {
   return value;
 };
 
+/*!
+ * Find the correct subdoc constructor, taking into account discriminators
+ */
+
+function getConstructor(docArray, subdoc) {
+  let Constructor = docArray.casterConstructor;
+  const schema = Constructor.schema;
+  const discriminatorKey = schema.options.discriminatorKey;
+  const discriminatorValue = subdoc[discriminatorKey];
+  if (Constructor.discriminators && typeof discriminatorValue === 'string') {
+    if (Constructor.discriminators[discriminatorValue]) {
+      Constructor = Constructor.discriminators[discriminatorValue];
+    } else {
+      const constructorByValue = getDiscriminatorByValue(Constructor,
+        discriminatorValue);
+      if (constructorByValue) {
+        Constructor = constructorByValue;
+      }
+    }
+  }
+
+  return Constructor;
+}
+
 /*!
  * ignore
  */
@@ -432,12 +446,12 @@ DocumentArray.prototype.clone = function() {
  */
 
 function _clearListeners(arr) {
-  if (arr == null || arr._parent == null) {
+  if (arr == null || arr[arrayParentSymbol] == null) {
     return;
   }
 
   for (const key in arr._handlers) {
-    arr._parent.removeListener(key, arr._handlers[key]);
+    arr[arrayParentSymbol].removeListener(key, arr._handlers[key]);
   }
 }
 

package/lib/schema.js

@@ -1049,11 +1049,12 @@ Schema.prototype.setupTimestamp = function(timestamps) {
 
   _setTimestampsOnUpdate[symbols.builtInMiddleware] = true;
 
-  this.pre('findOneAndUpdate', _setTimestampsOnUpdate);
-  this.pre('replaceOne', _setTimestampsOnUpdate);
-  this.pre('update', _setTimestampsOnUpdate);
-  this.pre('updateOne', _setTimestampsOnUpdate);
-  this.pre('updateMany', _setTimestampsOnUpdate);
+  const opts = { query: true, model: false };
+  this.pre('findOneAndUpdate', opts, _setTimestampsOnUpdate);
+  this.pre('replaceOne', opts, _setTimestampsOnUpdate);
+  this.pre('update', opts, _setTimestampsOnUpdate);
+  this.pre('updateOne', opts, _setTimestampsOnUpdate);
+  this.pre('updateMany', opts, _setTimestampsOnUpdate);
 
   function _setTimestampsOnUpdate(next) {
     const now = this.model.base.now();

package/lib/schematype.js

@@ -10,6 +10,7 @@ const $type = require('./schema/operators/type');
 const get = require('./helpers/get');
 const immediate = require('./helpers/immediate');
 const schemaTypeSymbol = require('./helpers/symbols').schemaTypeSymbol;
+const util = require('util');
 const utils = require('./utils');
 const validatorErrorSymbol = require('./helpers/symbols').validatorErrorSymbol;
 
@@ -50,6 +51,21 @@ function SchemaType(path, options, instance) {
     if (this[prop] && typeof this[prop] === 'function') {
       // { unique: true, index: true }
       if (prop === 'index' && this._index) {
+        if (options.index === false) {
+          const index = this._index;
+          if (typeof index === 'object' && index != null) {
+            if (index.unique) {
+              throw new Error('Path "' + this.path + '" may not have `index` ' +
+                'set to false and `unique` set to true');
+            }
+            if (index.sparse) {
+              throw new Error('Path "' + this.path + '" may not have `index` ' +
+                'set to false and `sparse` set to true');
+            }
+          }
+
+          this._index = false;
+        }
         continue;
       }
 
@@ -262,6 +278,14 @@ SchemaType.prototype.unique = function(bool) {
  */
 
 SchemaType.prototype.text = function(bool) {
+  if (this._index === false) {
+    if (!bool) {
+      return;
+    }
+    throw new Error('Path "' + this.path + '" may not have `index` set to ' +
+      'false and `text` set to true');
+  }
+
   if (this._index === null || this._index === undefined ||
     typeof this._index === 'boolean') {
     this._index = {};
@@ -287,8 +311,15 @@ SchemaType.prototype.text = function(bool) {
  */
 
 SchemaType.prototype.sparse = function(bool) {
-  if (this._index === null || this._index === undefined ||
-    typeof this._index === 'boolean') {
+  if (this._index === false) {
+    if (!bool) {
+      return;
+    }
+    throw new Error('Path "' + this.path + '" may not have `index` set to ' +
+      'false and `sparse` set to true');
+  }
+
+  if (this._index == null || typeof this._index === 'boolean') {
     this._index = {};
   } else if (typeof this._index === 'string') {
     this._index = {type: this._index};
@@ -597,6 +628,11 @@ SchemaType.prototype.validate = function(obj, message, type) {
       }
       properties = {message: message, type: type, validator: obj};
     }
+
+    if (properties.isAsync) {
+      handleIsAsync();
+    }
+
     this.validators.push(properties);
     return this;
   }
@@ -620,6 +656,15 @@ SchemaType.prototype.validate = function(obj, message, type) {
   return this;
 };
 
+/*!
+ * ignore
+ */
+
+const handleIsAsync = util.deprecate(function handleIsAsync() {},
+  'Mongoose: the `isAsync` option for custom validators is deprecated. Make ' +
+  'your async validators return a promise instead: ' +
+  'https://mongoosejs.com/docs/validation.html#async-custom-validators');
+
 /**
  * Adds a required validator to this SchemaType. The validator gets added
  * to the front of this SchemaType's validators array using `unshift()`.
@@ -906,7 +951,7 @@ SchemaType.prototype.select = function select(val) {
  * @api private
  */
 
-SchemaType.prototype.doValidate = function(value, fn, scope) {
+SchemaType.prototype.doValidate = function(value, fn, scope, options) {
   let err = false;
   const path = this.path;
   let count = this.validators.length;
@@ -945,7 +990,7 @@ SchemaType.prototype.doValidate = function(value, fn, scope) {
     let ok;
 
     const validatorProperties = utils.clone(v);
-    validatorProperties.path = path;
+    validatorProperties.path = options && options.path ? options.path : path;
     validatorProperties.value = value;
 
     if (validator instanceof RegExp) {
@@ -1041,7 +1086,7 @@ function asyncValidate(validator, scope, value, props, cb) {
  * @api private
  */
 
-SchemaType.prototype.doValidateSync = function(value, scope) {
+SchemaType.prototype.doValidateSync = function(value, scope, options) {
   let err = null;
   const path = this.path;
   const count = this.validators.length;
@@ -1077,7 +1122,7 @@ SchemaType.prototype.doValidateSync = function(value, scope) {
 
     const validator = v.validator;
     const validatorProperties = utils.clone(v);
-    validatorProperties.path = path;
+    validatorProperties.path = options && options.path ? options.path : path;
     validatorProperties.value = value;
     let ok;