mongoose 4.12.6 → 4.13.3

package/.travis.yml

@@ -1,6 +1,7 @@
 language: node_js
 sudo: false
 node_js:
+  - "8"
   - "7"
   - "6"
   - "5"

package/History.md

@@ -1,3 +1,36 @@
+4.13.3 / 2017-11-15
+===================
+ * chore: add node 8 to travis #5818 [superheri](https://github.com/superheri)
+ * fix(document): don't apply transforms to nested docs when updating already saved doc #5807
+
+4.13.2 / 2017-11-11
+===================
+ * feat(buffer): add support for subtype prop #5530
+
+4.13.1 / 2017-11-08
+===================
+ * fix: accept multiple paths or array of paths to depopulate #5798 #5797 [adamreisnz](https://github.com/adamreisnz)
+ * fix(document): pass default array as actual array rather than taking first element #5780
+ * fix(model): increment version when $set-ing it in a save() that requires a version bump #5779
+ * fix(query): don't explicitly project in discriminator key if user projected in parent path #5775 #5754
+ * fix(model): cast query option to geoNear() #5765
+ * fix(query): don't treat projection with just $slice as inclusive #5737
+ * fix(discriminator): defer applying embedded discriminator hooks until top-level model is compiled #5706
+ * docs(discriminator): add warning to always attach hooks before calling discriminator() #5706
+
+4.13.0 / 2017-11-02
+===================
+ * feat(aggregate): add $addFields helper #5740 [AyushG3112](https://github.com/AyushG3112)
+ * feat(connection): add connection-level bufferCommands #5720
+ * feat(connection): add createCollection() helper #5712
+ * feat(populate): support setting localField and foreignField to functions #5704 #5602
+ * feat(query): add multipleCastError option for aggregating cast errors when casting update #5609
+ * feat(populate): allow passing a function to virtual ref #5602
+ * feat(schema): add excludeIndexes option to optionally prevent collecting indexes from nested schemas #5575
+ * feat(model): report validation errors from `insertMany()` if using `ordered: false` and `rawResult: true` #5337
+ * feat(aggregate): add pre/post aggregate middleware #5251
+ * feat(schema): allow using `set` as a schema path #1939
+
 4.12.6 / 2017-11-01
 ===================
  * fix(schema): make clone() copy query helpers correctly #5752

package/lib/aggregate.js

@@ -106,6 +106,41 @@ Aggregate.prototype.append = function() {
   return this;
 };
 
+/**
+ * Appends a new $addFields operator to this aggregate pipeline.
+ * Requires MongoDB v3.4+ to work
+ *
+ * ####Examples:
+  *
+ *     // adding new fields based on existing fields
+ *     aggregate.addFields({
+ *         newField: '$b.nested'
+ *       , plusTen: { $add: ['$val', 10]}
+ *       , sub: {
+ *            name: '$a'
+ *         }
+ *     })
+ *
+ *     // etc
+ *     aggregate.addFields({ salary_k: { $divide: [ "$salary", 1000 ] } });
+ *
+ * @param {Object} arg field specification
+ * @see $addFields https://docs.mongodb.com/manual/reference/operator/aggregation/addFields/
+ * @return {Aggregate}
+ * @api public
+ */
+Aggregate.prototype.addFields = function(arg) {
+  var fields = {};
+  if (typeof arg === 'object' && !util.isArray(arg)) {
+    Object.keys(arg).forEach(function(field) {
+      fields[field] = arg[field];
+    });
+  } else {
+    throw new Error('Invalid addFields() argument. Must be an object');
+  }
+  return this.append({$addFields: fields});
+};
+
 /**
  * Appends a new $project operator to this aggregate pipeline.
  *
@@ -625,26 +660,27 @@ Aggregate.prototype.exec = function(callback) {
     throw new Error('Aggregate not bound to any Model');
   }
   var _this = this;
+  var model = this._model;
   var Promise = PromiseProvider.get();
-  var options = utils.clone(this.options);
+  var options = utils.clone(this.options || {});
+  var pipeline = this._pipeline;
+  var collection = this._model.collection;
 
   if (options && options.cursor) {
     if (options.cursor.async) {
       delete options.cursor.async;
       return new Promise.ES6(function(resolve) {
-        if (!_this._model.collection.buffer) {
+        if (!collection.buffer) {
           process.nextTick(function() {
-            var cursor = _this._model.collection.
-              aggregate(_this._pipeline, options || {});
+            var cursor = collection.aggregate(pipeline, options);
             decorateCursor(cursor);
             resolve(cursor);
             callback && callback(null, cursor);
           });
           return;
         }
-        _this._model.collection.emitter.once('queue', function() {
-          var cursor = _this._model.collection.
-            aggregate(_this._pipeline, options || {});
+        collection.emitter.once('queue', function() {
+          var cursor = collection.aggregate(pipeline, options);
           decorateCursor(cursor);
           resolve(cursor);
           callback && callback(null, cursor);
@@ -654,14 +690,13 @@ Aggregate.prototype.exec = function(callback) {
       delete options.cursor.useMongooseAggCursor;
       return new AggregationCursor(this);
     }
-    var cursor = this._model.collection.
-      aggregate(this._pipeline, this.options || {});
+    var cursor = collection.aggregate(pipeline, options);
     decorateCursor(cursor);
     return cursor;
   }
 
   return new Promise.ES6(function(resolve, reject) {
-    if (!_this._pipeline.length) {
+    if (!pipeline.length) {
       var err = new Error('Aggregate has empty pipeline');
       if (callback) {
         callback(err);
@@ -672,9 +707,20 @@ Aggregate.prototype.exec = function(callback) {
 
     prepareDiscriminatorPipeline(_this);
 
-    _this._model
-        .collection
-        .aggregate(_this._pipeline, _this.options || {}, function(error, result) {
+    model.hooks.execPre('aggregate', _this, function(error) {
+      if (error) {
+        var _opts = { error: error };
+        return model.hooks.execPost('aggregate', _this, [null], _opts, function(error) {
+          if (callback) {
+            callback(error);
+          }
+          reject(error);
+        });
+      }
+
+      collection.aggregate(pipeline, options, function(error, result) {
+        var _opts = { error: error };
+        model.hooks.execPost('aggregate', _this, [result], _opts, function(error, result) {
           if (error) {
             if (callback) {
               callback(error);
@@ -688,6 +734,8 @@ Aggregate.prototype.exec = function(callback) {
           }
           resolve(result);
         });
+      });
+    });
   });
 };
 
@@ -758,6 +806,8 @@ function isOperator(obj) {
  * @param {Aggregate} aggregate Aggregate to prepare
  */
 
