mongoose 5.0.17 → 5.1.2

package/lib/plugins/idGetter.js

@@ -13,18 +13,6 @@ module.exports = function(schema) {
   }
 
   schema.virtual('id').get(idGetter);
-
-  if ('toHexString' in schema.methods) {
-    return;
-  }
-
-  // Re: gh-6115, make it easy to get something usable as an ObjectID regardless
-  // of whether a property is populated or not. With this, you can do
-  // `blogPost.author.toHexString()` and get a hex string regardless of whether
-  // `author` is populated
-  schema.methods.toHexString = function() {
-    return this.id;
-  };
 };
 
 /*!

package/lib/plugins/saveSubdocs.js

@@ -23,7 +23,7 @@ module.exports = function(schema) {
     }
 
     each(subdocs, function(subdoc, cb) {
-      subdoc.save(function(err) {
+      subdoc.save({ suppressWarning: true }, function(err) {
         cb(err);
       });
     }, function(error) {

package/lib/query.js

@@ -10,6 +10,7 @@ const QueryCursor = require('./cursor/QueryCursor');
 const ReadPreference = require('./drivers').ReadPreference;
 const cast = require('./cast');
 const castUpdate = require('./services/query/castUpdate');
+const completeMany = require('./services/query/completeMany');
 const get = require('lodash.get');
 const hasDollarKeys = require('./services/query/hasDollarKeys');
 const helpers = require('./queryhelpers');
@@ -166,7 +167,7 @@ Query.prototype.toConstructor = function toConstructor() {
     Query.call(this, criteria, options || null, model, coll);
   };
 
-  util.inherits(CustomQuery, Query);
+  util.inherits(CustomQuery, model.Query);
 
   // set inherited defaults
   var p = CustomQuery.prototype;
@@ -996,6 +997,7 @@ Query.prototype.read = function read(pref, tags) {
  *
  * The following options are for all operations:
  * - [collation](https://docs.mongodb.com/manual/reference/collation/)
+ * - [session](https://docs.mongodb.com/manual/reference/server-sessions/)
  *
  * @param {Object} options
  * @api public
@@ -1082,6 +1084,11 @@ Query.prototype.getUpdate = function() {
  * @receiver Query
  */
 
