mongoose 5.0.18 → 5.1.0

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');
@@ -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.
  *
@@ -1308,10 +1315,16 @@ Query.prototype._find = function(callback) {
   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,16 +1338,17 @@ 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);
     });
   };
 
@@ -1436,43 +1450,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 +1467,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()
  *
@@ -1508,36 +1523,13 @@ Query.prototype._findOne = function(callback) {
   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);
-    }
 
-    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 +2007,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));
@@ -2247,6 +2241,130 @@ 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 this;
+  }
+
+  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 this;
+    }
+  }
+
+  this._collection.collection.findOneAndDelete(filter, options, (err, res) => {
+    if (err) {
+      return callback(err);
+    }
+
+    const doc = res.value;
+
+    return this._completeOne(doc, res, callback);
+  });
+
+  return this;
+};
+
 /*!
  * Thunk around findOneAndRemove()
  *
@@ -2259,7 +2377,9 @@ Query.prototype._findOneAndRemove = function(callback) {
     return callback(this.error());
   }
 
-  Query.base.findOneAndRemove.call(this, callback);
+  this._findAndModify('remove', callback);
+
+  return this;
 };
 
 /*!
@@ -2346,7 +2466,6 @@ Query.prototype._findAndModify = function(type, callback) {
   }
 
   this._applyPaths();
-  var userProvidedFields = this._userProvidedFields || {};
 
   var options = this._mongooseOptions;
 
@@ -2365,32 +2484,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;

package/lib/queryhelpers.js

@@ -4,9 +4,9 @@
  * 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.
@@ -17,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) {
@@ -37,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) {
@@ -55,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 &&
@@ -123,7 +123,9 @@ function gatherPaths(obj, map, path) {
     if (obj[key] != null &&
         typeof obj[key] === 'object' &&
         !Array.isArray(obj) &&
-        !obj[key]._bsontype) {
+        !(obj instanceof Map) &&
+        !obj[key]._bsontype &&
+        !utils.isMongooseObject(obj[key])) {
       gatherPaths(obj[key], map, fullPath);
     }
   }
@@ -137,10 +139,10 @@ function gatherPaths(obj, map, path) {
 
 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);
@@ -163,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;
@@ -185,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;
     }
@@ -195,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;
         }
@@ -233,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.
  */

package/lib/schema/embedded.js

@@ -219,7 +219,7 @@ Embedded.prototype.castForQuery = function($conditional, val) {
  * @api private
  */
 
-Embedded.prototype.doValidate = function(value, fn, scope) {
+Embedded.prototype.doValidate = function(value, fn, scope, options) {
   var Constructor = this.caster;
   var discriminatorKey = Constructor.schema.options.discriminatorKey;
   if (value != null &&
@@ -235,6 +235,13 @@ Embedded.prototype.doValidate = function(value, fn, scope) {
     }
   }
 
+  if (options && options.skipSchemaValidators) {
+    if (!(value instanceof Constructor)) {
+      value = new Constructor(value, null, scope);
+    }
+
+    return value.validate(fn);
+  }
 
   SchemaType.prototype.doValidate.call(this, value, function(error) {
     if (error) {
@@ -244,10 +251,7 @@ Embedded.prototype.doValidate = function(value, fn, scope) {
       return fn(null);
     }
 
-    if (!(value instanceof Constructor)) {
-      value = new Constructor(value);
-    }
-    value.validate({__noPromise: true}, fn);
+    value.validate(fn);
   }, scope);
 };
 
@@ -257,10 +261,12 @@ Embedded.prototype.doValidate = function(value, fn, scope) {
  * @api private
  */
 
-Embedded.prototype.doValidateSync = function(value, scope) {
-  var schemaTypeError = SchemaType.prototype.doValidateSync.call(this, value, scope);
-  if (schemaTypeError) {
-    return schemaTypeError;
+Embedded.prototype.doValidateSync = function(value, scope, options) {
+  if (!options || !options.skipSchemaValidators) {
+    var schemaTypeError = SchemaType.prototype.doValidateSync.call(this, value, scope);
+    if (schemaTypeError) {
+      return schemaTypeError;
+    }
   }
   if (!value) {
     return;

package/lib/schema/index.js

@@ -25,6 +25,8 @@ exports.Mixed = require('./mixed');
 
 exports.Decimal128 = exports.Decimal = require('./decimal128');
 
+exports.Map = require('./map');
+
 // alias
 
 exports.Oid = exports.ObjectId;

package/lib/schema/map.js

@@ -0,0 +1,29 @@
+'use strict';
+
+/*!
+ * ignore
+ */
+
+const MongooseMap = require('../types/map');
+const SchemaType = require('../schematype');
+
+/*!
+ * ignore
+ */
+
+class SchemaMap extends SchemaType {
+  constructor(key, options) {
+    super(key, options, 'Map');
+    this.$isSchemaMap = true;
+  }
+
+  cast(val, doc) {
+    if (val instanceof MongooseMap) {
+      return val;
+    }
+
+    return new MongooseMap(val, this.path, doc, this.$__schemaType);
+  }
+}
+
+module.exports = SchemaMap;

package/lib/schema/objectid.js

@@ -178,26 +178,6 @@ ObjectId.prototype.$conditionalHandlers =
       $lte: handleSingle
     });
 
-/**
- * Casts contents for queries.
- *
- * @param {String} $conditional
- * @param {any} [val]
- * @api private
- */
-
-ObjectId.prototype.castForQuery = function($conditional, val) {
-  var handler;
-  if (arguments.length === 2) {
-    handler = this.$conditionalHandlers[$conditional];
-    if (!handler) {
-      throw new Error('Can\'t use ' + $conditional + ' with ObjectId.');
-    }
-    return handler.call(this, val);
-  }
-  return this._castForQuery($conditional);
-};
-
 /*!
  * ignore
  */