+Aggregate._prepareDiscriminatorPipeline = prepareDiscriminatorPipeline;
+
 function prepareDiscriminatorPipeline(aggregate) {
   var schema = aggregate._model.schema,
       discriminatorMapping = schema && schema.discriminatorMapping;
@@ -781,12 +831,11 @@ function prepareDiscriminatorPipeline(aggregate) {
     } else {
       var match = {};
       match[discriminatorKey] = discriminatorValue;
-      aggregate._pipeline = [{$match: match}].concat(originalPipeline);
+      aggregate._pipeline.unshift({ $match: match });
     }
   }
 }
 
-
 /*!
  * Exports
  */

package/lib/cast.js

@@ -10,7 +10,7 @@ var utils = require('./utils');
 var ALLOWED_GEOWITHIN_GEOJSON_TYPES = ['Polygon', 'MultiPolygon'];
 
 /**
- * Handles internal casting for queries
+ * Handles internal casting for query filters.
  *
  * @param {Schema} schema
  * @param {Object} obj Object to cast

package/lib/connection.js

@@ -368,6 +368,28 @@ Connection.prototype._openWithoutPromise = function() {
   });
 };
 
+/**
+ * Helper for `createCollection()`. Will explicitly create the given collection
+ * with specified options. Used to create [capped collections](https://docs.mongodb.com/manual/core/capped-collections/)
+ * and [views](https://docs.mongodb.com/manual/core/views/) from mongoose.
+ *
+ * Options are passed down without modification to the [MongoDB driver's `createCollection()` function](http://mongodb.github.io/node-mongodb-native/2.2/api/Db.html#createCollection)
+ *
+ * @param {string} collection The collection to delete
+ * @param {Object} [options] see [MongoDB driver docs](http://mongodb.github.io/node-mongodb-native/2.2/api/Db.html#createCollection)
+ * @param {Function} [callback]
+ * @return {Promise}
+ * @api public
+ */
+
+Connection.prototype.createCollection = _wrapConnHelper(function createCollection(collection, options, cb) {
+  if (typeof options === 'function') {
+    cb = options;
+    options = {};
+  }
+  this.db.createCollection(collection, options, cb);
+});
+
 /**
  * Helper for `dropCollection()`. Will delete the given collection, including
  * all documents and indexes.
@@ -403,8 +425,10 @@ function _wrapConnHelper(fn) {
   return function() {
     var _this = this;
     var Promise = PromiseProvider.get();
-    var argsWithoutCb = Array.prototype.slice.call(arguments, 0, fn.length - 1);
-    var cb = arguments[arguments.length - 1];
+    var cb = arguments.length > 0 ? arguments[arguments.length - 1] : null;
+    var argsWithoutCb = typeof cb === 'function' ?
+      Array.prototype.slice.call(arguments, 0, arguments.length - 1) :
+      Array.prototype.slice.call(arguments);
     var promise = new Promise.ES6(function(resolve, reject) {
       if (_this.readyState !== STATES.connected) {
         _this.on('open', function() {
@@ -782,6 +806,12 @@ Connection.prototype.openUri = function(uri, options, callback) {
       this.user = options.auth.user;
       this.pass = options.auth.password;
     }
+
+    if (options.bufferCommands != null) {
+      options.bufferMaxEntries = 0;
+      this.config.bufferCommands = options.bufferCommands;
+      delete options.bufferCommands;
+    }
   }
 
   this._connectionOptions = options;

package/lib/cursor/AggregationCursor.js

@@ -14,6 +14,9 @@ var util = require('util');
  * in addition to several other mechanisms for loading documents from MongoDB
  * one at a time.
  *
+ * Creating an AggregationCursor executes the model's pre aggregate hooks,
+ * but **not** the model's post aggregate hooks.
+ *
  * Unless you're an advanced user, do **not** instantiate this class directly.
  * Use [`Aggregate#cursor()`](/docs/api.html#aggregate_Aggregate-cursor) instead.
  *
@@ -47,13 +50,17 @@ util.inherits(AggregationCursor, Readable);
 
 function _init(model, c, agg) {
   if (!model.collection.buffer) {
-    c.cursor = model.collection.aggregate(agg._pipeline, agg.options || {});
-    c.emit('cursor', c.cursor);
-  } else {
-    model.collection.emitter.once('queue', function() {
+    model.hooks.execPre('aggregate', agg, function() {
       c.cursor = model.collection.aggregate(agg._pipeline, agg.options || {});
       c.emit('cursor', c.cursor);
     });
+  } else {
+    model.collection.emitter.once('queue', function() {
+      model.hooks.execPre('aggregate', agg, function() {
+        c.cursor = model.collection.aggregate(agg._pipeline, agg.options || {});
+        c.emit('cursor', c.cursor);
+      });
+    });
   }
 }
 

package/lib/document.js

@@ -74,7 +74,7 @@ function Document(obj, fields, skipId, options) {
     if (this.$__original_set) {
       this.$__original_set(obj, undefined, true);
     } else {
-      this.set(obj, undefined, true);
+      this.$set(obj, undefined, true);
     }
   }
 
@@ -435,8 +435,18 @@ function init(self, obj, doc, prefix) {
  */
 
 for (var k in hooks) {
-  if (k === 'pre' || k === 'post') {
+  if (k === 'post') {
     Document.prototype['$' + k] = Document['$' + k] = hooks[k];
+  } else if (k === 'pre') {
+    Document.prototype.$pre = Document.$pre = function mongoosePreWrapper() {
+      if (arguments[0] === 'set') {
+        // Make set hooks also work for `$set`
+        var $setArgs = Array.prototype.slice.call(arguments);
+        $setArgs[0] = '$set';
+        hooks.pre.apply(this, $setArgs);
+      }
+      return hooks.pre.apply(this, arguments);
+    };
   } else {
     Document.prototype[k] = Document[k] = hooks[k];
   }
@@ -468,29 +478,7 @@ Document.prototype.update = function update() {
 };
 
 /**
- * Sets the value of a path, or many paths.
- *
- * ####Example:
- *
- *     // path, value
- *     doc.set(path, value)
- *
- *     // object
- *     doc.set({
- *         path  : value
- *       , path2 : {
- *            path  : value
- *         }
- *     })
- *
- *     // on-the-fly cast to number
- *     doc.set(path, value, Number)
- *
- *     // on-the-fly cast to string
- *     doc.set(path, value, String)
- *
- *     // changing strict mode behavior
- *     doc.set(path, value, { strict: false });
+ * Alias for `set()`, used internally to avoid conflicts
  *
  * @param {String|Object} path path or object of key/vals to set
  * @param {Any} val the value to set
@@ -499,7 +487,7 @@ Document.prototype.update = function update() {
  * @api public
  */
 
-Document.prototype.set = function(path, val, type, options) {
+Document.prototype.$set = function(path, val, type, options) {
   if (type && utils.getFunctionName(type.constructor) === 'Object') {
     options = type;
     type = undefined;
@@ -548,7 +536,7 @@ Document.prototype.set = function(path, val, type, options) {
 
       if (len === 0 && !this.schema.options.minimize) {
         if (val) {
-          this.set(val, {});
+          this.$set(val, {});
         }
         return this;
       }
@@ -583,7 +571,7 @@ Document.prototype.set = function(path, val, type, options) {
         && !(this.schema.paths[pathName] &&
         this.schema.paths[pathName].options &&
         this.schema.paths[pathName].options.ref)) {
-      this.set(path[key], prefix + key, constructing);
+      this.$set(path[key], prefix + key, constructing);
     } else if (strict) {
       // Don't overwrite defaults with undefined keys (gh-3981)
       if (constructing && path[key] === void 0 &&
@@ -599,9 +587,9 @@ Document.prototype.set = function(path, val, type, options) {
             path[key] instanceof Document) {
           p = p.toObject({ virtuals: false, transform: false });
         }
-        this.set(prefix + key, p, constructing);
+        this.$set(prefix + key, p, constructing);
       } else if (pathtype === 'nested' && path[key] instanceof Document) {
-        this.set(prefix + key,
+        this.$set(prefix + key,
             path[key].toObject({transform: false}), constructing);
       } else if (strict === 'throw') {
         if (pathtype === 'nested') {
@@ -611,7 +599,7 @@ Document.prototype.set = function(path, val, type, options) {
         }
       }
     } else if (path[key] !== void 0) {
-      this.set(prefix + key, path[key], constructing);
+      this.$set(prefix + key, path[key], constructing);
     }
   }
 
@@ -629,7 +617,7 @@ Document.prototype.set = function(path, val, type, options) {
         this.markModified(path);
         cleanModifiedSubpaths(this, path);
       } else {
-        this.set(val, path, constructing);
+        this.$set(val, path, constructing);
       }
       return this;
     }
@@ -681,7 +669,7 @@ Document.prototype.set = function(path, val, type, options) {
     cur = cur[parts[i]];
     curPath += (curPath.length > 0 ? '.' : '') + parts[i];
     if (!cur) {
-      this.set(curPath, {});
+      this.$set(curPath, {});
       cur = this.getValue(curPath);
     }
   }
@@ -785,6 +773,40 @@ Document.prototype.set = function(path, val, type, options) {
   return this;
 };
 
+/**
+ * Sets the value of a path, or many paths.
+ *
+ * ####Example:
+ *
+ *     // path, value
+ *     doc.set(path, value)
+ *
+ *     // object
+ *     doc.set({
+ *         path  : value
+ *       , path2 : {
+ *            path  : value
+ *         }
+ *     })
+ *
+ *     // on-the-fly cast to number
+ *     doc.set(path, value, Number)
+ *
+ *     // on-the-fly cast to string
+ *     doc.set(path, value, String)
+ *
+ *     // changing strict mode behavior
+ *     doc.set(path, value, { strict: false });
+ *
+ * @param {String|Object} path path or object of key/vals to set
+ * @param {Any} val the value to set
+ * @param {Schema|String|Number|Buffer|*} [type] optionally specify a type for "on-the-fly" attributes
+ * @param {Object} [options] optionally specify options that modify the behavior of the set
+ * @api public
+ */
+
+Document.prototype.set = Document.prototype.$set;
+
 /**
  * Determine if we should mark this change as modified.
  *
@@ -2570,12 +2592,17 @@ Document.prototype.populated = function(path, val, options) {
  */
 
 Document.prototype.depopulate = function(path) {
-  var populatedIds = this.populated(path);
-  if (!populatedIds) {
-    return;
+  if (typeof path === 'string') {
+    path = path.split(' ');
+  }
+  for (var i = 0; i < path.length; i++) {
+    var populatedIds = this.populated(path[i]);
+    if (!populatedIds) {
+      continue;
+    }
+    delete this.$__.populated[path[i]];
+    this.$set(path[i], populatedIds);
   }
-  delete this.$__.populated[path];
-  this.set(path, populatedIds);
   return this;
 };
 

package/lib/model.js

@@ -20,6 +20,7 @@ var cast = require('./cast');
 var castUpdate = require('./services/query/castUpdate');
 var discriminator = require('./services/model/discriminator');
 var isPathSelectedInclusive = require('./services/projection/isPathSelectedInclusive');
+var get = require('lodash.get');
 var mpath = require('mpath');
 var parallel = require('async/parallel');
 var parallelLimit = require('async/parallelLimit');
@@ -552,7 +553,13 @@ Model.prototype.$__delta = function() {
       value = value.toObject();
       operand(this, where, delta, data, value);
     } else {
-      value = utils.clone(value, {depopulate: 1, _isNested: true});
+      value = utils.clone(value, {
+        depopulate: true,
+        transform: false,
+        virtuals: false,
+        retainKeyOrder: true,
+        _isNested: true
+      });
       operand(this, where, delta, data, value);
     }
   }
@@ -651,8 +658,13 @@ Model.prototype.$__version = function(where, delta) {
   }
 
   if (VERSION_INC === (VERSION_INC & this.$__.version)) {
-    if (!delta.$set || typeof delta.$set[key] === 'undefined') {
-      delta.$inc || (delta.$inc = {});
+    if (get(delta.$set, key, null) != null) {
+      // Version key is getting set, means we'll increment the doc's version
+      // after a successful save, so we should set the incremented version so
+      // future saves don't fail (gh-5779)
+      ++delta.$set[key];
+    } else {
+      delta.$inc = delta.$inc || {};
       delta.$inc[key] = 1;
     }
   }
@@ -921,9 +933,9 @@ Model.init = function init(callback) {
         callback && callback(null, _this);
         resolve(_this);
       });
+    } else {
+      resolve(_this);
     }
-
-    return _this;
   });
 
   return this.$init;
@@ -2102,6 +2114,11 @@ var INSERT_MANY_CONVERT_OPTIONS = {
  * because it only sends one operation to the server, rather than one for each
  * document.
  *
+ * Mongoose always validates each document **before** sending `insertMany`
+ * to MongoDB. So if one document has a validation error, no documents will
+ * be saved, unless you set
+ * [the `ordered` option to false](https://docs.mongodb.com/manual/reference/method/db.collection.insertMany/#error-handling).
+ *
  * This function does **not** trigger save middleware.
  *
  * This function triggers the following middleware:
@@ -2114,6 +2131,8 @@ var INSERT_MANY_CONVERT_OPTIONS = {
  *
  * @param {Array|Object|*} doc(s)
  * @param {Object} [options] see the [mongodb driver options](http://mongodb.github.io/node-mongodb-native/2.2/api/Collection.html#insertMany)
+ * @param {Boolean} [options.ordered = true] if true, will fail fast on the first error encountered. If false, will insert all the documents it can and report errors later. An `insertMany()` with `ordered = false` is called an "unordered" `insertMany()`.
+ * @param {Boolean} [options.rawResult = false] if false, the returned promise resolves to the documents that passed mongoose document validation. If `false`, will return the [raw result from the MongoDB driver](http://mongodb.github.io/node-mongodb-native/2.2/api/Collection.html#~insertWriteOpCallback) with a `mongoose` property that contains `validationErrors` if this is an unordered `insertMany`.
  * @param {Function} [callback] callback
  * @return {Promise}
  * @api public
@@ -2128,16 +2147,18 @@ Model.insertMany = function(arr, options, callback) {
   if (callback) {
     callback = this.$wrapCallback(callback);
   }
-  var limit = options && options.limit;
-  if (typeof limit !== 'number') {
-    limit = 1000;
-  }
+  callback = callback || utils.noop;
+  options = options || {};
+  var limit = get(options, 'limit', 1000);
+  var rawResult = get(options, 'rawResult', false);
+  var ordered = get(options, 'ordered', true);
 
   if (!Array.isArray(arr)) {
     arr = [arr];
   }
 
   var toExecute = [];
+  var validationErrors = [];
   arr.forEach(function(doc) {
     toExecute.push(function(callback) {
       doc = new _this(doc);
@@ -2146,7 +2167,8 @@ Model.insertMany = function(arr, options, callback) {
           // Option `ordered` signals that insert should be continued after reaching
           // a failing insert. Therefore we delegate "null", meaning the validation
           // failed. It's up to the next function to filter out all failed models
-          if (options != null && typeof options === 'object' && options['ordered'] === false) {
+          if (ordered === false) {
+            validationErrors.push(error);
             return callback(null, null);
           }
           return callback(error);
@@ -2167,7 +2189,7 @@ Model.insertMany = function(arr, options, callback) {
     });
     // Quickly escape while there aren't any valid docAttributes
     if (docAttributes.length < 1) {
-      callback && callback(null, []);
+      callback(null, []);
       return;
     }
     var docObjects = docAttributes.map(function(doc) {
@@ -2180,7 +2202,7 @@ Model.insertMany = function(arr, options, callback) {
       return doc.toObject(INSERT_MANY_CONVERT_OPTIONS);
     });
 
-    _this.collection.insertMany(docObjects, options, function(error) {
+    _this.collection.insertMany(docObjects, options, function(error, res) {
       if (error) {
         callback && callback(error);
         return;
@@ -2190,7 +2212,17 @@ Model.insertMany = function(arr, options, callback) {
         docAttributes[i].emit('isNew', false);
         docAttributes[i].constructor.emit('isNew', false);
       }
-      callback && callback(null, docAttributes);
+      if (rawResult) {
+        if (ordered === false) {
+          // Decorate with mongoose validation errors in case of unordered,
+          // because then still do `insertMany()`
+          res.mongoose = {
+            validationErrors: validationErrors
+          };
+        }
+        return callback(null, res);
+      }
+      callback(null, docAttributes);
     });
   });
 };
@@ -2763,7 +2795,9 @@ Model.geoNear = function(near, options, callback) {
     });
   }
 
-  var x, y;
+  var x;
+  var y;
+  var schema = this.schema;
 
   return new Promise.ES6(function(resolve, reject) {
     var handler = function(err, res) {
@@ -2808,6 +2842,11 @@ Model.geoNear = function(near, options, callback) {
       }
     };
 
+    if (options.query != null) {
+      options.query = utils.clone(options.query, { retainKeyOrder: 1 });
+      cast(schema, options.query);
+    }
+
     if (Array.isArray(near)) {
       if (near.length !== 2) {
         var error = new Error('If using legacy coordinates, must be an array ' +
@@ -3552,10 +3591,14 @@ function getModelsMapForPopulate(model, docs, options) {
         }
         var virtual = modelForCurrentDoc.schema._getVirtual(options.path);
 
-        if (schemaForCurrentDoc && schemaForCurrentDoc.options && schemaForCurrentDoc.options.ref) {
-          modelNames = [schemaForCurrentDoc.options.ref];
-        } else if (virtual && virtual.options && virtual.options.ref) {
-          modelNames = [virtual && virtual.options && virtual.options.ref];
+        var ref;
+        if ((ref = get(schemaForCurrentDoc, 'options.ref')) != null) {
+          modelNames = [ref];
+        } else if ((ref = get(virtual, 'options.ref')) != null) {
+          if (typeof ref === 'function') {
+            ref = ref.call(doc, doc);
+          }
+          modelNames = [ref];
           isVirtual = true;
         } else {
           // We may have a discriminator, in which case we don't want to
@@ -3576,9 +3619,18 @@ function getModelsMapForPopulate(model, docs, options) {
     }
 
     virtual = model.schema._getVirtual(options.path);
-    var localField = virtual && virtual.options ?
-      (virtual.$nestedSchemaPath ? virtual.$nestedSchemaPath + '.' : '') + virtual.options.localField :
-      options.path;
+    var localField;
+    if (virtual && virtual.options) {
+      var virtualPrefix = virtual.$nestedSchemaPath ?
+        virtual.$nestedSchemaPath + '.' : '';
+      if (typeof virtual.options.localField === 'function') {
+        localField = virtualPrefix + virtual.options.localField.call(doc, doc);
+      } else {
+        localField = virtualPrefix + virtual.options.localField;
+      }
+    } else {
+      localField = options.path;
+    }
     var foreignField = virtual && virtual.options ?
       virtual.options.foreignField :
       '_id';
@@ -3593,6 +3645,12 @@ function getModelsMapForPopulate(model, docs, options) {
     }
 
     options.isVirtual = isVirtual;
+    if (typeof localField === 'function') {
+      localField = localField.call(doc, doc);
+    }
+    if (typeof foreignField === 'function') {
+      foreignField = foreignField.call(doc);
+    }
     var ret = convertTo_id(utils.getValue(localField, doc));
     var id = String(utils.getValue(foreignField, doc));
     options._docs[id] = Array.isArray(ret) ? ret.slice() : ret;
@@ -3841,8 +3899,17 @@ Model.compile = function compile(name, schema, collectionName, connection, base)
 
   model.prototype.$__setSchema(schema);
 
+  var _userProvidedOptions = schema._userProvidedOptions || {};
+  var bufferCommands = true;
+  if (connection.config.bufferCommands != null) {
+    bufferCommands = connection.config.bufferCommands;
+  }
+  if (_userProvidedOptions.bufferCommands != null) {
+    bufferCommands = _userProvidedOptions.bufferCommands;
+  }
+
   var collectionOptions = {
-    bufferCommands: schema.options.bufferCommands,
+    bufferCommands: bufferCommands,
     capped: schema.options.capped
   };
 
@@ -3937,14 +4004,24 @@ Model.__subclass = function subclass(conn, schema, collection) {
       : _this.prototype.schema;
 
   var options = s.options || {};
+  var _userProvidedOptions = s._userProvidedOptions || {};
 
   if (!collection) {
     collection = _this.prototype.schema.get('collection')
         || utils.toCollectionName(_this.modelName, options);
   }
 
+  var bufferCommands = true;
+  if (s) {
+    if (conn.config.bufferCommands != null) {
+      bufferCommands = conn.config.bufferCommands;
+    }
+    if (_userProvidedOptions.bufferCommands != null) {
+      bufferCommands = _userProvidedOptions.bufferCommands;
+    }
+  }
   var collectionOptions = {
-    bufferCommands: s ? options.bufferCommands : true,
+    bufferCommands: bufferCommands,
     capped: s && options.capped
   };
 

package/lib/query.js

@@ -11,6 +11,7 @@ var cast = require('./cast');
 var castUpdate = require('./services/query/castUpdate');
 var hasDollarKeys = require('./services/query/hasDollarKeys');
 var helpers = require('./queryhelpers');
+var isInclusive = require('./services/projection/isInclusive');
 var mquery = require('mquery');
 var readPref = require('./drivers').ReadPreference;
 var selectPopulatedFields = require('./services/query/selectPopulatedFields');
@@ -2025,6 +2026,7 @@ function prepareDiscriminatorCriteria(query) {
  * @param {Object} [options]
  * @param {Boolean} [options.passRawResult] if true, passes the [raw result from the MongoDB driver as the third callback parameter](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 {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, doc), _unless_ `passRawResult` is used, in which case params are (error, doc, writeOpResult)
  * @see mongodb http://www.mongodb.org/display/DOCS/findAndModify+Command
  * @see writeOpResult http://mongodb.github.io/node-mongodb-native/2.2/api/Collection.html#~WriteOpResult
@@ -2720,6 +2722,7 @@ Query.prototype._replaceOne = function(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 {Function} [callback] optional, params are (error, writeOpResult)
  * @return {Query} this
  * @see Model.update #model_Model.update
@@ -2771,6 +2774,7 @@ Query.prototype.update = 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 {Function} [callback] optional params are (error, writeOpResult)
  * @return {Query} this
  * @see Model.update #model_Model.update
@@ -2821,6 +2825,7 @@ Query.prototype.updateMany = 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 {Function} [callback] params are (error, writeOpResult)
  * @return {Query} this
  * @see Model.update #model_Model.update
@@ -3824,28 +3829,7 @@ Query.prototype.centerSphere = function() {
  */
 
 Query.prototype.selectedInclusively = function selectedInclusively() {
-  if (!this._fields) {
-    return false;
-  }
-
-  var keys = Object.keys(this._fields);
-  if (keys.length === 0) {
-    return false;
-  }
-
-  for (var i = 0; i < keys.length; ++i) {
-    var key = keys[i];
-    if (this._fields[key] === 0 || this._fields[key] === false) {
-      return false;
-    }
-    if (this._fields[key] &&
-        typeof this._fields[key] === 'object' &&
-        this._fields[key].$meta) {
-      return false;
-    }
-  }
-
-  return true;
+  return isInclusive(this._fields);
 };
 
 /**

package/lib/queryhelpers.js

@@ -3,6 +3,7 @@
  * Module dependencies
  */
 
+var get = require('lodash.get');
 var utils = require('./utils');
 
 /*!
@@ -75,7 +76,6 @@ exports.createModel = function createModel(model, doc, fields, userProvidedField
 
 exports.applyPaths = function applyPaths(fields, schema) {
   // determine if query is selecting or excluding fields
-
   var exclude;
   var keys;
   var ki;
@@ -123,8 +123,25 @@ exports.applyPaths = function applyPaths(fields, schema) {
     }
 
     // check for parent exclusions
-    var root = path.split('.')[0];
-    if (~excluded.indexOf(root)) return;
+    var pieces = path.split('.');
+    var root = pieces[0];
+    if (~excluded.indexOf(root)) {
+      return;
+    }
+
+    // Special case: if user has included a parent path of a discriminator key,
+    // 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) {
+        cur += (cur.length === 0 ? '' : '.') + pieces[i];
+        var projection = get(fields, cur, false);
+        if (projection && typeof projection !== 'object') {
+          return;
+        }
+      }
+    }
 
     (type.selected ? selected : excluded).push(path);
   };

package/lib/schema/array.js

@@ -93,7 +93,7 @@ function SchemaArray(key, cast, options, schemaOptions) {
       if (fn) {
         arr = defaultArr();
       } else if (defaultArr != null) {
-        arr = defaultArr;
+        arr = arr.concat(defaultArr);
       }
       // Leave it up to `cast()` to convert the array
       return arr;

package/lib/schema/buffer.js

@@ -113,6 +113,9 @@ SchemaBuffer.prototype.cast = function(value, doc, init) {
   if (Buffer.isBuffer(value)) {
     if (!value || !value.isMongooseBuffer) {
       value = new MongooseBuffer(value, [this.path, doc]);
+      if (this.options.subtype != null) {
+        value._subtype = this.options.subtype;
+      }
     }
 
     return value;
@@ -135,12 +138,36 @@ SchemaBuffer.prototype.cast = function(value, doc, init) {
       value = [value];
     }
     ret = new MongooseBuffer(value, [this.path, doc]);
+    if (this.options.subtype != null) {
+      ret._subtype = this.options.subtype;
+    }
     return ret;
   }
 
   throw new CastError('buffer', value, this.path);
 };
 
+/**
+ * Sets the default [subtype](https://studio3t.com/whats-new/best-practices-uuid-mongodb/)
+ * for this buffer. You can find a [list of allowed subtypes here](http://api.mongodb.com/python/current/api/bson/binary.html).
+ *
+ * ####Example:
+ *
+ *     var s = new Schema({ uuid: { type: Buffer, subtype: 4 });
+ *     var M = db.model('M', s);
+ *     var m = new M({ uuid: 'test string' });
+ *     m.uuid._subtype; // 4
+ *
+ * @param {Number} subtype the default subtype
+ * @return {SchemaType} this
+ * @api public
+ */
+
+SchemaBuffer.prototype.subtype = function(subtype) {
+  this.options.subtype = subtype;
+  return this;
+};
+
 /*!
  * ignore
  */

package/lib/schema/documentarray.js

@@ -11,7 +11,6 @@ var EventEmitter = require('events').EventEmitter;
 var MongooseDocumentArray = require('../types/documentarray');
 var SchemaType = require('../schematype');
 var Subdocument = require('../types/embedded');
-var applyHooks = require('../services/model/applyHooks');
 var discriminator = require('../services/model/discriminator');
 var util = require('util');
 var utils = require('../utils');
@@ -120,8 +119,6 @@ DocumentArray.prototype.discriminator = function(name, schema) {
 
   this.casterConstructor.discriminators[name] = EmbeddedDocument;
 
-  applyHooks(EmbeddedDocument, schema);
-
   return this.casterConstructor.discriminators[name];
 };
 

package/lib/schema/embedded.js

@@ -8,7 +8,6 @@ var $exists = require('./operators/exists');
 var EventEmitter = require('events').EventEmitter;
 var SchemaType = require('../schematype');
 var Subdocument = require('../types/subdocument');
-var applyHooks = require('../services/model/applyHooks');
 var castToNumber = require('./operators/helpers').castToNumber;
 var discriminator = require('../services/model/discriminator');
 var geospatial = require('./operators/geospatial');
@@ -255,7 +254,5 @@ Embedded.prototype.discriminator = function(name, schema) {
 
   this.caster.discriminators[name] = _createConstructor(schema);
 
-  applyHooks(this.caster.discriminators[name], schema);
-
   return this.caster.discriminators[name];
 };

package/lib/schema.js

@@ -13,6 +13,7 @@ var SchemaType = require('./schematype');
 var mpath = require('mpath');
 
 var IS_KAREEM_HOOK = {
+  aggregate: true,
   count: true,
   find: true,
   findOne: true,
@@ -327,6 +328,10 @@ Schema.prototype.defaultOptions = function(options) {
     options.versionKey = false;
   }
 
+  this._userProvidedOptions = utils.clone(options, {
+    retainKeyOrder: true
+  });
+
   options = utils.options({
     strict: true,
     bufferCommands: true,
@@ -438,7 +443,6 @@ reserved.get =
 reserved.modelName =
 reserved.save =
 reserved.schema =
-reserved.set =
 reserved.toObject =
 reserved.validate =
 reserved.remove =
@@ -588,7 +592,7 @@ Schema.interpretAsType = function(path, obj, options) {
     if (cast &&
         cast[options.typeKey] &&
         cast[options.typeKey].instanceOfSchema) {
-      return new MongooseTypes.DocumentArray(path, cast[options.typeKey], obj);
+      return new MongooseTypes.DocumentArray(path, cast[options.typeKey], cast);
     }
 
     if (Array.isArray(cast)) {
@@ -1427,7 +1431,9 @@ Schema.prototype.indexes = function() {
       path = schema.paths[key];
 
       if ((path instanceof MongooseTypes.DocumentArray) || path.$isSingleNested) {
-        collectIndexes(path.schema, prefix + key + '.');
+        if (path.options.excludeIndexes !== true) {
+          collectIndexes(path.schema, prefix + key + '.');
+        }
       } else {
         index = path._index || (path.caster && path.caster._index);
 

package/lib/schematype.js

@@ -28,18 +28,23 @@ function SchemaType(path, options, instance) {
   this._index = null;
   this.selected;
 
-  for (var i in options) {
-    if (this[i] && typeof this[i] === 'function') {
+  for (var prop in options) {
+    if (this[prop] && typeof this[prop] === 'function') {
       // { unique: true, index: true }
-      if (i === 'index' && this._index) {
+      if (prop === 'index' && this._index) {
         continue;
       }
 
-      var opts = Array.isArray(options[i])
-          ? options[i]
-          : [options[i]];
+      var val = options[prop];
+      // Special case so we don't screw up array defaults, see gh-5780
+      if (prop === 'default') {
+        this.default(val);
+        continue;
+      }
+
+      var opts = Array.isArray(val) ? val : [val];
 
-      this[i].apply(this, opts);
+      this[prop].apply(this, opts);
     }
   }
 

package/lib/services/document/compile.js

@@ -126,7 +126,8 @@ function defineKey(prop, subprops, prototype, prefix, keys, options) {
         if (v instanceof Document) {
           v = v.toObject({ transform: false });
         }
-        return (this.$__.scope || this).set(path, v);
+        var doc = this.$__.scope || this;
+        return doc.$set(path, v);
       }
     });
   } else {
@@ -137,7 +138,7 @@ function defineKey(prop, subprops, prototype, prefix, keys, options) {
         return this.get.call(this.$__.scope || this, path);
       },
       set: function(v) {
-        return this.set.call(this.$__.scope || this, path, v);
+        return this.$set.call(this.$__.scope || this, path, v);
       }
     });
   }

package/lib/services/model/applyHooks.js

@@ -24,10 +24,18 @@ function applyHooks(model, schema) {
 
   model.$appliedHooks = true;
   for (i = 0; i < schema.childSchemas.length; ++i) {
-    if (schema.childSchemas[i].model.$appliedHooks) {
+    var childModel = schema.childSchemas[i].model;
+    if (childModel.$appliedHooks) {
       continue;
     }
-    applyHooks(schema.childSchemas[i].model, schema.childSchemas[i].schema);
+    if (childModel.discriminators != null) {
+      keys = Object.keys(childModel.discriminators);
+      for (j = 0; j < keys.length; ++j) {
+        applyHooks(childModel.discriminators[keys[j]],
+          childModel.discriminators[keys[j]].schema);
+      }
+    }
+    applyHooks(childModel, schema.childSchemas[i].schema);
   }
 
   if (!q.length) {

package/lib/services/projection/isInclusive.js

@@ -0,0 +1,28 @@
+'use strict';
+
+/*!
+ * ignore
+ */
+
+module.exports = function isInclusive(projection) {
+  if (projection == null) {
+    return false;
+  }
+
+  var props = Object.keys(projection);
+  var numProps = props.length;
+  if (numProps === 0) {
+    return false;
+  }
+
+  for (var i = 0; i < numProps; ++i) {
+    var prop = props[i];
+    // If field is truthy (1, true, etc.) and not an object, then this
+    // projection must be inclusive. If object, assume its $meta, $slice, etc.
+    if (typeof projection[prop] !== 'object' && !!projection[prop]) {
+      return true;
+    }
+  }
+
+  return false;
+};

package/lib/services/query/castUpdate.js

@@ -1,6 +1,7 @@
 'use strict';
 
 var StrictModeError = require('../../error/strict');
+var ValidationError = require('../../error/validation');
 var utils = require('../../utils');
 
 /*!
@@ -102,13 +103,16 @@ module.exports = function castUpdate(schema, obj, options, context) {
  */
 
 function walkUpdatePath(schema, obj, op, strict, context, pref) {
-  var prefix = pref ? pref + '.' : '',
-      keys = Object.keys(obj),
-      i = keys.length,
-      hasKeys = false,
-      schematype,
-      key,
-      val;
+  var prefix = pref ? pref + '.' : '';
+  var keys = Object.keys(obj);
+  var i = keys.length;
+  var hasKeys = false;
+  var schematype;
+  var key;
+  var val;
+
+  var hasError = false;
+  var aggregatedError = new ValidationError();
 
   var useNestedStrict = schema.options.useNestedStrict;
 
@@ -124,9 +128,14 @@ function walkUpdatePath(schema, obj, op, strict, context, pref) {
         hasKeys = true;
 
         if ('$each' in val) {
-          obj[key] = {
-            $each: castUpdateVal(schematype, val.$each, op, context)
-          };
+          try {
+            obj[key] = {
+              $each: castUpdateVal(schematype, val.$each, op, context)
+            };
+          } catch (error) {
+            hasError = true;
+            _handleCastError(error, context, key, aggregatedError);
+          }
 
           if (val.$slice != null) {
             obj[key].$slice = val.$slice | 0;
@@ -140,14 +149,22 @@ function walkUpdatePath(schema, obj, op, strict, context, pref) {
             obj[key].$position = val.$position;
           }
         } else {
-          obj[key] = castUpdateVal(schematype, val, op, context);
+          try {
+            obj[key] = castUpdateVal(schematype, val, op, context);
+          } catch (error) {
+            hasError = true;
+            _handleCastError(error, context, key, aggregatedError);
+          }
         }
-      } else if (op === '$currentDate') {
+      } else if ((op === '$currentDate') || (op in castOps && schematype)) {
         // $currentDate can take an object
-        obj[key] = castUpdateVal(schematype, val, op, context);
-        hasKeys = true;
-      } else if (op in castOps && schematype) {
-        obj[key] = castUpdateVal(schematype, val, op, context);
+        try {
+          obj[key] = castUpdateVal(schematype, val, op, context);
+        } catch (error) {
+          hasError = true;
+          _handleCastError(error, context, key, aggregatedError);
+        }
+
         hasKeys = true;
       } else {
         var pathToCheck = (prefix + key);
@@ -208,13 +225,34 @@ function walkUpdatePath(schema, obj, op, strict, context, pref) {
         }
 
         hasKeys = true;
-        obj[key] = castUpdateVal(schematype, val, op, key, context);
+        try {
+          obj[key] = castUpdateVal(schematype, val, op, key, context);
+        } catch (error) {
+          hasError = true;
+          _handleCastError(error, context, key, aggregatedError);
+        }
       }
     }
   }
+
+  if (hasError) {
+    throw aggregatedError;
+  }
+
   return hasKeys;
 }
 
+/*!
+ * ignore
+ */
+
+function _handleCastError(error, query, key, aggregatedError) {
+  if (!query.options.multipleCastError) {
+    throw error;
+  }
+  aggregatedError.addError(key, error);
+}
+
 /*!
  * These operators should be cast to numbers instead
  * of their path schema type.

package/lib/utils.js

@@ -894,3 +894,9 @@ exports.each = function(arr, fn) {
     fn(arr[i]);
   }
 };
+
+/*!
+ * ignore
+ */
+
+exports.noop = function() {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "4.12.6",
+  "version": "4.13.3",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -23,6 +23,7 @@
     "bson": "~1.0.4",
     "hooks-fixed": "2.0.2",
     "kareem": "1.5.0",
+    "lodash.get": "4.4.2",
     "mongodb": "2.2.33",
     "mpath": "0.3.0",
     "mpromise": "0.5.5",
@@ -44,7 +45,7 @@
     "istanbul": "0.4.4",
     "jade": "0.26.3",
     "lodash": "4.16.6",
-    "markdown": "0.3.1",
+    "markdown": "0.5.0",
     "marked": "0.3.6",
     "mocha": "3.2.0",
     "mongoose-long": "0.1.1",

package/release-items.md

@@ -18,7 +18,7 @@ For 4.x
 
 0. Change to the master branch
 1. execute `make docs` (when this process completes you'll be on the gh-pages branch)
-2. `git commit -a -m 'docs: release 4.x.x'`
+2. `git commit -a -m 'chore: website 4.x.x'`
 3. `git push origin gh-pages`
 
 For 3.8.x: