mongoose 5.7.8 → 5.7.12

package/History.md

@@ -1,3 +1,36 @@
+5.7.12 / 2019-11-19
+===================
+ * fix: avoid throwing error if calling `push()` on a doc array with no parent #8351 #8317 #8312 [AbdelrahmanHafez](https://github.com/AbdelrahmanHafez)
+ * fix(connection): only buffer for "open" events when calling connection helper while connecting #8319
+ * fix(connection): pull default database from connection string if specified #8355 #8354 [zachazar](https://github.com/zachazar)
+ * fix(populate+discriminator): handle populating document whose discriminator value is different from discriminator model name #8324
+ * fix: add `mongoose.isValidObjectId()` function to test whether Mongoose can cast a value to an objectid #3823
+ * fix(model): support setting `excludeIndexes` as schema option for subdocs #8343
+ * fix: add SchemaMapOptions class for options to map schematype #8318
+ * docs(query): remove duplicate omitUndefined options #8349 [mdumandag](https://github.com/mdumandag)
+ * docs(schema): add Schema#paths docs to public API docs #8340
+
+5.7.11 / 2019-11-14
+===================
+ * fix: update mongodb driver -> 3.3.4 #8276
+ * fix(model): throw readable error when casting bulkWrite update without a 'filter' or 'update' #8332 #8331 [AbdelrahmanHafez](https://github.com/AbdelrahmanHafez)
+ * fix(connection): bubble up connected/disconnected events with unified topology #8338 #8337
+ * fix(model): delete $versionError after saving #8326 #8048 [Fonger](https://github.com/Fonger)
+ * test(model): add test for issue #8040 #8341 [Fonger](https://github.com/Fonger)
+
+5.7.10 / 2019-11-11
+===================
+ * perf(cursor): remove unnecessary `setTimeout()` in `eachAsync()`, 4x speedup in basic benchmarks #8310
+ * docs(README): re-order sections for better readability #8321 [dandv](https://github.com/dandv)
+ * chore: make npm test not hard-code file paths #8322 [stieg](https://github.com/stieg)
+
+5.7.9 / 2019-11-08
+==================
+ * fix(schema): support setting schema path to an instance of SchemaTypeOptions to fix integration with mongoose-i18n-localize #8297 #8292
+ * fix(populate): make `retainNullValues` set array element to `null` if foreign doc with that id was not found #8293
+ * fix(document): support getter setting virtual on manually populated doc when calling toJSON() #8295
+ * fix(model): allow objects with `toBSON()` to make it to `save()` #8299
+
 5.7.8 / 2019-11-04
 ==================
  * fix(document): allow manually populating path within document array #8273

package/README.md

@@ -1,6 +1,6 @@
 # Mongoose
 