+Query.prototype._fieldsForExec = function() {
+  return utils.clone(this._fields);
+};
+
+
 /**
  * Return an update document with corrected $set operations.
  *
@@ -1302,16 +1309,22 @@ Query.prototype._find = function(callback) {
 
   if (this.error() != null) {
     callback(this.error());
-    return this;
+    return null;
   }
 
   this._applyPaths();
   this._fields = this._castFields(this._fields);
 
-  var fields = this._fieldsForExec();
-  var mongooseOptions = this._mongooseOptions;
-  var _this = this;
-  var userProvidedFields = _this._userProvidedFields || {};
+  const fields = this._fieldsForExec();
+  const mongooseOptions = this._mongooseOptions;
+  const _this = this;
+  const userProvidedFields = _this._userProvidedFields || {};
+
+  // Separate options to pass down to `completeMany()` in case we need to
+  // set a session on the document
+  const completeManyOptions = Object.assign({}, {
+    session: get(this, 'options.session', null)
+  });
 
   var cb = function(err, docs) {
     if (err) {
@@ -1325,23 +1338,25 @@ Query.prototype._find = function(callback) {
     if (!mongooseOptions.populate) {
       return !!mongooseOptions.lean === true
         ? callback(null, docs)
-        : completeMany(_this.model, docs, fields, userProvidedFields, null, callback);
+        : completeMany(_this.model, docs, fields, userProvidedFields, completeManyOptions, callback);
     }
 
-    var pop = helpers.preparePopulationOptionsMQ(_this, mongooseOptions);
+    const pop = helpers.preparePopulationOptionsMQ(_this, mongooseOptions);
     pop.__noPromise = true;
+    completeManyOptions.populated = pop;
     _this.model.populate(docs, pop, function(err, docs) {
       if (err) return callback(err);
       return !!mongooseOptions.lean === true
         ? callback(null, docs)
-        : completeMany(_this.model, docs, fields, userProvidedFields, pop, callback);
+        : completeMany(_this.model, docs, fields, userProvidedFields, completeManyOptions, callback);
     });
   };
 
   var options = this._optionsForExec();
   options.fields = this._fieldsForExec();
   var filter = this._conditions;
-  return this._collection.find(filter, options, cb);
+  this._collection.find(filter, options, cb);
+  return null;
 };
 
 /**
@@ -1436,43 +1451,6 @@ Query.prototype.merge = function(source) {
   return this;
 };
 
-/*!
- * hydrates many documents
- *
- * @param {Model} model
- * @param {Array} docs
- * @param {Object} fields
- * @param {Query} self
- * @param {Array} [pop] array of paths used in population
- * @param {Function} callback
- */
-
-function completeMany(model, docs, fields, userProvidedFields, pop, callback) {
-  var arr = [];
-  var count = docs.length;
-  var len = count;
-  var opts = pop ? { populated: pop } : undefined;
-  var error = null;
-  function init(_error) {
-    if (_error != null) {
-      error = error || _error;
-    }
-    if (error != null) {
-      --count || process.nextTick(() => callback(error));
-      return;
-    }
-    --count || process.nextTick(() => callback(error, arr));
-  }
-  for (var i = 0; i < len; ++i) {
-    arr[i] = helpers.createModel(model, docs[i], fields, userProvidedFields);
-    try {
-      arr[i].init(docs[i], opts, init);
-    } catch (error) {
-      init(error);
-    }
-  }
-}
-
 /**
  * Adds a collation to this op (MongoDB 3.4 and up)
  *
@@ -1490,6 +1468,44 @@ Query.prototype.collation = function(value) {
   return this;
 };
 
+/**
+ * Hydrate a single doc from `findOne()`, `findOneAndUpdate()`, etc.
+ *
+ * @api private
+ */
+
+Query.prototype._completeOne = function(doc, res, callback) {
+  if (!doc) {
+    return callback(null, null);
+  }
+
+  const model = this.model;
+  const projection = utils.clone(this._fields);
+  const userProvidedFields = this._userProvidedFields || {};
+  // `populate`, `lean`
+  const mongooseOptions = this._mongooseOptions;
+  // `rawResult`
+  const options = this.options;
+
+  if (!mongooseOptions.populate) {
+    return mongooseOptions.lean ?
+      _completeOneLean(doc, res, options, callback) :
+      completeOne(model, doc, res, options, projection, userProvidedFields,
+        null, callback);
+  }
+
+  const pop = helpers.preparePopulationOptionsMQ(this, this._mongooseOptions);
+  model.populate(doc, pop, (err, doc) => {
+    if (err) {
+      return callback(err);
+    }
+    return mongooseOptions.lean ?
+      _completeOneLean(doc, res, options, callback) :
+      completeOne(model, doc, res, options, projection, userProvidedFields,
+        pop, callback);
+  });
+};
+
 /**
  * Thunk around findOne()
  *
@@ -1502,42 +1518,21 @@ Query.prototype._findOne = function(callback) {
   this._castConditions();
 
   if (this.error()) {
-    return callback(this.error());
+    callback(this.error());
+    return null;
   }
 
   this._applyPaths();
   this._fields = this._castFields(this._fields);
 
-  var options = this._mongooseOptions;
-  var projection = this._fieldsForExec();
-  var userProvidedFields = this._userProvidedFields || {};
-  var _this = this;
-
   // don't pass in the conditions because we already merged them in
-  Query.base.findOne.call(_this, {}, function(err, doc) {
+  Query.base.findOne.call(this, {}, (err, doc) => {
     if (err) {
-      return callback(err);
-    }
-    if (!doc) {
-      return callback(null, null);
-    }
-
-    if (!options.populate) {
-      return !!options.lean === true
-        ? callback(null, doc)
-        : completeOne(_this.model, doc, null, {}, projection, userProvidedFields, null, callback);
+      callback(err);
+      return null;
     }
 
-    var pop = helpers.preparePopulationOptionsMQ(_this, options);
-    pop.__noPromise = true;
-    _this.model.populate(doc, pop, function(err, doc) {
-      if (err) {
-        return callback(err);
-      }
-      return !!options.lean === true
-        ? callback(null, doc)
-        : completeOne(_this.model, doc, null, {}, projection, userProvidedFields, pop, callback);
-    });
+    this._completeOne(doc, null, callback);
   });
 };
 
@@ -2015,6 +2010,8 @@ function completeOne(model, doc, res, options, fields, userProvidedFields, pop,
       return process.nextTick(() => callback(err));
     }
 
+    casted.$session(options.session);
+
     if (options.rawResult) {
       res.value = casted;
       return process.nextTick(() => callback(null, res));
@@ -2167,7 +2164,6 @@ Query.prototype._findOneAndUpdate = function(callback) {
   }
 
   this._findAndModify('update', callback);
-  return this;
 };
 
 /**
@@ -2247,6 +2243,128 @@ Query.prototype.findOneAndRemove = function(conditions, options, callback) {
   return this;
 };
 
+/**
+ * Issues a MongoDB [findOneAndDelete](https://docs.mongodb.com/manual/reference/method/db.collection.findOneAndDelete/) command.
+ *
+ * Finds a matching document, removes it, and passes the found document (if any) to the callback. Executes immediately if `callback` is passed.
+ *
+ * This function triggers the following middleware.
+ *
+ * - `findOneAndDelete()`
+ *
+ * This function differs slightly from `Model.findOneAndRemove()` in that
+ * `findOneAndRemove()` becomes a [MongoDB `findAndModify()` command](https://docs.mongodb.com/manual/reference/method/db.collection.findAndModify/),
+ * as opposed to a `findOneAndDelete()` command. For most mongoose use cases,
+ * this distinction is purely pedantic. You should use `findOneAndDelete()`
+ * unless you have a good reason not to.
+ *
+ * ####Available options
+ *
+ * - `sort`: if multiple docs are found by the conditions, sets the sort order to choose which doc to update
+ * - `maxTimeMS`: puts a time limit on the query - requires mongodb >= 2.6.0
+ * - `rawResult`: if true, resolves to the [raw result from the MongoDB driver](http://mongodb.github.io/node-mongodb-native/2.0/api/Collection.html#findAndModify)
+ *
+ * ####Callback Signature
+ *     function(error, doc) {
+ *       // error: any errors that occurred
+ *       // doc: the document before updates are applied if `new: false`, or after updates if `new = true`
+ *     }
+ *
+ * ####Examples
+ *
+ *     A.where().findOneAndDelete(conditions, options, callback) // executes
+ *     A.where().findOneAndDelete(conditions, options)  // return Query
+ *     A.where().findOneAndDelete(conditions, callback) // executes
+ *     A.where().findOneAndDelete(conditions) // returns Query
+ *     A.where().findOneAndDelete(callback)   // executes
+ *     A.where().findOneAndDelete()           // returns Query
+ *
+ * @method findOneAndDelete
+ * @memberOf Query
+ * @param {Object} [conditions]
+ * @param {Object} [options]
+ * @param {Boolean} [options.rawResult] if true, returns the [raw result from the MongoDB driver](http://mongodb.github.io/node-mongodb-native/2.0/api/Collection.html#findAndModify)
+ * @param {Boolean|String} [options.strict] overwrites the schema's [strict mode option](http://mongoosejs.com/docs/guide.html#strict)
+ * @param {Function} [callback] optional params are (error, document)
+ * @return {Query} this
+ * @see mongodb http://www.mongodb.org/display/DOCS/findAndModify+Command
+ * @api public
+ */
+
+Query.prototype.findOneAndDelete = function(conditions, options, callback) {
+  this.op = 'findOneAndDelete';
+  this._validate();
+
+  switch (arguments.length) {
+    case 2:
+      if (typeof options === 'function') {
+        callback = options;
+        options = {};
+      }
+      break;
+    case 1:
+      if (typeof conditions === 'function') {
+        callback = conditions;
+        conditions = undefined;
+        options = undefined;
+      }
+      break;
+  }
+
+  if (mquery.canMerge(conditions)) {
+    this.merge(conditions);
+  }
+
+  options && this.setOptions(options);
+
+  if (!callback) {
+    return this;
+  }
+
+  this._findOneAndDelete(callback);
+
+  return this;
+};
+
+/*!
+ * Thunk around findOneAndDelete()
+ *
+ * @param {Function} [callback]
+ * @return {Query} this
+ * @api private
+ */
+Query.prototype._findOneAndDelete = function(callback) {
+  this._castConditions();
+
+  if (this.error() != null) {
+    callback(this.error());
+    return null;
+  }
+
+  const filter = this._conditions;
+  const options = this._optionsForExec();
+  let fields = null;
+
+  if (this._fields != null) {
+    options.projection = this._castFields(utils.clone(this._fields));
+    fields = options.projection;
+    if (fields instanceof Error) {
+      callback(fields);
+      return null;
+    }
+  }
+
+  this._collection.collection.findOneAndDelete(filter, options, (err, res) => {
+    if (err) {
+      return callback(err);
+    }
+
+    const doc = res.value;
+
+    return this._completeOne(doc, res, callback);
+  });
+};
+
 /*!
  * Thunk around findOneAndRemove()
  *
@@ -2256,10 +2374,11 @@ Query.prototype.findOneAndRemove = function(conditions, options, callback) {
  */
 Query.prototype._findOneAndRemove = function(callback) {
   if (this.error() != null) {
-    return callback(this.error());
+    callback(this.error());
+    return;
   }
 
-  Query.base.findOneAndRemove.call(this, callback);
+  this._findAndModify('remove', callback);
 };
 
 /*!
@@ -2346,7 +2465,6 @@ Query.prototype._findAndModify = function(type, callback) {
   }
 
   this._applyPaths();
-  var userProvidedFields = this._userProvidedFields || {};
 
   var options = this._mongooseOptions;
 
@@ -2365,32 +2483,7 @@ Query.prototype._findAndModify = function(type, callback) {
       return callback(err);
     }
 
-    if (!doc || (utils.isObject(doc) && Object.keys(doc).length === 0)) {
-      if (opts.rawResult) {
-        return callback(null, res);
-      }
-      return callback(null, null);
-    }
-
-    if (!options.populate) {
-      if (!!options.lean === true) {
-        return _completeOneLean(doc, res, opts, callback);
-      }
-      return completeOne(_this.model, doc, res, opts, fields, userProvidedFields, null, callback);
-    }
-
-    var pop = helpers.preparePopulationOptionsMQ(_this, options);
-    pop.__noPromise = true;
-    _this.model.populate(doc, pop, function(err, doc) {
-      if (err) {
-        return callback(err);
-      }
-
-      if (!!options.lean === true) {
-        return _completeOneLean(doc, res, opts, callback);
-      }
-      return completeOne(_this.model, doc, res, opts, fields, userProvidedFields, pop, callback);
-    });
+    _this._completeOne(doc, res, callback);
   };
 
   var _callback;
@@ -2550,7 +2643,7 @@ function _updateThunk(op, callback) {
 
   if (this.error() != null) {
     callback(this.error());
-    return this;
+    return null;
   }
 
   var castedQuery = this._conditions;
@@ -2566,12 +2659,12 @@ function _updateThunk(op, callback) {
 
     if (castedDoc instanceof Error) {
       callback(castedDoc);
-      return this;
+      return null;
     }
 
     if (castedDoc == null || Object.keys(castedDoc).length === 0) {
       callback(null, 0);
-      return this;
+      return null;
     }
 
     castedDoc = setDefaultsOnInsert(this._conditions, this.model.schema,
@@ -2603,7 +2696,7 @@ function _updateThunk(op, callback) {
         callback(err);
       });
     }
-    return this;
+    return null;
   }
 
   if (castedDoc.toBSON) {
@@ -2611,7 +2704,7 @@ function _updateThunk(op, callback) {
   }
 
   this._collection[op](castedQuery, castedDoc, options, callback);
-  return this;
+  return null;
 }
 
 /*!

package/lib/queryhelpers.js

@@ -1,11 +1,12 @@
+'use strict';
 
 /*!
  * Module dependencies
  */
 
