mongoose 5.0.7 → 5.0.11

package/History.md

@@ -1,3 +1,45 @@
+5.0.11 / 2018-03-19
+===================
+ * fix(update): handle $pull with $in in update validators #6240
+ * fix(query): don't convert undefined to null when casting so driver `ignoreUndefined` option works #6236
+ * docs(middleware): add example of using async/await with middleware #6235
+ * fix(populate): apply justOne option before `completeMany()` so it works with lean() #6234
+ * fix(query): ensure errors in user callbacks aren't caught in init #6195 #6178
+ * docs(connections): document dbName option for Atlas connections #6179
+ * fix(discriminator): make child schema nested paths overwrite parent schema paths #6076
+
+4.13.12 / 2018-03-13
+====================
+ * fix(document): make virtual get() return undefined instead of null if no getters #6223
+ * docs: fix url in useMongoClient error message #6219 #6217 [lineus](https://github.com/lineus)
+ * fix(discriminator): don't copy `discriminators` property from base schema #6122 #6064
+
+5.0.10 / 2018-03-12
+===================
+ * docs(schematype): add notes re: running setters on queries #6209
+ * docs: fix typo #6208 [kamagatos](https://github.com/kamagatos)
+ * fix(query): only call setters once on query filter props for findOneAndUpdate and findOneAndRemove #6203
+ * docs: elaborate on connection string changes in migration guide #6193
+ * fix(document): skip applyDefaults if subdoc is null #6187
+ * docs: fix schematypes docs and link to them #6176
+ * docs(faq): add FAQs re: array defaults and casting aggregation pipelines #6184 #6176 #6170 [lineus](https://github.com/lineus)
+ * fix(document): ensure primitive defaults are set and built-in default functions run before setters #6155
+ * fix(query): handle single embedded embedded discriminators in castForQuery #6027
+
+5.0.9 / 2018-03-05
+==================
+ * perf: bump mongodb -> 3.0.4 to fix SSL perf issue #6065
+
+5.0.8 / 2018-03-03
+==================
+ * docs: remove obsolete references to `emitIndexErrors` #6186 [isaackwan](https://github.com/isaackwan)
+ * fix(query): don't cast findOne() until exec() so setters don't run twice #6157
+ * fix: remove document_provider.web.js file #6186
+ * fix(discriminator): support custom discriminator model names #6100 [wentout](https://github.com/wentout)
+ * fix: support caching calls to `useDb()` #6036 [rocketspacer](https://github.com/rocketspacer)
+ * fix(query): add omitUndefined option so setDefaultsOnInsert can kick in on undefined #6034
+ * fix: upgrade mongodb -> 3.0.3 for reconnectTries: 0 blocking process exit fix #6028
+
 5.0.7 / 2018-02-23
 ==================
  * fix: support eachAsync options with aggregation cursor #6169 #6168 [vichle](https://github.com/vichle)

package/README.md