-Mongoose is a [MongoDB](https://www.mongodb.org/) object modeling tool designed to work in an asynchronous environment.
+Mongoose is a [MongoDB](https://www.mongodb.org/) object modeling tool designed to work in an asynchronous environment. Mongoose supports both promises and callbacks.
 
 [![Slack Status](http://slack.mongoosejs.io/badge.svg)](http://slack.mongoosejs.io)
 [![Build Status](https://api.travis-ci.org/Automattic/mongoose.svg?branch=master)](https://travis-ci.org/Automattic/mongoose)
@@ -22,16 +22,6 @@ Mongoose is a [MongoDB](https://www.mongodb.org/) object modeling tool designed
   - [Help Forum](http://groups.google.com/group/mongoose-orm)
   - [MongoDB Support](https://docs.mongodb.org/manual/support/)
 
-## Importing
-
-```javascript
-// Using Node.js `require()`
-const mongoose = require('mongoose');
-
-// Using ES6 imports
-import mongoose from 'mongoose';
-```
-
 ## Plugins
 
 Check out the [plugins search site](http://plugins.mongoosejs.io/) to see hundreds of related modules from the community. Next, learn how to write your own plugin from the [docs](http://mongoosejs.com/docs/plugins.html) or [this blog post](http://thecodebarbarian.com/2015/03/06/guide-to-mongoose-plugins).
@@ -55,6 +45,16 @@ First install [node.js](http://nodejs.org/) and [mongodb](https://www.mongodb.or
 $ npm install mongoose
 ```
 
+## Importing
+
+```javascript
+// Using Node.js `require()`
+const mongoose = require('mongoose');
+
+// Using ES6 imports
+import mongoose from 'mongoose';
+```
+
 ## Overview
 
 ### Connecting to MongoDB
@@ -64,9 +64,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
-const mongoose = require('mongoose');
-
-mongoose.connect('mongodb://localhost/my_database', {
+await mongoose.connect('mongodb://localhost/my_database', {
   useNewUrlParser: true,
   useUnifiedTopology: true
 });
@@ -172,7 +170,14 @@ MyModel.find({}, function (err, docs) {
 });
 ```
 
-You can also `findOne`, `findById`, `update`, etc. For more details check out [the docs](http://mongoosejs.com/docs/queries.html).
+You can also `findOne`, `findById`, `update`, etc.
+
+```js
+const instance = await MyModel.findOne({ ... });
+console.log(instance.my.key);  // 'hello'
+```
+
+For more details check out [the docs](http://mongoosejs.com/docs/queries.html).
 
 **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:
 

package/lib/connection.js

@@ -420,7 +420,7 @@ function _wrapConnHelper(fn) {
       Array.prototype.slice.call(arguments, 0, arguments.length - 1) :
       Array.prototype.slice.call(arguments);
     return utils.promiseOrCallback(cb, cb => {
-      if (this.readyState !== STATES.connected) {
+      if (this.readyState === STATES.connecting) {
         this.once('open', function() {
           fn.apply(this, argsWithoutCb.concat([cb]));
         });
@@ -605,7 +605,13 @@ Connection.prototype.openUri = function(uri, options, callback) {
       if (err) {
         return reject(err);
       }
-      this.name = dbName != null ? dbName : get(parsed, 'auth.db', null);
+      if (dbName) {
+        this.name = dbName;
+      } else if (parsed.defaultDatabase) {
+        this.name = parsed.defaultDatabase;
+      } else {
+        this.name = get(parsed, 'auth.db', null);
+      }
       this.host = get(parsed, 'hosts.0.host', 'localhost');
       this.port = get(parsed, 'hosts.0.port', 27017);
       this.user = this.user || get(parsed, 'auth.username');
@@ -643,11 +649,14 @@ Connection.prototype.openUri = function(uri, options, callback) {
       if (options.useUnifiedTopology) {
         if (type === 'Single') {
           const server = Array.from(db.s.topology.s.servers.values())[0];
-          server.s.pool.on('reconnect', () => {
+          server.s.pool.on('close', () => {
+            _this.readyState = STATES.disconnected;
+          });
+          server.s.topology.on('serverHeartbeatSucceeded', () => {
             _handleReconnect();
           });
-          server.s.pool.on('reconnectFailed', () => {
-            _this.emit('reconnectFailed');
+          server.s.pool.on('reconnect', () => {
+            _handleReconnect();
           });
           server.s.pool.on('timeout', () => {
             _this.emit('timeout');

package/lib/document.js

@@ -2836,6 +2836,13 @@ Document.prototype.$toObject = function(options, json) {
     minimize: _minimize
   });
 
+  if (utils.hasUserDefinedProperty(options, 'getters')) {
+    cloneOptions.getters = options.getters;
+  }
+  if (utils.hasUserDefinedProperty(options, 'virtuals')) {
+    cloneOptions.virtuals = options.virtuals;
+  }
+
   const depopulate = options.depopulate ||
     get(options, '_parentOptions.depopulate', false);
   // _isNested will only be true if this is not the top level document, we
@@ -2852,6 +2859,10 @@ Document.prototype.$toObject = function(options, json) {
   options.minimize = _minimize;
 
   cloneOptions._parentOptions = options;
+  cloneOptions._skipSingleNestedGetters = true;
+
+  const gettersOptions = Object.assign({}, cloneOptions);
+  gettersOptions._skipSingleNestedGetters = false;
 
   // remember the root transform function
   // to save it from being overwritten by sub-transform functions
@@ -2860,16 +2871,15 @@ Document.prototype.$toObject = function(options, json) {
   let ret = clone(this._doc, cloneOptions) || {};
 
   if (options.getters) {
-    applyGetters(this, ret, cloneOptions);
-    // applyGetters for paths will add nested empty objects;
-    // if minimize is set, we need to remove them.
+    applyGetters(this, ret, gettersOptions);
+
     if (options.minimize) {
       ret = minimize(ret) || {};
     }
   }
 
-  if (options.virtuals || options.getters && options.virtuals !== false) {
-    applyVirtuals(this, ret, cloneOptions, options);
+  if (options.virtuals || (options.getters && options.virtuals !== false)) {
+    applyVirtuals(this, ret, gettersOptions, options);
   }
 
   if (options.versionKey === false && this.schema.options.versionKey) {
@@ -3180,12 +3190,7 @@ function applyGetters(self, json, options) {
       v = cur[part];
       if (ii === last) {
         const val = self.get(path);
-        // Ignore single nested docs: getters will run because of `clone()`
-        // before `applyGetters()` in `$toObject()`. Quirk because single
-        // nested subdocs are hydrated docs in `_doc` as opposed to POJOs.
-        if (val != null && val.$__ == null) {
-          branch[part] = clone(val, options);
-        }
+        branch[part] = clone(val, options);
       } else if (v == null) {
         if (part in cur) {
           branch[part] = v;

package/lib/helpers/cursor/eachAsync.js

@@ -99,13 +99,11 @@ function asyncQueue() {
   };
 
   function _step() {
-    setTimeout(() => {
-      inProgress = null;
-      if (_queue.length > 0) {
-        inProgress = id++;
-        const fn = _queue.shift();
-        fn(_step);
-      }
-    }, 0);
+    inProgress = null;
+    if (_queue.length > 0) {
+      inProgress = id++;
+      const fn = _queue.shift();
+      fn(_step);
+    }
   }
 }

package/lib/helpers/discriminator/getConstructor.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const getDiscriminatorByValue = require('../../queryhelpers').getDiscriminatorByValue;
+const getDiscriminatorByValue = require('./getDiscriminatorByValue');
 
 /*!
  * Find the correct constructor, taking into account discriminators

package/lib/helpers/discriminator/getDiscriminatorByValue.js

@@ -0,0 +1,27 @@
+'use strict';
+
+/*!
+* returns discriminator by discriminatorMapping.value
+*
+* @param {Model} model
+* @param {string} value
+*/
+
+module.exports = function getDiscriminatorByValue(model, value) {
+  let discriminator = null;
+  if (!model.discriminators) {
+    return discriminator;
+  }
+  for (const name in model.discriminators) {
+    const it = model.discriminators[name];
+    if (
+      it.schema &&
+     it.schema.discriminatorMapping &&
+     it.schema.discriminatorMapping.value == value
+    ) {
+      discriminator = it;
+      break;
+    }
+  }
+  return discriminator;
+};

package/lib/helpers/model/castBulkWrite.js

@@ -34,6 +34,9 @@ module.exports = function castBulkWrite(model, op, options) {
     op = op['updateOne'];
     return (callback) => {
       try {
+        if (!op['filter']) throw new Error('Must provide a filter object.');
+        if (!op['update']) throw new Error('Must provide an update object.');
+
         op['filter'] = cast(model.schema, op['filter']);
         op['update'] = castUpdate(model.schema, op['update'], {
           strict: model.schema.options.strict,
@@ -61,6 +64,9 @@ module.exports = function castBulkWrite(model, op, options) {
     op = op['updateMany'];
     return (callback) => {
       try {
+        if (!op['filter']) throw new Error('Must provide a filter object.');
+        if (!op['update']) throw new Error('Must provide an update object.');
+
         op['filter'] = cast(model.schema, op['filter']);
         op['update'] = castUpdate(model.schema, op['update'], {
           strict: model.schema.options.strict,

package/lib/helpers/populate/assignRawDocsToIdStructure.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const modelSymbol = require('../symbols').modelSymbol;
+
 module.exports = assignRawDocsToIdStructure;
 
 /*!
@@ -63,8 +65,10 @@ function assignRawDocsToIdStructure(rawIds, resultDocs, resultOrder, options, re
         } else {
           newOrder.push(doc);
         }
+      } else if (id != null && id[modelSymbol] != null) {
+        newOrder.push(id);
       } else {
-        newOrder.push(nullIfNotFound ? null : id);
+        newOrder.push(options.retainNullValues || nullIfNotFound ? null : id);
       }
     } else {
       // apply findOne behavior - if document in results, assign, else assign null

package/lib/helpers/populate/getModelsMapForPopulate.js

@@ -2,6 +2,7 @@
 
 const MongooseError = require('../../error/index');
 const get = require('../get');
+const getDiscriminatorByValue = require('../discriminator/getDiscriminatorByValue');
 const isPathExcluded = require('../projection/isPathExcluded');
 const getSchemaTypes = require('./getSchemaTypes');
 const getVirtual = require('./getVirtual');
@@ -297,12 +298,18 @@ module.exports = function getModelsMapForPopulate(model, docs, options) {
 
       if (!schema && discriminatorKey) {
         modelForFindSchema = utils.getValue(discriminatorKey, doc);
-
         if (modelForFindSchema) {
-          try {
-            modelForCurrentDoc = model.db.model(modelForFindSchema);
-          } catch (error) {
-            return error;
+          // `modelForFindSchema` is the discriminator value, so we might need
+          // find the discriminated model name
+          const discriminatorModel = getDiscriminatorByValue(model, modelForFindSchema);
+          if (discriminatorModel != null) {
+            modelForCurrentDoc = discriminatorModel;
+          } else {
+            try {
+              modelForCurrentDoc = model.db.model(modelForFindSchema);
+            } catch (error) {
+              return error;
+            }
           }
 
           schemaForCurrentDoc = modelForCurrentDoc.schema._getSchema(options.path);

package/lib/helpers/schema/getIndexes.js

@@ -36,7 +36,8 @@ module.exports = function getIndexes(schema) {
 
       if (path.$isMongooseDocumentArray || path.$isSingleNested) {
         if (get(path, 'options.excludeIndexes') !== true &&
-            get(path, 'schemaOptions.excludeIndexes') !== true) {
+            get(path, 'schemaOptions.excludeIndexes') !== true &&
+            get(path, 'schema.options.excludeIndexes') !== true) {
           collectIndexes(path.schema, prefix + key + '.');
         }
 

package/lib/index.js

@@ -933,6 +933,51 @@ Mongoose.prototype.DocumentProvider = require('./document_provider');
 
 Mongoose.prototype.ObjectId = SchemaTypes.ObjectId;
 
+/**
+ * Returns true if Mongoose can cast the given value to an ObjectId, or
+ * false otherwise.
+ *
+ * ####Example:
+ *
+ *     mongoose.isValidObjectId(new mongoose.Types.ObjectId()); // true
+ *     mongoose.isValidObjectId('0123456789ab'); // true
+ *     mongoose.isValidObjectId(6); // false
+ *
+ * @method isValidObjectId
+ * @api public
+ */
+
+Mongoose.prototype.isValidObjectId = function(v) {
+  if (v == null) {
+    return true;
+  }
+  const base = this || mongoose;
+  const ObjectId = base.driver.get().ObjectId;
+  if (v instanceof ObjectId) {
+    return true;
+  }
+
+  if (v._id != null) {
+    if (v._id instanceof ObjectId) {
+      return true;
+    }
+    if (v._id.toString instanceof Function) {
+      v = v._id.toString();
+      return typeof v === 'string' && (v.length === 12 || v.length === 24);
+    }
+  }
+
+  if (v.toString instanceof Function) {
+    v = v.toString();
+  }
+
+  if (typeof v === 'string' && (v.length === 12 || v.length === 24)) {
+    return true;
+  }
+
+  return false;
+};
+
 /**
  * The Mongoose Decimal128 [SchemaType](/docs/schematypes.html). Used for
  * declaring paths in your schema that should be

package/lib/model.js

@@ -30,7 +30,7 @@ const assignVals = require('./helpers/populate/assignVals');
 const castBulkWrite = require('./helpers/model/castBulkWrite');
 const discriminator = require('./helpers/model/discriminator');
 const each = require('./helpers/each');
-const getDiscriminatorByValue = require('./queryhelpers').getDiscriminatorByValue;
+const getDiscriminatorByValue = require('./helpers/discriminator/getDiscriminatorByValue');
 const getModelsMapForPopulate = require('./helpers/populate/getModelsMapForPopulate');
 const immediate = require('./helpers/immediate');
 const internalToObjectOptions = require('./options').internalToObjectOptions;
@@ -52,6 +52,10 @@ const modelDbSymbol = Symbol('mongoose#Model#db');
 const modelSymbol = require('./helpers/symbols').modelSymbol;
 const subclassedSymbol = Symbol('mongoose#Model#subclassed');
 
+const saveToObjectOptions = Object.assign({}, internalToObjectOptions, {
+  bson: true
+});
+
 /**
  * A Model is a class that's your primary tool for interacting with MongoDB.
  * An instance of a Model is called a [Document](./api.html#Document).
@@ -244,7 +248,7 @@ Model.prototype.$__handleSave = function(options, callback) {
 
   if (this.isNew) {
     // send entire doc
-    const obj = this.toObject(internalToObjectOptions);
+    const obj = this.toObject(saveToObjectOptions);
 
     if ((obj || {})._id === void 0) {
       // documents must have an _id else mongoose won't know
@@ -461,7 +465,7 @@ Model.prototype.save = function(options, fn) {
     this.$__save(options, error => {
       this.$__.saving = undefined;
       delete this.$__.saveOptions;
-      delete this.$__.versionError;
+      delete this.$__.$versionError;
 
       if (error) {
         this.$__handleReject(error);

package/lib/options/SchemaArrayOptions.js

@@ -17,12 +17,7 @@ const SchemaTypeOptions = require('./SchemaTypeOptions');
 
 class SchemaArrayOptions extends SchemaTypeOptions {}
 
-const opts = {
-  enumerable: true,
-  configurable: true,
-  writable: true,
-  value: null
-};
+const opts = require('./propertyOptions');
 
 /**
  * If this is an array of strings, an array of allowed values for this path.

package/lib/options/SchemaBufferOptions.js

@@ -17,12 +17,7 @@ const SchemaTypeOptions = require('./SchemaTypeOptions');
 
 class SchemaBufferOptions extends SchemaTypeOptions {}
 
-const opts = {
-  enumerable: true,
-  configurable: true,
-  writable: true,
-  value: null
-};
+const opts = require('./propertyOptions');
 
 /**
  * Set the default subtype for this buffer.

package/lib/options/SchemaDateOptions.js

@@ -17,12 +17,7 @@ const SchemaTypeOptions = require('./SchemaTypeOptions');
 
 class SchemaDateOptions extends SchemaTypeOptions {}
 
-const opts = {
-  enumerable: true,
-  configurable: true,
-  writable: true,
-  value: null
-};
+const opts = require('./propertyOptions');
 
 /**
  * If set, Mongoose adds a validator that checks that this path is after the

package/lib/options/SchemaDocumentArrayOptions.js

@@ -0,0 +1,48 @@
+'use strict';
+
+const SchemaTypeOptions = require('./SchemaTypeOptions');
+
+/**
+ * The options defined on an Document Array schematype.
+ *
+ * ####Example:
+ *
+ *     const schema = new Schema({ users: [{ name: string }] });
+ *     schema.path('users').options; // SchemaDocumentArrayOptions instance
+ *
+ * @api public
+ * @inherits SchemaTypeOptions
+ * @constructor SchemaDocumentOptions
+ */
+
+class SchemaDocumentArrayOptions extends SchemaTypeOptions {}
+
+const opts = require('./propertyOptions');
+
+/**
+ * If `true`, Mongoose will skip building any indexes defined in this array's schema.
+ * If not set, Mongoose will build all indexes defined in this array's schema.
+ *
+ * ####Example:
+ *
+ *     const childSchema = Schema({ name: { type: String, index: true } });
+ *     // If `excludeIndexes` is `true`, Mongoose will skip building an index
+ *     // on `arr.name`. Otherwise, Mongoose will build an index on `arr.name`.
+ *     const parentSchema = Schema({
+ *       arr: { type: [childSchema], excludeIndexes: true }
+ *     });
+ *
+ * @api public
+ * @property excludeIndexes
+ * @memberOf SchemaDocumentArrayOptions
+ * @type Array
+ * @instance
+ */
+
+Object.defineProperty(SchemaDocumentArrayOptions.prototype, 'excludeIndexes', opts);
+
+/*!
+ * ignore
+ */
+
+module.exports = SchemaDocumentArrayOptions;

package/lib/options/SchemaMapOptions.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const SchemaTypeOptions = require('./SchemaTypeOptions');
+
+/**
+ * The options defined on a Map schematype.
+ *
+ * ####Example:
+ *
+ *     const schema = new Schema({ socialMediaHandles: { type: Map, of: String } });
+ *     schema.path('socialMediaHandles').options; // SchemaMapOptions instance
+ *
+ * @api public
+ * @inherits SchemaTypeOptions
+ * @constructor SchemaMapOptions
+ */
+
+class SchemaMapOptions extends SchemaTypeOptions {}
+
+const opts = require('./propertyOptions');
+
+/**
+ * If set, specifies the type of this map's values. Mongoose will cast
+ * this map's values to the given type.
+ *
+ * If not set, Mongoose will not cast the map's values.
+ *
+ * ####Example:
+ *
+ *     // Mongoose will cast `socialMediaHandles` values to strings
+ *     const schema = new Schema({ socialMediaHandles: { type: Map, of: String } });
+ *     schema.path('socialMediaHandles').options.of; // String
+ *
+ * @api public
+ * @property of
+ * @memberOf SchemaMapOptions
+ * @type Function|string
+ * @instance
+ */
+
+Object.defineProperty(SchemaMapOptions.prototype, 'of', opts);
+
+module.exports = SchemaMapOptions;

package/lib/options/SchemaNumberOptions.js

@@ -17,12 +17,7 @@ const SchemaTypeOptions = require('./SchemaTypeOptions');
 
 class SchemaNumberOptions extends SchemaTypeOptions {}
 
-const opts = {
-  enumerable: true,
-  configurable: true,
-  writable: true,
-  value: null
-};
+const opts = require('./propertyOptions');
 
 /**
  * If set, Mongoose adds a validator that checks that this path is at least the

package/lib/options/SchemaObjectIdOptions.js

@@ -17,12 +17,7 @@ const SchemaTypeOptions = require('./SchemaTypeOptions');
 
 class SchemaObjectIdOptions extends SchemaTypeOptions {}
 
-const opts = {
-  enumerable: true,
-  configurable: true,
-  writable: true,
-  value: null
-};
+const opts = require('./propertyOptions');
 
 /**
  * If truthy, uses Mongoose's default built-in ObjectId path.

package/lib/options/SchemaStringOptions.js

@@ -17,12 +17,7 @@ const SchemaTypeOptions = require('./SchemaTypeOptions');
 
 class SchemaStringOptions extends SchemaTypeOptions {}
 
-const opts = {
-  enumerable: true,
-  configurable: true,
-  writable: true,
-  value: null
-};
+const opts = require('./propertyOptions');
 
 /**
  * Array of allowed values for this path

package/lib/options/SchemaTypeOptions.js

@@ -23,12 +23,7 @@ class SchemaTypeOptions {
   }
 }
 
-const opts = {
-  enumerable: true,
-  configurable: true,
-  writable: true,
-  value: null
-};
+const opts = require('./propertyOptions');
 
 /**
  * The type to cast this path to.

package/lib/options/propertyOptions.js

@@ -0,0 +1,8 @@
+'use strict';
+
+module.exports = Object.freeze({
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: void 0
+});

package/lib/query.js

@@ -18,6 +18,7 @@ const castArrayFilters = require('./helpers/update/castArrayFilters');
 const castUpdate = require('./helpers/query/castUpdate');
 const completeMany = require('./helpers/query/completeMany');
 const get = require('./helpers/get');
+const getDiscriminatorByValue = require('./helpers/discriminator/getDiscriminatorByValue');
 const hasDollarKeys = require('./helpers/query/hasDollarKeys');
 const helpers = require('./queryhelpers');
 const isInclusive = require('./helpers/projection/isInclusive');
@@ -3862,7 +3863,6 @@ Query.prototype._replaceOne = wrapThunk(function(callback) {
  * @param {Boolean|String} [options.strict] overwrites the schema's [strict mode option](http://mongoosejs.com/docs/guide.html#strict)
  * @param {Boolean} [options.upsert=false] if true, and no documents found, insert a new document
  * @param {Object} [options.writeConcern=null] sets the [write concern](https://docs.mongodb.com/manual/reference/write-concern/) for replica sets. Overrides the [schema-level write concern](/docs/guide.html#writeConcern)
- * @param {Boolean} [options.omitUndefined=false] If true, delete any properties whose value is `undefined` when casting an update. In other words, if this is set, Mongoose will delete `baz` from the update in `Model.updateOne({}, { foo: 'bar', baz: undefined })` before sending the update to the server.
  * @param {Boolean} [options.timestamps=null] If set to `false` and [schema-level timestamps](/docs/guide.html#timestamps) are enabled, skip timestamps for this update. Does nothing if schema-level timestamps are not set.
  * @param {Function} [callback] params are (error, writeOpResult)
  * @return {Query} this
@@ -3928,7 +3928,6 @@ Query.prototype.update = function(conditions, doc, options, callback) {
  * @param {Boolean|String} [options.strict] overwrites the schema's [strict mode option](http://mongoosejs.com/docs/guide.html#strict)
  * @param {Boolean} [options.upsert=false] if true, and no documents found, insert a new document
  * @param {Object} [options.writeConcern=null] sets the [write concern](https://docs.mongodb.com/manual/reference/write-concern/) for replica sets. Overrides the [schema-level write concern](/docs/guide.html#writeConcern)
- * @param {Boolean} [options.omitUndefined=false] If true, delete any properties whose value is `undefined` when casting an update. In other words, if this is set, Mongoose will delete `baz` from the update in `Model.updateOne({}, { foo: 'bar', baz: undefined })` before sending the update to the server.
  * @param {Boolean} [options.timestamps=null] If set to `false` and [schema-level timestamps](/docs/guide.html#timestamps) are enabled, skip timestamps for this update. Does nothing if schema-level timestamps are not set.
  * @param {Function} [callback] params are (error, writeOpResult)
  * @return {Query} this
@@ -3995,7 +3994,6 @@ Query.prototype.updateMany = function(conditions, doc, options, callback) {
  * @param {Boolean|String} [options.strict] overwrites the schema's [strict mode option](http://mongoosejs.com/docs/guide.html#strict)
  * @param {Boolean} [options.upsert=false] if true, and no documents found, insert a new document
  * @param {Object} [options.writeConcern=null] sets the [write concern](https://docs.mongodb.com/manual/reference/write-concern/) for replica sets. Overrides the [schema-level write concern](/docs/guide.html#writeConcern)
- * @param {Boolean} [options.omitUndefined=false] If true, delete any properties whose value is `undefined` when casting an update. In other words, if this is set, Mongoose will delete `baz` from the update in `Model.updateOne({}, { foo: 'bar', baz: undefined })` before sending the update to the server.
  * @param {Boolean} [options.timestamps=null] If set to `false` and [schema-level timestamps](/docs/guide.html#timestamps) are enabled, skip timestamps for this update. Does nothing if schema-level timestamps are not set.
  * @param {Function} [callback] params are (error, writeOpResult)
  * @return {Query} this
@@ -4060,7 +4058,6 @@ Query.prototype.updateOne = function(conditions, doc, options, callback) {
  * @param {Boolean|String} [options.strict] overwrites the schema's [strict mode option](http://mongoosejs.com/docs/guide.html#strict)
  * @param {Boolean} [options.upsert=false] if true, and no documents found, insert a new document
  * @param {Object} [options.writeConcern=null] sets the [write concern](https://docs.mongodb.com/manual/reference/write-concern/) for replica sets. Overrides the [schema-level write concern](/docs/guide.html#writeConcern)
- * @param {Boolean} [options.omitUndefined=false] If true, delete any properties whose value is `undefined` when casting an update. In other words, if this is set, Mongoose will delete `baz` from the update in `Model.updateOne({}, { foo: 'bar', baz: undefined })` before sending the update to the server.
  * @param {Boolean} [options.timestamps=null] If set to `false` and [schema-level timestamps](/docs/guide.html#timestamps) are enabled, skip timestamps for this update. Does nothing if schema-level timestamps are not set.
  * @param {Function} [callback] params are (error, writeOpResult)
  * @return {Query} this
@@ -4433,7 +4430,7 @@ Query.prototype._castUpdate = function _castUpdate(obj, overwrite) {
       typeof filter[schema.options.discriminatorKey] !== 'object' &&
       schema.discriminators != null) {
     const discriminatorValue = filter[schema.options.discriminatorKey];
-    const byValue = helpers.getDiscriminatorByValue(this.model, discriminatorValue);
+    const byValue = getDiscriminatorByValue(this.model, discriminatorValue);
     schema = schema.discriminators[discriminatorValue] ||
       (byValue && byValue.schema) ||
       schema;

package/lib/queryhelpers.js

@@ -7,6 +7,8 @@
 const checkEmbeddedDiscriminatorKeyProjection =
   require('./helpers/discriminator/checkEmbeddedDiscriminatorKeyProjection');
 const get = require('./helpers/get');
+const getDiscriminatorByValue =
+  require('./helpers/discriminator/getDiscriminatorByValue');
 const isDefiningProjection = require('./helpers/projection/isDefiningProjection');
 const utils = require('./utils');
 
@@ -71,34 +73,6 @@ exports.preparePopulationOptionsMQ = function preparePopulationOptionsMQ(query,
   return pop;
 };
 
-
-/*!
- * returns discriminator by discriminatorMapping.value
- *
- * @param {Model} model
- * @param {string} value
- */
-function getDiscriminatorByValue(model, value) {
-  let discriminator = null;
-  if (!model.discriminators) {
-    return discriminator;
-  }
-  for (const name in model.discriminators) {
-    const 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.

package/lib/schema/array.js

@@ -17,7 +17,7 @@ const util = require('util');
 const utils = require('../utils');
 const castToNumber = require('./operators/helpers').castToNumber;
 const geospatial = require('./operators/geospatial');
-const getDiscriminatorByValue = require('../queryhelpers').getDiscriminatorByValue;
+const getDiscriminatorByValue = require('../helpers/discriminator/getDiscriminatorByValue');
 
 let MongooseArray;
 let EmbeddedDoc;

package/lib/schema/documentarray.js

@@ -7,6 +7,8 @@
 const ArrayType = require('./array');
 const CastError = require('../error/cast');
 const EventEmitter = require('events').EventEmitter;
+const SchemaDocumentArrayOptions =
+  require('../options/SchemaDocumentArrayOptions');
 const SchemaType = require('../schematype');
 const discriminator = require('../helpers/model/discriminator');
 const get = require('../helpers/get');
@@ -91,6 +93,7 @@ DocumentArrayPath.options = { castNonArrays: true };
  */
 DocumentArrayPath.prototype = Object.create(ArrayType.prototype);
 DocumentArrayPath.prototype.constructor = DocumentArrayPath;
+DocumentArrayPath.prototype.OptionsConstructor = SchemaDocumentArrayOptions;
 
 /*!
  * Ignore

package/lib/schema/map.js

@@ -5,6 +5,7 @@
  */
 
 const MongooseMap = require('../types/map');
+const SchemaMapOptions = require('../options/SchemaMapOptions');
 const SchemaType = require('../schematype');
 
 /*!
@@ -42,4 +43,6 @@ class Map extends SchemaType {
   }
 }
 
+Map.prototype.OptionsConstructor = SchemaMapOptions;
+
 module.exports = Map;

package/lib/schema.js

@@ -7,6 +7,7 @@
 const EventEmitter = require('events').EventEmitter;
 const Kareem = require('kareem');
 const SchemaType = require('./schematype');
+const SchemaTypeOptions = require('./options/SchemaTypeOptions');
 const VirtualType = require('./virtualtype');
 const applyTimestampsToChildren = require('./helpers/update/applyTimestampsToChildren');
 const applyTimestampsToUpdate = require('./helpers/update/applyTimestampsToUpdate');
@@ -71,6 +72,9 @@ let id = 0;
  * - [timestamps](/docs/guide.html#timestamps): object or boolean - defaults to `false`. If true, Mongoose adds `createdAt` and `updatedAt` properties to your schema and manages those properties for you.
  * - [storeSubdocValidationError](/docs/guide.html#storeSubdocValidationError): boolean - Defaults to true. If false, Mongoose will wrap validation errors in single nested document subpaths into a single validation error on the single nested subdoc's path.
  *
+ * ####Options for Nested Schemas:
+ * - `excludeIndexes`: bool - defaults to `false`. If `true`, skip building indexes on this schema's paths.
+ *
  * ####Note:
  *
  * _When nesting schemas, (`children` in the example above), always declare the child schema first before passing it into its parent._
@@ -234,15 +238,17 @@ Object.defineProperty(Schema.prototype, 'childSchemas', {
 Schema.prototype.obj;
 
 /**
- * Schema as flat paths
+ * The paths defined on this schema. The keys are the top-level paths
+ * in this schema, and the values are instances of the SchemaType class.
  *
  * ####Example:
- *     {
- *         '_id'        : SchemaType,
- *       , 'nested.key' : SchemaType,
- *     }
+ *     const schema = new Schema({ name: String }, { _id: false });
+ *     schema.paths; // { name: SchemaString { ... } }
  *
- * @api private
+ *     schema.add({ age: Number });
+ *     schema.paths; // { name: SchemaString { ... }, age: SchemaNumber { ... } }
+ *
+ * @api public
  * @property paths
  * @memberOf Schema
  * @instance
@@ -426,7 +432,7 @@ Schema.prototype.add = function add(obj, prefix) {
         '`, got value "' + obj[key][0] + '"');
     }
 
-    if (utils.isPOJO(obj[key]) &&
+    if ((utils.isPOJO(obj[key]) || obj[key] instanceof SchemaTypeOptions) &&
         (!obj[key][this.options.typeKey] || (this.options.typeKey === 'type' && obj[key].type.type))) {
       if (Object.keys(obj[key]).length) {
         // nested object { last: { name: String }}
@@ -795,7 +801,7 @@ Schema.prototype.interpretAsType = function(path, obj, options) {
   // copy of SchemaTypes re: gh-7158 gh-6933
   const MongooseTypes = this.base != null ? this.base.Schema.Types : Schema.Types;
 
-  if (obj.constructor) {
+  if (!utils.isPOJO(obj) && !(obj instanceof SchemaTypeOptions)) {
     const constructorName = utils.getFunctionName(obj.constructor);
     if (constructorName !== 'Object') {
       const oldObj = obj;

package/lib/types/documentarray.js

@@ -8,7 +8,7 @@ const CoreMongooseArray = require('./core_array');
 const Document = require('../document');
 const ObjectId = require('./objectid');
 const castObjectId = require('../cast/objectid');
-const getDiscriminatorByValue = require('../queryhelpers').getDiscriminatorByValue;
+const getDiscriminatorByValue = require('../helpers/discriminator/getDiscriminatorByValue');
 const internalToObjectOptions = require('../options').internalToObjectOptions;
 const util = require('util');
 const utils = require('../utils');
@@ -172,6 +172,14 @@ class CoreDocumentArray extends CoreMongooseArray {
     }));
   }
 
+  slice() {
+    const arr = super.slice.apply(this, arguments);
+    arr[arrayParentSymbol] = this[arrayParentSymbol];
+    arr[arrayPathSymbol] = this[arrayPathSymbol];
+
+    return arr;
+  }
+
   /**
    * Wraps [`Array#push`](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/push) with proper change tracking.
    *
@@ -320,18 +328,18 @@ if (util.inspect.custom) {
 
 function _updateParentPopulated(arr) {
   const parent = arr[arrayParentSymbol];
-  if (parent.$__.populated != null) {
-    const populatedPaths = Object.keys(parent.$__.populated).
-      filter(p => p.startsWith(arr[arrayPathSymbol] + '.'));
+  if (!parent || parent.$__.populated == null) return;
 
-    for (const path of populatedPaths) {
-      const remnant = path.slice((arr[arrayPathSymbol] + '.').length);
-      if (!Array.isArray(parent.$__.populated[path].value)) {
-        continue;
-      }
+  const populatedPaths = Object.keys(parent.$__.populated).
+    filter(p => p.startsWith(arr[arrayPathSymbol] + '.'));
 
-      parent.$__.populated[path].value = arr.map(val => val.populated(remnant));
+  for (const path of populatedPaths) {
+    const remnant = path.slice((arr[arrayPathSymbol] + '.').length);
+    if (!Array.isArray(parent.$__.populated[path].value)) {
+      continue;
     }
+
+    parent.$__.populated[path].value = arr.map(val => val.populated(remnant));
   }
 }
 

package/lib/utils.js

@@ -193,6 +193,11 @@ exports.clone = function clone(obj, options, isArrayChild) {
   }
 
   if (isMongooseObject(obj)) {
+    // Single nested subdocs should apply getters later in `applyGetters()`
+    // when calling `toObject()`. See gh-7442, gh-8295
+    if (options && options._skipSingleNestedGetters && obj.$isSingleNested) {
+      options = Object.assign({}, options, { getters: false });
+    }
     if (options && options.json && typeof obj.toJSON === 'function') {
       return obj.toJSON(options);
     }
@@ -232,6 +237,13 @@ exports.clone = function clone(obj, options, isArrayChild) {
     return obj.clone();
   }
 
+  // If we're cloning this object to go into a MongoDB command,
+  // and there's a `toBSON()` function, assume this object will be
+  // stored as a primitive in MongoDB and doesn't need to be cloned.
+  if (options && options.bson && typeof obj.toBSON === 'function') {
+    return obj;
+  }
+
   if (obj.valueOf != null) {
     return obj.valueOf();
   }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "5.7.8",
+  "version": "5.7.12",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -21,7 +21,7 @@
   "dependencies": {
     "bson": "~1.1.1",
     "kareem": "2.3.1",
-    "mongodb": "3.3.3",
+    "mongodb": "3.3.4",
     "mongoose-legacy-pluralize": "1.0.2",
     "mpath": "0.6.0",
     "mquery": "3.2.2",
@@ -73,7 +73,7 @@
     "lint": "eslint .",
     "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": "mocha --exit",
     "test-cov": "nyc --reporter=html --reporter=text npm test"
   },
   "main": "./index.js",
@@ -89,6 +89,14 @@
   },
   "homepage": "https://mongoosejs.com",
   "browser": "./browser.js",
+  "mocha": {
+    "extension": [
+      "test.js"
+    ],
+    "watch-files": [
+      "test/**/*.js"
+    ]
+  },
   "eslintConfig": {
     "extends": [
       "eslint:recommended"