-var get = require('lodash.get');
-var isDefiningProjection = require('./services/projection/isDefiningProjection');
-var utils = require('./utils');
+const get = require('lodash.get');
+const isDefiningProjection = require('./services/projection/isDefiningProjection');
+const utils = require('./utils');
 
 /*!
  * Prepare a set of path options for query population.
@@ -16,7 +17,7 @@ var utils = require('./utils');
  */
 
 exports.preparePopulationOptions = function preparePopulationOptions(query, options) {
-  var pop = utils.object.vals(query.options.populate);
+  const pop = utils.object.vals(query.options.populate);
 
   // lean options should trickle through all queries
   if (options.lean) {
@@ -36,7 +37,7 @@ exports.preparePopulationOptions = function preparePopulationOptions(query, opti
  */
 
 exports.preparePopulationOptionsMQ = function preparePopulationOptionsMQ(query, options) {
-  var pop = utils.object.vals(query._mongooseOptions.populate);
+  const pop = utils.object.vals(query._mongooseOptions.populate);
 
   // lean options should trickle through all queries
   if (options.lean) {
@@ -54,12 +55,12 @@ exports.preparePopulationOptionsMQ = function preparePopulationOptionsMQ(query,
  * @param {string} value
  */
 function getDiscriminatorByValue(model, value) {
-  var discriminator = null;
+  let discriminator = null;
   if (!model.discriminators) {
     return discriminator;
   }
-  for (var name in model.discriminators) {
-    var it = model.discriminators[name];
+  for (const name in model.discriminators) {
+    const it = model.discriminators[name];
     if (
       it.schema &&
       it.schema.discriminatorMapping &&
@@ -85,37 +86,63 @@ exports.getDiscriminatorByValue = getDiscriminatorByValue;
  * @return {Model}
  */
 exports.createModel = function createModel(model, doc, fields, userProvidedFields) {
-  var discriminatorMapping = model.schema
-    ? model.schema.discriminatorMapping
-    : null;
+  const discriminatorMapping = model.schema ?
+    model.schema.discriminatorMapping :
+    null;
 
-  var key = discriminatorMapping && discriminatorMapping.isRoot
-    ? discriminatorMapping.key
-    : null;
+  const key = discriminatorMapping && discriminatorMapping.isRoot ?
+    discriminatorMapping.key :
+    null;
 
-  var value = doc[key];
+  const value = doc[key];
   if (key && value && model.discriminators) {
-    var discriminator = model.discriminators[value] || getDiscriminatorByValue(model, value);
+    const discriminator = model.discriminators[value] || getDiscriminatorByValue(model, value);
     if (discriminator) {
-      var _fields = utils.clone(userProvidedFields);
+      const _fields = utils.clone(userProvidedFields);
       exports.applyPaths(_fields, discriminator.schema);
       return new discriminator(undefined, _fields, true);
     }
   }
 
-  return new model(undefined, fields, { skipId: true, isNew: false });
+  const skipDefaults = gatherPaths(doc, {}, '');
+  return new model(undefined, fields, {
+    skipId: true,
+    isNew: false,
+    skipDefaults: skipDefaults
+  });
 };
 
+/*!
+ *
+ */
+
+function gatherPaths(obj, map, path) {
+  for (const key of Object.keys(obj)) {
+    const fullPath = path ? path + '.' + key : key;
+    map[fullPath] = true;
+    if (obj[key] != null &&
+        typeof obj[key] === 'object' &&
+        !Array.isArray(obj) &&
+        !(obj instanceof Map) &&
+        !obj[key]._bsontype &&
+        !utils.isMongooseObject(obj[key])) {
+      gatherPaths(obj[key], map, fullPath);
+    }
+  }
+
+  return map;
+}
+
 /*!
  * ignore
  */
 
 exports.applyPaths = function applyPaths(fields, schema) {
   // determine if query is selecting or excluding fields
-  var exclude;
-  var keys;
-  var ki;
-  var field;
+  let exclude;
+  let keys;
+  let ki;
+  let field;
 
   if (fields) {
     keys = Object.keys(fields);
@@ -138,11 +165,11 @@ exports.applyPaths = function applyPaths(fields, schema) {
   // if selecting, apply default schematype select:true fields
   // if excluding, apply schematype select:false fields
 
-  var selected = [];
-  var excluded = [];
-  var stack = [];
+  let selected = [];
+  let excluded = [];
+  let stack = [];
 
-  var analyzePath = function(path, type) {
+  let analyzePath = function(path, type) {
     if (typeof type.selected !== 'boolean') return;
 
     var plusPath = '+' + path;
@@ -160,8 +187,8 @@ exports.applyPaths = function applyPaths(fields, schema) {
     }
 
     // check for parent exclusions
-    var pieces = path.split('.');
-    var root = pieces[0];
+    let pieces = path.split('.');
+    let root = pieces[0];
     if (~excluded.indexOf(root)) {
       return;
     }
@@ -170,10 +197,10 @@ exports.applyPaths = function applyPaths(fields, schema) {
     // don't explicitly project in the discriminator key because that will
     // project out everything else under the parent path
     if (!exclude && get(type, 'options.$skipDiscriminatorCheck', false)) {
-      var cur = '';
-      for (var i = 0; i < pieces.length; ++i) {
+      let cur = '';
+      for (let i = 0; i < pieces.length; ++i) {
         cur += (cur.length === 0 ? '' : '.') + pieces[i];
-        var projection = get(fields, cur, false);
+        const projection = get(fields, cur, false);
         if (projection && typeof projection !== 'object') {
           return;
         }
@@ -208,7 +235,7 @@ exports.applyPaths = function applyPaths(fields, schema) {
 
   analyzeSchema(schema);
 
-  var i;
+  let i;
   switch (exclude) {
     case true:
       for (i = 0; i < excluded.length; ++i) {

package/lib/schema/array.js

@@ -221,8 +221,8 @@ SchemaArray.prototype.cast = function(value, doc, init) {
  */
 
 SchemaArray.prototype.castForQuery = function($conditional, value) {
-  var handler,
-      val;
+  var handler;
+  var val;
 
   if (arguments.length === 2) {
     handler = this.$conditionalHandlers[$conditional];
@@ -355,13 +355,16 @@ handle.$type = $type;
 handle.$eq =
 handle.$gt =
 handle.$gte =
-handle.$in =
 handle.$lt =
 handle.$lte =
 handle.$ne =
 handle.$nin =
 handle.$regex = SchemaArray.prototype.castForQuery;
 
+// `$in` is special because you can also include an empty array in the query
+// like `$in: [1, []]`, see gh-5913
+handle.$in = SchemaType.prototype.$conditionalHandlers.$in;
+
 /*!
  * Module exports.
  */