@@ -10,6 +10,8 @@ Mongoose is a [MongoDB](https://www.mongodb.org/) object modeling tool designed
 
 [mongoosejs.com](http://mongoosejs.com/)
 
+[Mongoose 5.0.0](https://github.com/Automattic/mongoose/blob/master/History.md#500--2018-01-17) was released on January 17, 2018. You can find more details on backwards breaking changes in 5.0.0 on [GitHub](https://github.com/Automattic/mongoose/blob/master/migrating_to_5.md).
+
 ## Support
 
   - [Stack Overflow](http://stackoverflow.com/questions/tagged/mongoose)
@@ -57,7 +59,7 @@ First, we need to define a connection. If your app uses only one database, you s
 Both `connect` and `createConnection` take a `mongodb://` URI, or the parameters `host, database, port, options`.
 
 ```js
-var mongoose = require('mongoose');
+const mongoose = require('mongoose');
 
 mongoose.connect('mongodb://localhost/my_database');
 ```
@@ -73,14 +75,14 @@ Once connected, the `open` event is fired on the `Connection` instance. If you'r
 Models are defined through the `Schema` interface.
 
 ```js
-var Schema = mongoose.Schema,
+const Schema = mongoose.Schema,
     ObjectId = Schema.ObjectId;
 
-var BlogPost = new Schema({
-    author    : ObjectId,
-    title     : String,
-    body      : String,
-    date      : Date
+const BlogPost = new Schema({
+ author: ObjectId,
+ title: String,
+ body: String,
+ date: Date
 });
 ```
 
@@ -100,7 +102,7 @@ Aside from defining the structure of your documents and the types of data you're
 The following example shows some of these features:
 
 ```js
-var Comment = new Schema({
+const Comment = new Schema({
   name: { type: String, default: 'hahaha' },
   age: { type: Number, min: 18, index: true },
   bio: { type: String, match: /[a-z]/ },
@@ -127,19 +129,19 @@ Take a look at the example in `examples/schema.js` for an end-to-end example of
 Once we define a model through `mongoose.model('ModelName', mySchema)`, we can access it through the same function
 
 ```js
-var myModel = mongoose.model('ModelName');
+const myModel = mongoose.model('ModelName');
 ```
 
 Or just do it all at once
 
 ```js
-var MyModel = mongoose.model('ModelName', mySchema);
+const MyModel = mongoose.model('ModelName', mySchema);
 ```
 
 The first argument is the _singular_ name of the collection your model is for. **Mongoose automatically looks for the _plural_ version of your model name.** For example, if you use
 
 ```js
-var MyModel = mongoose.model('Ticket', mySchema);
+const MyModel = mongoose.model('Ticket', mySchema);
 ```
 
 Then Mongoose will create the model for your __tickets__ collection, not your __ticket__ collection.
@@ -147,7 +149,7 @@ Then Mongoose will create the model for your __tickets__ collection, not your __
 Once we have our model, we can then instantiate it, and save it:
 
 ```js
-var instance = new MyModel();
+const instance = new MyModel();
 instance.my.key = 'hello';
 instance.save(function (err) {
   //
@@ -167,18 +169,18 @@ You can also `findOne`, `findById`, `update`, etc. For more details check out [t
 **Important!** If you opened a separate connection using `mongoose.createConnection()` but attempt to access the model through `mongoose.model('ModelName')` it will not work as expected since it is not hooked up to an active db connection. In this case access your model through the connection you created:
 
 ```js
-var conn = mongoose.createConnection('your connection string'),
-    MyModel = conn.model('ModelName', schema),
-    m = new MyModel;
+const conn = mongoose.createConnection('your connection string');
+const MyModel = conn.model('ModelName', schema);
+const m = new MyModel;
 m.save(); // works
 ```
 
 vs
 
 ```js
-var conn = mongoose.createConnection('your connection string'),
-    MyModel = mongoose.model('ModelName', schema),
-    m = new MyModel;
+const conn = mongoose.createConnection('your connection string');
+const MyModel = mongoose.model('ModelName', schema);
+const m = new MyModel;
 m.save(); // does not work b/c the default connection object was never connected
 ```
 

package/browser.js

@@ -0,0 +1,6 @@
+/**
+ * Export lib/mongoose
+ *
+ */
+
+module.exports = require('./lib/browser');

package/lib/cast.js

@@ -1,13 +1,16 @@
+'use strict';
+
 /*!
  * Module dependencies.
  */
 
-var StrictModeError = require('./error/strict');
-var Types = require('./schema/index');
-var util = require('util');
-var utils = require('./utils');
+const StrictModeError = require('./error/strict');
+const Types = require('./schema/index');
+const get = require('lodash.get');
+const util = require('util');
+const utils = require('./utils');
 
-var ALLOWED_GEOWITHIN_GEOJSON_TYPES = ['Polygon', 'MultiPolygon'];
+const ALLOWED_GEOWITHIN_GEOJSON_TYPES = ['Polygon', 'MultiPolygon'];
 
 /**
  * Handles internal casting for query filters.
@@ -67,6 +70,31 @@ module.exports = function cast(schema, obj, options, context) {
 
       schematype = schema.path(path);
 
+      // Check for embedded discriminator paths
+      if (!schematype) {
+        let split = path.split('.');
+        let j = split.length;
+        while (j--) {
+          let pathFirstHalf = split.slice(0, j).join('.');
+          let pathLastHalf = split.slice(j).join('.');
+          let _schematype = schema.path(pathFirstHalf);
+          let discriminatorKey = get(_schematype, 'schema.options.discriminatorKey');
+          // gh-6027: if we haven't found the schematype but this path is
+          // underneath an embedded discriminator and the embedded discriminator
+          // key is in the query, use the embedded discriminator schema
+          if (_schematype != null &&
+              get(_schematype, 'schema.discriminators') != null &&
+              discriminatorKey != null &&
+              pathLastHalf !== discriminatorKey) {
+            const discriminatorVal = get(obj, pathFirstHalf + '.' + discriminatorKey);
+            if (discriminatorVal) {
+              schematype = _schematype.schema.discriminators[discriminatorVal].
+                path(pathLastHalf);
+            }
+          }
+        }
+      }
+
       if (!schematype) {
         // Handle potential embedded array queries
         var split = path.split('.'),
@@ -206,8 +234,7 @@ module.exports = function cast(schema, obj, options, context) {
         } else if (options.strictQuery) {
           delete obj[path];
         }
-      } else if (val === null || val === undefined) {
-        obj[path] = null;
+      } else if (val == null) {
         continue;
       } else if (val.constructor.name === 'Object') {
         any$conditionals = Object.keys(val).some(function(k) {

package/lib/connection.js

@@ -59,7 +59,8 @@ function Connection(base) {
   this.pass = null;
   this.name = null;
   this.options = null;
-  this.otherDbs = [];
+  this.otherDbs = []; // FIXME: To be replaced with relatedDbs
+  this.relatedDbs = {}; // Hashmap of other dbs that share underlying connection
   this.states = STATES;
   this._readyState = STATES.disconnected;
   this._closeCalled = false;
@@ -103,11 +104,16 @@ Object.defineProperty(Connection.prototype, 'readyState', {
 
     if (this._readyState !== val) {
       this._readyState = val;
-      // loop over the otherDbs on this connection and change their state
+      // [legacy] loop over the otherDbs on this connection and change their state
       for (var i = 0; i < this.otherDbs.length; i++) {
         this.otherDbs[i].readyState = val;
       }
 
+      // loop over relatedDbs on this connection and change their state
+      for (var k in this.relatedDbs) {
+        this.relatedDbs[k].readyState = val;
+      }
+
       if (STATES.connected === val) {
         this._hasOpened = true;
       }

package/lib/document.js

@@ -87,6 +87,10 @@ function Document(obj, fields, skipId, options) {
 
   this.$__buildDoc(obj, fields, skipId, exclude, hasIncludedChildren);
 
+  // By default, defaults get applied **before** setting initial values
+  // Re: gh-6155
+  $__applyDefaults(this, fields, skipId, exclude, hasIncludedChildren, true);
+
   if (obj) {
     if (obj instanceof Document) {
       this.isNew = obj.isNew;
@@ -99,7 +103,10 @@ function Document(obj, fields, skipId, options) {
     }
   }
 
-  $__applyDefaults(this, fields, skipId, exclude, hasIncludedChildren);
+  // Function defaults get applied **after** setting initial values so they
+  // see the full doc rather than an empty one, unless they opt out.
+  // Re: gh-3781, gh-6155
+  $__applyDefaults(this, fields, skipId, exclude, hasIncludedChildren, false);
 
   this.$__._id = this._id;
 
@@ -202,7 +209,7 @@ function $__hasIncludedChildren(fields) {
  * ignore
  */
 
-function $__applyDefaults(doc, fields, skipId, exclude, hasIncludedChildren) {
+function $__applyDefaults(doc, fields, skipId, exclude, hasIncludedChildren, isBeforeSetters) {
   const paths = Object.keys(doc.schema.paths);
   const plen = paths.length;
 
@@ -222,6 +229,10 @@ function $__applyDefaults(doc, fields, skipId, exclude, hasIncludedChildren) {
     let doc_ = doc._doc;
 
     for (let j = 0; j < len; ++j) {
+      if (doc_ == null) {
+        break;
+      }
+
       let piece = path[j];
       curPath += (!curPath.length ? '' : '.') + piece;
 
@@ -242,6 +253,18 @@ function $__applyDefaults(doc, fields, skipId, exclude, hasIncludedChildren) {
           break;
         }
 
+        if (typeof type.defaultValue === 'function') {
+          if (!type.defaultValue.$runBeforeSetters && isBeforeSetters) {
+            break;
+          }
+          if (type.defaultValue.$runBeforeSetters && !isBeforeSetters) {
+            break;
+          }
+        } else if (!isBeforeSetters) {
+          // Non-function defaults should always run **before** setters
+          continue;
+        }
+
         if (fields && exclude !== null) {
           if (exclude === true) {
             // apply defaults to all non-excluded fields
@@ -1009,6 +1032,9 @@ Document.prototype.get = function(path, type) {
   var obj = this._doc;
 
   if (schema instanceof VirtualType) {
+    if (schema.getters.length === 0) {
+      return void 0;
+    }
     return schema.applyGetters(null, this);
   }
 

package/lib/drivers/node-mongodb-native/connection.js

@@ -40,7 +40,10 @@ NativeConnection.prototype.__proto__ = MongooseConnection.prototype;
  * @api public
  */
 
-NativeConnection.prototype.useDb = function(name) {
+NativeConnection.prototype.useDb = function(name, options) {
+  // Return immediately if cached
+  if (options && options.useCache && this.relatedDbs[name]) return this.relatedDbs[name];
+
   // we have to manually copy all of the attributes...
   var newConn = new this.constructor();
   newConn.name = name;
@@ -88,6 +91,12 @@ NativeConnection.prototype.useDb = function(name) {
   this.otherDbs.push(newConn);
   newConn.otherDbs.push(this);
 
+  // push onto the relatedDbs cache, this is used when state changes
+  if (options && options.useCache) {
+    this.relatedDbs[newConn.name] = newConn;
+    newConn.relatedDbs = this.relatedDbs;
+  }
+
   return newConn;
 };
 

package/lib/index.js

@@ -477,7 +477,7 @@ Mongoose.prototype.__defineSetter__('connection', function(v) {
 });
 
 /*!
- * Driver depentend APIs
+ * Driver dependent APIs
  */
 
 var driver = global.MONGOOSE_DRIVER_PATH || './drivers/node-mongodb-native';

package/lib/model.js

@@ -22,6 +22,7 @@ var applyStatics = require('./services/model/applyStatics');
 var cast = require('./cast');
 var castUpdate = require('./services/query/castUpdate');
 var discriminator = require('./services/model/discriminator');
+var getDiscriminatorByValue = require('./queryhelpers').getDiscriminatorByValue;
 var internalToObjectOptions = require('./options').internalToObjectOptions;
 var isPathSelectedInclusive = require('./services/projection/isPathSelectedInclusive');
 var get = require('lodash.get');
@@ -829,10 +830,11 @@ Model.prototype.model = function model(name) {
  *
  * @param {String} name   discriminator model name
  * @param {Schema} schema discriminator model schema
+ * @param {String} value  discriminator model typeKey value
  * @api public
  */
 
-Model.discriminator = function(name, schema) {
+Model.discriminator = function(name, schema, value) {
   var model;
   if (typeof name === 'function') {
     model = name;
@@ -842,7 +844,7 @@ Model.discriminator = function(name, schema) {
     }
   }
 
-  schema = discriminator(this, name, schema);
+  schema = discriminator(this, name, schema, value);
   if (this.db.models[name]) {
     throw new OverwriteModelError(name);
   }
@@ -2034,7 +2036,7 @@ Model.create = function create(doc, callback) {
     args.forEach(doc => {
       toExecute.push(callback => {
         var Model = this.discriminators && doc[discriminatorKey] ?
-          this.discriminators[doc[discriminatorKey]] :
+          this.discriminators[doc[discriminatorKey]] || getDiscriminatorByValue(this, doc[discriminatorKey]) :
           this;
         var toSave = doc;
         var callbackWrapper = (error, doc) => {
@@ -3267,6 +3269,8 @@ function assignVals(o) {
       } else {
         rawIds[i] = [rawIds[i]];
       }
+    } else if (o.isVirtual && o.justOne && Array.isArray(rawIds[i])) {
+      rawIds[i] = rawIds[i][0];
     }
 
     if (o.isVirtual && docs[i].constructor.name === 'model') {

package/lib/query.js

@@ -1025,6 +1025,10 @@ Query.prototype.setOptions = function(options, overwrite) {
     this._mongooseOptions.useFindAndModify = options.useFindAndModify;
     delete options.useFindAndModify;
   }
+  if ('omitUndefined' in options) {
+    this._mongooseOptions.omitUndefined = options.omitUndefined;
+    delete options.omitUndefined;
+  }
 
   return Query.base.setOptions.call(this, options);
 };
@@ -1446,10 +1450,10 @@ function completeMany(model, docs, fields, userProvidedFields, pop, callback) {
       error = error || _error;
     }
     if (error != null) {
-      --count || callback(error);
+      --count || process.nextTick(() => callback(error));
       return;
     }
-    --count || callback(error, arr);
+    --count || process.nextTick(() => callback(error, arr));
   }
   for (var i = 0; i < len; ++i) {
     arr[i] = helpers.createModel(model, docs[i], fields, userProvidedFields);
@@ -1595,13 +1599,6 @@ Query.prototype.findOne = function(conditions, projection, options, callback) {
     this.merge(conditions);
 
     prepareDiscriminatorCriteria(this);
-
-    try {
-      this.cast(this.model);
-      this.error(null);
-    } catch (err) {
-      this.error(err);
-    }
   } else if (conditions != null) {
     this.error(new ObjectParameterError(conditions, 'filter', 'findOne'));
   }
@@ -2000,14 +1997,14 @@ function completeOne(model, doc, res, options, fields, userProvidedFields, pop,
 
   function _init(err) {
     if (err) {
-      return callback(err);
+      return process.nextTick(() => callback(err));
     }
 
     if (options.rawResult) {
       res.value = casted;
-      return callback(null, res);
+      return process.nextTick(() => callback(null, res));
     }
-    callback(null, casted);
+    process.nextTick(() => callback(null, casted));
   }
 }
 
@@ -2148,8 +2145,6 @@ Query.prototype.findOneAndUpdate = function(criteria, doc, options, callback) {
  */
 
 Query.prototype._findOneAndUpdate = function(callback) {
-  this._castConditions();
-
   if (this.error() != null) {
     return callback(this.error());
   }
@@ -2243,8 +2238,6 @@ Query.prototype.findOneAndRemove = function(conditions, options, callback) {
  * @api private
  */
 Query.prototype._findOneAndRemove = function(callback) {
-  this._castConditions();
-
   if (this.error() != null) {
     return callback(this.error());
   }
@@ -3071,9 +3064,16 @@ Query.prototype._castUpdate = function _castUpdate(obj, overwrite) {
   } else {
     strict = true;
   }
+
+  var omitUndefined = false;
+  if ('omitUndefined' in this._mongooseOptions) {
+    omitUndefined = this._mongooseOptions.omitUndefined;
+  }
+
   return castUpdate(this.schema, obj, {
     overwrite: overwrite,
-    strict: strict
+    strict: strict,
+    omitUndefined
   }, this);
 };
 

package/lib/queryhelpers.js

@@ -46,6 +46,34 @@ exports.preparePopulationOptionsMQ = function preparePopulationOptionsMQ(query,
   return pop;
 };
 
+
+/*!
+ * returns discriminator by discriminatorMapping.value
+ *
+ * @param {Model} model
+ * @param {string} value
+ */
+function getDiscriminatorByValue(model, value) {
+  var discriminator = null;
+  if (!model.discriminators) {
+    return discriminator;
+  }
+  for (var name in model.discriminators) {
+    var it = model.discriminators[name];
+    if (
+      it.schema &&
+      it.schema.discriminatorMapping &&
+      it.schema.discriminatorMapping.value == value
+    ) {
+      discriminator = it;
+      break;
+    }
+  }
+  return discriminator;
+}
+
+exports.getDiscriminatorByValue = getDiscriminatorByValue;
+
 /*!
  * If the document is a mapped discriminator type, it returns a model instance for that type, otherwise,
  * it returns an instance of the given model.
@@ -65,11 +93,14 @@ exports.createModel = function createModel(model, doc, fields, userProvidedField
     ? discriminatorMapping.key
     : null;
 
-  if (key && doc[key] && model.discriminators && model.discriminators[doc[key]]) {
-    var discriminator = model.discriminators[doc[key]];
-    var _fields = utils.clone(userProvidedFields);
-    exports.applyPaths(_fields, discriminator.schema);
-    return new model.discriminators[doc[key]](undefined, _fields, true);
+  var value = doc[key];
+  if (key && value && model.discriminators) {
+    var discriminator = model.discriminators[value] || getDiscriminatorByValue(model, value);
+    if (discriminator) {
+      var _fields = utils.clone(userProvidedFields);
+      exports.applyPaths(_fields, discriminator.schema);
+      return new discriminator(undefined, _fields, true);
+    }
   }
 
   return new model(undefined, fields, true);

package/lib/schema/array.js

@@ -22,6 +22,7 @@ var util = require('util');
 var utils = require('../utils');
 var castToNumber = require('./operators/helpers').castToNumber;
 var geospatial = require('./operators/geospatial');
+var getDiscriminatorByValue = require('../queryhelpers').getDiscriminatorByValue;
 
 var MongooseArray;
 var EmbeddedDoc;
@@ -93,7 +94,7 @@ function SchemaArray(key, cast, options, schemaOptions) {
   }
 
   if (!('defaultValue' in this) || this.defaultValue !== void 0) {
-    this.default(function() {
+    var defaultFn = function() {
       var arr = [];
       if (fn) {
         arr = defaultArr();
@@ -102,7 +103,9 @@ function SchemaArray(key, cast, options, schemaOptions) {
       }
       // Leave it up to `cast()` to convert the array
       return arr;
-    });
+    };
+    defaultFn.$runBeforeSetters = true;
+    this.default(defaultFn);
   }
 }
 
@@ -247,10 +250,18 @@ SchemaArray.prototype.castForQuery = function($conditional, value) {
 
     if (val &&
         Constructor.discriminators &&
-        Constructor.schema.options.discriminatorKey &&
-        typeof val[Constructor.schema.options.discriminatorKey] === 'string' &&
-        Constructor.discriminators[val[Constructor.schema.options.discriminatorKey]]) {
-      Constructor = Constructor.discriminators[val[Constructor.schema.options.discriminatorKey]];
+        Constructor.schema &&
+        Constructor.schema.options &&
+        Constructor.schema.options.discriminatorKey) {
+      if (typeof val[Constructor.schema.options.discriminatorKey] === 'string' &&
+          Constructor.discriminators[val[Constructor.schema.options.discriminatorKey]]) {
+        Constructor = Constructor.discriminators[val[Constructor.schema.options.discriminatorKey]];
+      } else {
+        var constructorByValue = getDiscriminatorByValue(Constructor, val[Constructor.schema.options.discriminatorKey]);
+        if (constructorByValue) {
+          Constructor = constructorByValue;
+        }
+      }
     }
 
     var proto = this.casterConstructor.prototype;

package/lib/schema/documentarray.js

@@ -12,6 +12,7 @@ var SchemaType = require('../schematype');
 var discriminator = require('../services/model/discriminator');
 var util = require('util');
 var utils = require('../utils');
+var getDiscriminatorByValue = require('../queryhelpers').getDiscriminatorByValue;
 
 var MongooseDocumentArray;
 var Subdocument;
@@ -291,9 +292,17 @@ DocumentArray.prototype.cast = function(value, doc, init, prev, options) {
 
     var Constructor = this.casterConstructor;
     if (Constructor.discriminators &&
-        typeof value[i][Constructor.schema.options.discriminatorKey] === 'string' &&
-        Constructor.discriminators[value[i][Constructor.schema.options.discriminatorKey]]) {
-      Constructor = Constructor.discriminators[value[i][Constructor.schema.options.discriminatorKey]];
+        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 {
+        var constructorByValue = getDiscriminatorByValue(Constructor, value[i][Constructor.schema.options.discriminatorKey]);
+        if (constructorByValue) {
+          Constructor = constructorByValue;
+        }
+      }
     }
 
     // Check if the document has a different schema (re gh-3701)

package/lib/schema/embedded.js

@@ -11,6 +11,7 @@ const castToNumber = require('./operators/helpers').castToNumber;
 const discriminator = require('../services/model/discriminator');
 const geospatial = require('./operators/geospatial');
 const internalToObjectOptions = require('../options').internalToObjectOptions;
+var getDiscriminatorByValue = require('../queryhelpers').getDiscriminatorByValue;
 
 let Subdocument;
 
@@ -140,9 +141,15 @@ Embedded.prototype.cast = function(val, doc, init, priorVal) {
   var discriminatorKey = Constructor.schema.options.discriminatorKey;
   if (val != null &&
       Constructor.discriminators &&
-      typeof val[discriminatorKey] === 'string' &&
-      Constructor.discriminators[val[discriminatorKey]]) {
-    Constructor = Constructor.discriminators[val[discriminatorKey]];
+      typeof val[discriminatorKey] === 'string') {
+    if (Constructor.discriminators[val[discriminatorKey]]) {
+      Constructor = Constructor.discriminators[val[discriminatorKey]];
+    } else {
+      var constructorByValue = getDiscriminatorByValue(Constructor, val[discriminatorKey]);
+      if (constructorByValue) {
+        Constructor = constructorByValue;
+      }
+    }
   }
 
   var subdoc;
@@ -188,7 +195,22 @@ Embedded.prototype.castForQuery = function($conditional, val) {
     val = this._applySetters(val);
   }
 
-  return new this.caster(val);
+  var Constructor = this.caster;
+  var discriminatorKey = Constructor.schema.options.discriminatorKey;
+  if (val != null &&
+      Constructor.discriminators &&
+      typeof val[discriminatorKey] === 'string') {
+    if (Constructor.discriminators[val[discriminatorKey]]) {
+      Constructor = Constructor.discriminators[val[discriminatorKey]];
+    } else {
+      var constructorByValue = getDiscriminatorByValue(Constructor, val[discriminatorKey]);
+      if (constructorByValue) {
+        Constructor = constructorByValue;
+      }
+    }
+  }
+
+  return new Constructor(val);
 };
 
 /**
@@ -202,11 +224,18 @@ Embedded.prototype.doValidate = function(value, fn, scope) {
   var discriminatorKey = Constructor.schema.options.discriminatorKey;
   if (value != null &&
       Constructor.discriminators &&
-      typeof value[discriminatorKey] === 'string' &&
-      Constructor.discriminators[value[discriminatorKey]]) {
-    Constructor = Constructor.discriminators[value[discriminatorKey]];
+      typeof value[discriminatorKey] === 'string') {
+    if (Constructor.discriminators[value[discriminatorKey]]) {
+      Constructor = Constructor.discriminators[value[discriminatorKey]];
+    } else {
+      var constructorByValue = getDiscriminatorByValue(Constructor, value[discriminatorKey]);
+      if (constructorByValue) {
+        Constructor = constructorByValue;
+      }
+    }
   }
 
+
   SchemaType.prototype.doValidate.call(this, value, function(error) {
     if (error) {
       return fn(error);

package/lib/schema/objectid.js

@@ -206,6 +206,8 @@ function defaultId() {
   return new oid();
 }
 
+defaultId.$runBeforeSetters = true;
+
 function resetId(v) {
   Document || (Document = require('./../document'));
 

package/lib/schema.js

@@ -29,7 +29,6 @@ var mpath = require('mpath');
  * - [bufferCommands](/docs/guide.html#bufferCommands): bool - defaults to true
  * - [capped](/docs/guide.html#capped): bool - defaults to false
  * - [collection](/docs/guide.html#collection): string - no default
- * - [emitIndexErrors](/docs/guide.html#emitIndexErrors): bool - defaults to false.
  * - [id](/docs/guide.html#id): bool - defaults to true
  * - [_id](/docs/guide.html#_id): bool - defaults to true
  * - `minimize`: bool - controls [document#toObject](#document_Document-toObject) behavior when called manually - defaults to true

package/lib/schematype.js

@@ -245,15 +245,19 @@ SchemaType.prototype.sparse = function(bool) {
  *     }
  *
  *     // defining within the schema
- *     var s = new Schema({ name: { type: String, set: capitalize }})
+ *     var s = new Schema({ name: { type: String, set: capitalize }});
  *
- *     // or by retreiving its SchemaType
+ *     // or with the SchemaType
  *     var s = new Schema({ name: String })
- *     s.path('name').set(capitalize)
+ *     s.path('name').set(capitalize);
  *
- * Setters allow you to transform the data before it gets to the raw mongodb document and is set as a value on an actual key.
+ * Setters allow you to transform the data before it gets to the raw mongodb
+ * document or query.
  *
- * Suppose you are implementing user registration for a website. Users provide an email and password, which gets saved to mongodb. The email is a string that you will want to normalize to lower case, in order to avoid one email having more than one account -- e.g., otherwise, avenue@q.com can be registered for 2 accounts via avenue@q.com and AvEnUe@Q.CoM.
+ * Suppose you are implementing user registration for a website. Users provide
+ * an email and password, which gets saved to mongodb. The email is a string
+ * that you will want to normalize to lower case, in order to avoid one email
+ * having more than one account -- e.g., otherwise, avenue@q.com can be registered for 2 accounts via avenue@q.com and AvEnUe@Q.CoM.
  *
  * You can set up email lower case normalization easily via a Mongoose setter.
  *
@@ -276,7 +280,8 @@ SchemaType.prototype.sparse = function(bool) {
  *     console.log(user.email); // 'avenue@q.com'
  *     User.updateOne({ _id: _id }, { $set: { email: 'AVENUE@Q.COM' } }); // update to 'avenue@q.com'
  *
- * As you can see above, setters allow you to transform the data before it stored in MongoDB.
+ * As you can see above, setters allow you to transform the data before it
+ * stored in MongoDB, or before executing a query.
  *
  * _NOTE: we could have also just used the built-in `lowercase: true` SchemaType option instead of defining our own function._
  *
@@ -303,6 +308,24 @@ SchemaType.prototype.sparse = function(bool) {
  *     console.log(v.name);     // name is required
  *     console.log(v.taxonomy); // Parvovirinae
  *
+ * You can also use setters to modify other properties on the document. If
+ * you're setting a property `name` on a document, the setter will run with
+ * `this` as the document. Be careful, in mongoose 5 setters will also run
+ * when querying by `name` with `this` as the query.
+ *
+ * ```javascript
+ * const nameSchema = new Schema({ name: String, keywords: [String] });
+ * nameSchema.path('name').set(function(v) {
+ *   // Need to check if `this` is a document, because in mongoose 5
+ *   // setters will also run on queries, in which case `this` will be a
+ *   // mongoose query object.
+ *   if (this instanceof Document && v != null) {
+ *     this.keywords = v.split(' ');
+ *   }
+ *   return v;
+ * });
+ * ```
+ *
  * @param {Function} fn
  * @return {SchemaType} this
  * @api public

package/lib/services/model/discriminator.js

@@ -14,7 +14,7 @@ var CUSTOMIZABLE_DISCRIMINATOR_OPTIONS = {
  * ignore
  */
 
-module.exports = function discriminator(model, name, schema) {
+module.exports = function discriminator(model, name, schema, tiedValue) {
   if (!(schema && schema.instanceOfSchema)) {
     throw new Error('You must pass a valid discriminator Schema');
   }
@@ -46,6 +46,11 @@ module.exports = function discriminator(model, name, schema) {
         '" cannot have field with name "' + key + '"');
   }
 
+  var value = name;
+  if (typeof tiedValue == 'string' && tiedValue.length) {
+    value = tiedValue;
+  }
+
   function merge(schema, baseSchema) {
     if (baseSchema.paths._id &&
         baseSchema.paths._id.options &&
@@ -55,15 +60,38 @@ module.exports = function discriminator(model, name, schema) {
       delete schema.paths._id;
       delete schema.tree._id;
     }
-    utils.merge(schema, baseSchema, { omit: { discriminators: true } });
+
+    // Find conflicting paths: if something is a path in the base schema
+    // and a nested path in the child schema, overwrite the base schema path.
+    // See gh-6076
+    var baseSchemaPaths = Object.keys(baseSchema.paths);
+    var conflictingPaths = [];
+    for (i = 0; i < baseSchemaPaths.length; ++i) {
+      if (schema.nested[baseSchemaPaths[i]]) {
+        conflictingPaths.push(baseSchemaPaths[i]);
+      }
+    }
+
+    utils.merge(schema, baseSchema, {
+      omit: { discriminators: true },
+      omitNested: conflictingPaths.reduce((cur, path) => {
+        cur['tree.' + path] = true;
+        return cur;
+      }, {})
+    });
+
+    // Clean up conflicting paths _after_ merging re: gh-6076
+    for (i = 0; i < conflictingPaths.length; ++i) {
+      delete schema.paths[conflictingPaths[i]];
+    }
 
     var obj = {};
     obj[key] = {
-      default: name,
+      default: value,
       select: true,
       set: function(newName) {
-        if (newName === name) {
-          return name;
+        if (newName === value) {
+          return value;
         }
         throw new Error('Can\'t set discriminator key "' + key + '"');
       },
@@ -71,7 +99,7 @@ module.exports = function discriminator(model, name, schema) {
     };
     obj[key][schema.options.typeKey] = String;
     schema.add(obj);
-    schema.discriminatorMapping = {key: key, value: name, isRoot: false};
+    schema.discriminatorMapping = {key: key, value: value, isRoot: false};
 
     if (baseSchema.options.collection) {
       schema.options.collection = baseSchema.options.collection;

package/lib/services/query/castUpdate.js

@@ -71,7 +71,7 @@ module.exports = function castUpdate(schema, obj, options, context) {
         typeof val === 'object' &&
         !Buffer.isBuffer(val) &&
         (!overwrite || hasDollarKey)) {
-      hasKeys |= walkUpdatePath(schema, val, op, options.strict, context);
+      hasKeys |= walkUpdatePath(schema, val, op, options, context);
     } else if (overwrite && ret && typeof ret === 'object') {
       // if we are just using overwrite, cast the query and then we will
       // *always* return the value, even if it is an empty object. We need to
@@ -79,7 +79,7 @@ module.exports = function castUpdate(schema, obj, options, context) {
       // user passes {} and wants to clobber the whole document
       // Also, _walkUpdatePath expects an operation, so give it $set since that
       // is basically what we're doing
-      walkUpdatePath(schema, ret, '$set', options.strict, context);
+      walkUpdatePath(schema, ret, '$set', options, context);
     } else {
       var msg = 'Invalid atomic update value for ' + op + '. '
           + 'Expected an object, received ' + typeof val;
@@ -97,14 +97,17 @@ module.exports = function castUpdate(schema, obj, options, context) {
  * @param {Schema} schema
  * @param {Object} obj - part of a query
  * @param {String} op - the atomic operator ($pull, $set, etc)
- * @param {Boolean|String} strict
+ * @param {Object} options
+ * @param {Boolean|String} [options.strict]
+ * @param {Boolean} [options.omitUndefined]
  * @param {Query} context
  * @param {String} pref - path prefix (internal only)
  * @return {Bool} true if this path has keys to update
  * @api private
  */
 
-function walkUpdatePath(schema, obj, op, strict, context, pref) {
+function walkUpdatePath(schema, obj, op, options, context, pref) {
+  var strict = options.strict;
   var prefix = pref ? pref + '.' : '';
   var keys = Object.keys(obj);
   var i = keys.length;
@@ -126,9 +129,8 @@ function walkUpdatePath(schema, obj, op, strict, context, pref) {
       schematype = schema._getSchema(prefix + key);
       if (schematype && schematype.caster && op in castOps) {
         // embedded doc schema
-        hasKeys = true;
-
         if ('$each' in val) {
+          hasKeys = true;
           try {
             obj[key] = {
               $each: castUpdateVal(schematype, val.$each, op, context)
@@ -154,6 +156,13 @@ function walkUpdatePath(schema, obj, op, strict, context, pref) {
           } catch (error) {
             aggregatedError = _handleCastError(error, context, key, aggregatedError);
           }
+
+          if (options.omitUndefined && obj[key] === void 0) {
+            delete obj[key];
+            continue;
+          }
+
+          hasKeys = true;
         }
       } else if ((op === '$currentDate') || (op in castOps && schematype)) {
         // $currentDate can take an object
@@ -163,6 +172,11 @@ function walkUpdatePath(schema, obj, op, strict, context, pref) {
           aggregatedError = _handleCastError(error, context, key, aggregatedError);
         }
 
+        if (options.omitUndefined && obj[key] === void 0) {
+          delete obj[key];
+          continue;
+        }
+
         hasKeys = true;
       } else {
         var pathToCheck = (prefix + key);
@@ -187,7 +201,7 @@ function walkUpdatePath(schema, obj, op, strict, context, pref) {
         // gh-2314
         // we should be able to set a schema-less field
         // to an empty object literal
-        hasKeys |= walkUpdatePath(schema, val, op, strict, context, prefix + key) ||
+        hasKeys |= walkUpdatePath(schema, val, op, options, context, prefix + key) ||
           (utils.isObject(val) && Object.keys(val).length === 0);
       }
     } else {
@@ -222,7 +236,6 @@ function walkUpdatePath(schema, obj, op, strict, context, pref) {
           continue;
         }
 
-        hasKeys = true;
         try {
           obj[key] = castUpdateVal(schematype, val, op, key, context);
         } catch (error) {
@@ -232,6 +245,13 @@ function walkUpdatePath(schema, obj, op, strict, context, pref) {
         if (Array.isArray(obj[key]) && (op === '$addToSet' || op === '$push') && key !== '$each') {
           obj[key] = { $each: obj[key] };
         }
+
+        if (options.omitUndefined && obj[key] === void 0) {
+          delete obj[key];
+          continue;
+        }
+
+        hasKeys = true;
       }
     }
   }

package/lib/services/updateValidators.js

@@ -1,12 +1,14 @@
+'use strict';
+
 /*!
  * Module dependencies.
  */
 
-var Mixed = require('../schema/mixed');
-var ValidationError = require('../error/validation');
-var parallel = require('async/parallel');
-var flatten = require('./common').flatten;
-var modifiedPaths = require('./common').modifiedPaths;
+const Mixed = require('../schema/mixed');
+const ValidationError = require('../error/validation');
+const flatten = require('./common').flatten;
+const modifiedPaths = require('./common').modifiedPaths;
+const parallel = require('async/parallel');
 
 /**
  * Applies validators and defaults to update and findOneAndUpdate operations,
@@ -57,6 +59,11 @@ module.exports = function(query, schema, castedDoc, options) {
         var updatedPath = paths[j].replace('.$.', '.0.');
         updatedPath = updatedPath.replace(/\.\$$/, '.0');
         key = keys[i];
+        // With `$pull` we might flatten `$in`. Skip stuff nested under `$in`
+        // for the rest of the logic, it will get handled later.
+        if (updatedPath.indexOf('$') !== -1) {
+          continue;
+        }
         if (key === '$set' || key === '$setOnInsert' ||
             key === '$pull' || key === '$pullAll') {
           updatedValues[updatedPath] = flat[paths[j]];
@@ -86,19 +93,38 @@ module.exports = function(query, schema, castedDoc, options) {
       if (schemaPath instanceof Mixed && schemaPath.$fullPath !== updates[i]) {
         return;
       }
-      validatorsToExecute.push(function(callback) {
-        schemaPath.doValidate(
-          v,
-          function(err) {
-            if (err) {
-              err.path = updates[i];
-              validationErrors.push(err);
-            }
-            callback(null);
-          },
-          options && options.context === 'query' ? query : null,
-          {updateValidator: true});
-      });
+
+      if (v && Array.isArray(v.$in)) {
+        v.$in.forEach((v, i) => {
+          validatorsToExecute.push(function(callback) {
+            schemaPath.doValidate(
+              v,
+              function(err) {
+                if (err) {
+                  err.path = updates[i] + '.$in.' + i;
+                  validationErrors.push(err);
+                }
+                callback(null);
+              },
+              options && options.context === 'query' ? query : null,
+              {updateValidator: true});
+          });
+        });
+      } else {
+        validatorsToExecute.push(function(callback) {
+          schemaPath.doValidate(
+            v,
+            function(err) {
+              if (err) {
+                err.path = updates[i];
+                validationErrors.push(err);
+              }
+              callback(null);
+            },
+            options && options.context === 'query' ? query : null,
+            {updateValidator: true});
+        });
+      }
     }
   }
   for (i = 0; i < numUpdates; ++i) {

package/lib/types/documentarray.js

@@ -10,6 +10,7 @@ const ObjectIdSchema = require('../schema/objectid');
 const internalToObjectOptions = require('../options').internalToObjectOptions;
 const utils = require('../utils');
 const Document = require('../document');
+const getDiscriminatorByValue = require('../queryhelpers').getDiscriminatorByValue;
 
 /**
  * DocumentArray constructor
@@ -123,10 +124,18 @@ MongooseDocumentArray.mixin = {
 
     if (value &&
         Constructor.discriminators &&
-        Constructor.schema.options.discriminatorKey &&
-        typeof value[Constructor.schema.options.discriminatorKey] === 'string' &&
-        Constructor.discriminators[value[Constructor.schema.options.discriminatorKey]]) {
-      Constructor = Constructor.discriminators[value[Constructor.schema.options.discriminatorKey]];
+        Constructor.schema &&
+        Constructor.schema.options &&
+        Constructor.schema.options.discriminatorKey) {
+      if (typeof value[Constructor.schema.options.discriminatorKey] === 'string' &&
+          Constructor.discriminators[value[Constructor.schema.options.discriminatorKey]]) {
+        Constructor = Constructor.discriminators[value[Constructor.schema.options.discriminatorKey]];
+      } else {
+        var constructorByValue = getDiscriminatorByValue(Constructor, value[Constructor.schema.options.discriminatorKey]);
+        if (constructorByValue) {
+          Constructor = constructorByValue;
+        }
+      }
     }
 
     return new Constructor(value, this, undefined, undefined, index);
@@ -233,10 +242,18 @@ MongooseDocumentArray.mixin = {
     var Constructor = this._schema.casterConstructor;
     if (obj &&
         Constructor.discriminators &&
-        Constructor.schema.options.discriminatorKey &&
-        typeof obj[Constructor.schema.options.discriminatorKey] === 'string' &&
-        Constructor.discriminators[obj[Constructor.schema.options.discriminatorKey]]) {
-      Constructor = Constructor.discriminators[obj[Constructor.schema.options.discriminatorKey]];
+        Constructor.schema &&
+        Constructor.schema.options &&
+        Constructor.schema.options.discriminatorKey) {
+      if (typeof obj[Constructor.schema.options.discriminatorKey] === 'string' &&
+          Constructor.discriminators[obj[Constructor.schema.options.discriminatorKey]]) {
+        Constructor = Constructor.discriminators[obj[Constructor.schema.options.discriminatorKey]];
+      } else {
+        var constructorByValue = getDiscriminatorByValue(Constructor, obj[Constructor.schema.options.discriminatorKey]);
+        if (constructorByValue) {
+          Constructor = constructorByValue;
+        }
+      }
     }
 
     return new Constructor(obj);

package/lib/utils.js

@@ -306,7 +306,7 @@ exports.random = function() {
  * @api private
  */
 
-exports.merge = function merge(to, from, options) {
+exports.merge = function merge(to, from, options, path) {
   options = options || {};
 
   const keys = Object.keys(from);
@@ -314,18 +314,24 @@ exports.merge = function merge(to, from, options) {
   const len = keys.length;
   let key;
 
+  path = path || '';
+  const omitNested = options.omitNested || {};
+
   while (i < len) {
     key = keys[i++];
     if (options.omit && options.omit[key]) {
       continue;
     }
+    if (omitNested[path]) {
+      continue;
+    }
     if (to[key] == null) {
       to[key] = from[key];
     } else if (exports.isObject(from[key])) {
       if (!exports.isObject(to[key])) {
         to[key] = {};
       }
-      merge(to[key], from[key], options);
+      merge(to[key], from[key], options, path ? path + '.' + key : key);
     } else if (options.overwrite) {
       to[key] = from[key];
     }

package/migrating_to_5.md

@@ -33,6 +33,21 @@ mongoose.connect('mongodb://localhost:27017/test');
 mongoose.model('Test', new Schema({}));
 ```
 
+### Connection Logic and `useMongoClient`
+
+The [`useMongoClient` option](http://mongoosejs.com/docs/4.x/docs/connections.html#use-mongo-client) was
+removed in Mongoose 5, it is now always `true`. As a consequence, Mongoose 5
+no longer supports several function signatures for `mongoose.connect()` that
+worked in Mongoose 4.x if the `useMongoClient` option was off. Below are some
+examples of `mongoose.connect()` calls that do **not** work in Mongoose 5.x.
+
+* `mongoose.connect('localhost', 27017);`
+* `mongoose.connect('localhost', 'mydb', 27017);`
+* `mongoose.connect('mongodb://host1:27017,mongodb://host2:27017');`
+
+In Mongoose 5.x, the first parameter to `mongoose.connect()` and `mongoose.createConnection()`, if specified, **must** be a [MongoDB connection string](https://docs.mongodb.com/manual/reference/connection-string/). The
+connection string and options are then passed down to [the MongoDB Node.js driver's `MongoClient.connect()` function](http://mongodb.github.io/node-mongodb-native/3.0/api/MongoClient.html#.connect). Mongoose does not modify the connection string, although `mongoose.connect()` and `mongoose.createConnection()` support a [few additional options in addition to the ones the MongoDB driver supports](http://mongoosejs.com/docs/connections.html#options).
+
 ### Setter Order
 
 Setters run in reverse order in 4.x:
@@ -134,6 +149,36 @@ The above code does **not** work in 5.x, you **must** wrap the `$match` and `$sk
 MyModel.aggregate([{ $match: { isDeleted: false } }, { $skip: 10 }]).exec(cb);
 ```
 
+### Boolean Casting
+
+By default, mongoose 4 would coerce any value to a boolean without error.
+
+```javascript
+// Fine in mongoose 4, would save a doc with `boolField = true`
+const MyModel = mongoose.model('Test', new Schema({
+  boolField: Boolean
+}));
+
+MyModel.create({ boolField: 'not a boolean' });
+```
+
+Mongoose 5 only casts the following values to `true`:
+
+* `true`
+* `'true'`
+* `1`
+* `'1'`
+* `'yes'`
+
+And the following values to `false`:
+
+* `false`
+* `'false'`
+* `0`
+* `'0'`
+* `'no'`
+
+All other values will cause a `CastError`
 ### Query Casting
 
 Casting for `update()`, `updateOne()`, `updateMany()`, `replaceOne()`,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "5.0.7",
+  "version": "5.0.11",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -23,7 +23,7 @@
     "bson": "~1.0.4",
     "kareem": "2.0.5",
     "lodash.get": "4.4.2",
-    "mongodb": "3.0.2",
+    "mongodb": "3.0.4",
     "mongoose-legacy-pluralize": "1.0.2",
     "mpath": "0.3.0",
     "mquery": "3.0.0",
@@ -64,8 +64,8 @@
     "fix-lint": "eslint . --fix",
     "lint": "eslint . --quiet",
     "nsp": "nsp check",
-    "release": "git push origin master --tags && npm publish",
-    "release-legacy": "git push origin 4.x --tags && npm publish --tag legacy",
+    "release": "git pull && git push origin master --tags && npm publish",
+    "release-legacy": "git pull origin 4.x && git push origin 4.x --tags && npm publish --tag legacy",
     "test": "mocha --exit test/*.test.js test/**/*.test.js",
     "test-cov": "nyc --reporter=html --reporter=text npm test"
   },
@@ -81,7 +81,7 @@
     "url": "git://github.com/Automattic/mongoose.git"
   },
   "homepage": "http://mongoosejs.com",
-  "browser": "lib/browser.js",
+  "browser": "./browser.js",
   "eslintConfig": {
     "extends": [
       "eslint:recommended"

package/lib/document_provider.web.js

@@ -1,17 +0,0 @@
-'use strict';
-
-/* eslint-env browser */
-
-/*!
- * Module dependencies.
- */
-var BrowserDocument = require('./browserDocument.js');
-
-/**
- * Returns the Document constructor for the current context
- *
- * @api private
- */
-module.exports = function() {
-  return BrowserDocument;
-};