mongoose 6.2.1 → 6.2.4

package/lib/helpers/indexes/getRelatedIndexes.js

@@ -0,0 +1,59 @@
+'use strict';
+
+function getRelatedSchemaIndexes(model, schemaIndexes) {
+  return getRelatedIndexes({
+    baseModelName: model.baseModelName,
+    discriminatorMapping: model.schema.discriminatorMapping,
+    indexes: schemaIndexes,
+    indexesType: 'schema'
+  });
+}
+
+function getRelatedDBIndexes(model, dbIndexes) {
+  return getRelatedIndexes({
+    baseModelName: model.baseModelName,
+    discriminatorMapping: model.schema.discriminatorMapping,
+    indexes: dbIndexes,
+    indexesType: 'db'
+  });
+}
+
+module.exports = {
+  getRelatedSchemaIndexes,
+  getRelatedDBIndexes
+};
+
+function getRelatedIndexes({
+  baseModelName,
+  discriminatorMapping,
+  indexes,
+  indexesType
+}) {
+  const discriminatorKey = discriminatorMapping && discriminatorMapping.key;
+  const discriminatorValue = discriminatorMapping && discriminatorMapping.value;
+
+  if (!discriminatorKey) {
+    return indexes;
+  }
+
+  const isChildDiscriminatorModel = Boolean(baseModelName);
+  if (isChildDiscriminatorModel) {
+    return indexes.filter(index => {
+      const partialFilterExpression = getPartialFilterExpression(index, indexesType);
+      return partialFilterExpression && partialFilterExpression[discriminatorKey] === discriminatorValue;
+    });
+  }
+
+  return indexes.filter(index => {
+    const partialFilterExpression = getPartialFilterExpression(index, indexesType);
+    return !partialFilterExpression || !partialFilterExpression[discriminatorKey];
+  });
+}
+
+function getPartialFilterExpression(index, indexesType) {
+  if (indexesType === 'schema') {
+    const options = index[1];
+    return options && options.partialFilterExpression;
+  }
+  return index.partialFilterExpression;
+}

package/lib/helpers/isAsyncFunction.js

@@ -1,11 +1,10 @@
 'use strict';
 
-const { inspect } = require('util');
+const asyncFunctionPrototype = Object.getPrototypeOf(async function() {});
 
 module.exports = function isAsyncFunction(v) {
-  if (typeof v !== 'function') {
-    return;
-  }
-
-  return inspect(v).startsWith('[AsyncFunction:');
-};
+  return (
+    typeof v === 'function' &&
+    Object.getPrototypeOf(v) === asyncFunctionPrototype
+  );
+};

package/lib/helpers/populate/assignVals.js

@@ -172,6 +172,10 @@ module.exports = function assignVals(o) {
       o.allOptions.options[populateModelSymbol] = o.allOptions.model;
       docs[i].$populated(_path, o.unpopulatedValues[i], o.allOptions.options);
 
+      if (valueToSet != null && valueToSet.$__ != null) {
+        valueToSet.$__.wasPopulated = { value: o.unpopulatedValues[i] };
+      }
+
       if (valueToSet instanceof Map && !valueToSet.$isMongooseMap) {
         valueToSet = new MongooseMap(valueToSet, _path, docs[i], docs[i].schema.path(_path).$__schemaType);
       }

package/lib/helpers/printJestWarning.js

@@ -6,12 +6,12 @@ if (typeof jest !== 'undefined' && typeof window !== 'undefined') {
   utils.warn('Mongoose: looks like you\'re trying to test a Mongoose app ' +
     'with Jest\'s default jsdom test environment. Please make sure you read ' +
     'Mongoose\'s docs on configuring Jest to test Node.js apps: ' +
-    'http://mongoosejs.com/docs/jest.html');
+    'https://mongoosejs.com/docs/jest.html');
 }
 
 if (typeof jest !== 'undefined' && process.nextTick.toString().indexOf('nextTick') === -1) {
   utils.warn('Mongoose: looks like you\'re trying to test a Mongoose app ' +
     'with Jest\'s mock timers enabled. Please make sure you read ' +
     'Mongoose\'s docs on configuring Jest to test Node.js apps: ' +
-    'http://mongoosejs.com/docs/jest.html');
+    'https://mongoosejs.com/docs/jest.html');
 }

package/lib/helpers/projection/applyProjection.js

@@ -0,0 +1,77 @@
+'use strict';
+
+const hasIncludedChildren = require('./hasIncludedChildren');
+const isExclusive = require('./isExclusive');
+const isInclusive = require('./isInclusive');
+const isPOJO = require('../../utils').isPOJO;
+
+module.exports = function applyProjection(doc, projection, _hasIncludedChildren) {
+  if (projection == null) {
+    return doc;
+  }
+  if (doc == null) {
+    return doc;
+  }
+
+  let exclude = null;
+  if (isInclusive(projection)) {
+    exclude = false;
+  } else if (isExclusive(projection)) {
+    exclude = true;
+  }
+
+  if (exclude == null) {
+    return doc;
+  } else if (exclude) {
+    _hasIncludedChildren = _hasIncludedChildren || hasIncludedChildren(projection);
+    return applyExclusiveProjection(doc, projection, _hasIncludedChildren);
+  } else {
+    _hasIncludedChildren = _hasIncludedChildren || hasIncludedChildren(projection);
+    return applyInclusiveProjection(doc, projection, _hasIncludedChildren);
+  }
+};
+
+function applyExclusiveProjection(doc, projection, hasIncludedChildren, projectionLimb, prefix) {
+  if (doc == null || typeof doc !== 'object') {
+    return doc;
+  }
+  const ret = { ...doc };
+  projectionLimb = prefix ? (projectionLimb || {}) : projection;
+
+  for (const key of Object.keys(ret)) {
+    const fullPath = prefix ? prefix + '.' + key : key;
+    if (projection.hasOwnProperty(fullPath) || projectionLimb.hasOwnProperty(key)) {
+      if (isPOJO(projection[fullPath]) || isPOJO(projectionLimb[key])) {
+        ret[key] = applyExclusiveProjection(ret[key], projection, hasIncludedChildren, projectionLimb[key], fullPath);
+      } else {
+        delete ret[key];
+      }
+    } else if (hasIncludedChildren[fullPath]) {
+      ret[key] = applyExclusiveProjection(ret[key], projection, hasIncludedChildren, projectionLimb[key], fullPath);
+    }
+  }
+  return ret;
+}
+
+function applyInclusiveProjection(doc, projection, hasIncludedChildren, projectionLimb, prefix) {
+  if (doc == null || typeof doc !== 'object') {
+    return doc;
+  }
+  const ret = { ...doc };
+  projectionLimb = prefix ? (projectionLimb || {}) : projection;
+
+  for (const key of Object.keys(ret)) {
+    const fullPath = prefix ? prefix + '.' + key : key;
+    if (projection.hasOwnProperty(fullPath) || projectionLimb.hasOwnProperty(key)) {
+      if (isPOJO(projection[fullPath]) || isPOJO(projectionLimb[key])) {
+        ret[key] = applyInclusiveProjection(ret[key], projection, hasIncludedChildren, projectionLimb[key], fullPath);
+      }
+      continue;
+    } else if (hasIncludedChildren[fullPath]) {
+      ret[key] = applyInclusiveProjection(ret[key], projection, hasIncludedChildren, projectionLimb[key], fullPath);
+    } else {
+      delete ret[key];
+    }
+  }
+  return ret;
+}

package/lib/helpers/projection/hasIncludedChildren.js

@@ -0,0 +1,36 @@
+'use strict';
+
+/*!
+ * Creates an object that precomputes whether a given path has child fields in
+ * the projection.
+ *
+ * ####Example:
+ *     const res = hasIncludedChildren({ 'a.b.c': 0 });
+ *     res.a; // 1
+ *     res['a.b']; // 1
+ *     res['a.b.c']; // 1
+ *     res['a.c']; // undefined
+ */
+
+module.exports = function hasIncludedChildren(fields) {
+  const hasIncludedChildren = {};
+  const keys = Object.keys(fields);
+
+  for (const key of keys) {
+    if (key.indexOf('.') === -1) {
+      hasIncludedChildren[key] = 1;
+      continue;
+    }
+    const parts = key.split('.');
+    let c = parts[0];
+
+    for (let i = 0; i < parts.length; ++i) {
+      hasIncludedChildren[c] = 1;
+      if (i + 1 < parts.length) {
+        c = c + '.' + parts[i + 1];
+      }
+    }
+  }
+
+  return hasIncludedChildren;
+};

package/lib/helpers/projection/isExclusive.js

@@ -21,8 +21,11 @@ module.exports = function isExclusive(projection) {
     while (ki--) {
       // Does this projection explicitly define inclusion/exclusion?
       // Explicitly avoid `$meta` and `$slice`
-      if (keys[ki] !== '_id' && isDefiningProjection(projection[keys[ki]])) {
-        exclude = !projection[keys[ki]];
+      const key = keys[ki];
+      if (key !== '_id' && isDefiningProjection(projection[key])) {
+        exclude = (projection[key] != null && typeof projection[key] === 'object') ?
+          isExclusive(projection[key]) :
+          !projection[key];
         break;
       }
     }

package/lib/helpers/projection/isInclusive.js

@@ -26,7 +26,11 @@ module.exports = function isInclusive(projection) {
     // 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 (isDefiningProjection(projection[prop]) && !!projection[prop]) {
-      return true;
+      if (projection[prop] != null && typeof projection[prop] === 'object') {
+        return isInclusive(projection[prop]);
+      } else {
+        return !!projection[prop];
+      }
     }
   }
 

package/lib/helpers/query/cast$expr.js

@@ -68,7 +68,7 @@ const dateOperators = new Set([
 ]);
 
 module.exports = function cast$expr(val, schema, strictQuery) {
-  if (typeof val !== 'object' || val == null) {
+  if (typeof val !== 'object' || val === null) {
     throw new Error('`$expr` must be an object');
   }
 
@@ -123,10 +123,8 @@ function _castExpression(val, schema, strictQuery) {
 
 function _omitUndefined(val) {
   const keys = Object.keys(val);
-  for (const key of keys) {
-    if (val[key] === void 0) {
-      delete val[key];
-    }
+  for (let i = 0, len = keys.length; i < len; ++i) {
+    (val[keys[i]] === void 0) && delete val[keys[i]];
   }
 }
 
@@ -144,15 +142,14 @@ function castNumberOperator(val) {
 }
 
 function castIn(val, schema, strictQuery) {
-  let search = val[0];
-  let path = val[1];
+  const path = val[1];
   if (!isPath(path)) {
     return val;
   }
+  const search = val[0];
 
-  path = path.slice(1);
-  const schematype = schema.path(path);
-  if (schematype == null) {
+  const schematype = schema.path(path.slice(1));
+  if (schematype === null) {
     if (strictQuery === false) {
       return val;
     } else if (strictQuery === 'throw') {
@@ -166,12 +163,10 @@ function castIn(val, schema, strictQuery) {
     throw new Error('Path must be an array for $in');
   }
 
-  if (schematype.$isMongooseDocumentArray) {
-    search = schematype.$embeddedSchemaType.cast(search);
-  } else {
-    search = schematype.caster.cast(search);
-  }
-  return [search, val[1]];
+  return [
+    schematype.$isMongooseDocumentArray ? schematype.$embeddedSchemaType.cast(search) : schematype.caster.cast(search),
+    path
+  ];
 }
 
 // { $op: [<number>, <number>] }
@@ -268,14 +263,14 @@ function castComparison(val, schema, strictQuery) {
 }
 
 function isPath(val) {
-  return typeof val === 'string' && val.startsWith('$');
+  return typeof val === 'string' && val[0] === '$';
 }
 
 function isLiteral(val) {
-  if (typeof val === 'string' && val.startsWith('$')) {
+  if (typeof val === 'string' && val[0] === '$') {
     return false;
   }
-  if (typeof val === 'object' && val != null && Object.keys(val).find(key => key.startsWith('$'))) {
+  if (typeof val === 'object' && val !== null && Object.keys(val).find(key => key[0] === '$')) {
     // The `$literal` expression can make an object a literal
     // https://docs.mongodb.com/manual/reference/operator/aggregation/literal/#mongodb-expression-exp.-literal
     return val.$literal != null;

package/lib/helpers/query/hasDollarKeys.js

@@ -4,16 +4,20 @@
  * ignore
  */
 
-module.exports = function(obj) {
-  if (obj == null || typeof obj !== 'object') {
+module.exports = function hasDollarKeys(obj) {
+
+  if (typeof obj !== 'object' || obj === null) {
     return false;
   }
+
   const keys = Object.keys(obj);
   const len = keys.length;
+
   for (let i = 0; i < len; ++i) {
-    if (keys[i].startsWith('$')) {
+    if (keys[i][0] === '$') {
       return true;
     }
   }
+
   return false;
 };

package/lib/helpers/query/isOperator.js

@@ -7,5 +7,8 @@ const specialKeys = new Set([
 ]);
 
 module.exports = function isOperator(path) {
-  return path.startsWith('$') && !specialKeys.has(path);
-};
+  return (
+    path[0] === '$' &&
+    !specialKeys.has(path)
+  );
+};

package/lib/helpers/schema/getIndexes.js

@@ -2,6 +2,7 @@
 
 const get = require('../get');
 const helperIsObject = require('../isObject');
+const decorateDiscriminatorIndexOptions = require('../indexes/decorateDiscriminatorIndexOptions');
 
 /*!
  * Gather all indexes defined in the schema, including single nested,
@@ -88,6 +89,7 @@ module.exports = function getIndexes(schema) {
         }
 
         const indexName = options && options.name;
+
         if (typeof indexName === 'string') {
           if (indexByName.has(indexName)) {
             Object.assign(indexByName.get(indexName), field);
@@ -108,9 +110,11 @@ module.exports = function getIndexes(schema) {
       fixSubIndexPaths(schema, prefix);
     } else {
       schema._indexes.forEach(function(index) {
-        if (!('background' in index[1])) {
-          index[1].background = true;
+        const options = index[1];
+        if (!('background' in options)) {
+          options.background = true;
         }
+        decorateDiscriminatorIndexOptions(schema, options);
       });
       indexes = indexes.concat(schema._indexes);
     }

package/lib/index.js

@@ -19,7 +19,6 @@ const Query = require('./query');
 const Model = require('./model');
 const applyPlugins = require('./helpers/schema/applyPlugins');
 const driver = require('./driver');
-const get = require('./helpers/get');
 const promiseOrCallback = require('./helpers/promiseOrCallback');
 const legacyPluralize = require('./helpers/pluralize');
 const utils = require('./utils');
@@ -252,17 +251,17 @@ Mongoose.prototype.get = Mongoose.prototype.set;
  *     db.openUri('localhost', 'database', port, [opts]);
  *
  * @param {String} [uri] a mongodb:// URI
- * @param {Object} [options] passed down to the [MongoDB driver's `connect()` function](http://mongodb.github.io/node-mongodb-native/3.0/api/MongoClient.html), except for 4 mongoose-specific options explained below.
- * @param {Boolean} [options.bufferCommands=true] Mongoose specific option. Set to false to [disable buffering](http://mongoosejs.com/docs/faq.html#callback_never_executes) on all models associated with this connection.
+ * @param {Object} [options] passed down to the [MongoDB driver's `connect()` function](https://mongodb.github.io/node-mongodb-native/3.0/api/MongoClient.html), except for 4 mongoose-specific options explained below.
+ * @param {Boolean} [options.bufferCommands=true] Mongoose specific option. Set to false to [disable buffering](https://mongoosejs.com/docs/faq.html#callback_never_executes) on all models associated with this connection.
  * @param {String} [options.dbName] The name of the database you want to use. If not provided, Mongoose uses the database name from connection string.
  * @param {String} [options.user] username for authentication, equivalent to `options.auth.user`. Maintained for backwards compatibility.
  * @param {String} [options.pass] password for authentication, equivalent to `options.auth.password`. Maintained for backwards compatibility.
  * @param {Boolean} [options.autoIndex=true] Mongoose-specific option. Set to false to disable automatic index creation for all models associated with this connection.
  * @param {Number} [options.reconnectTries=30] If you're connected to a single server or mongos proxy (as opposed to a replica set), the MongoDB driver will try to reconnect every `reconnectInterval` milliseconds for `reconnectTries` times, and give up afterward. When the driver gives up, the mongoose connection emits a `reconnectFailed` event. This option does nothing for replica set connections.
  * @param {Number} [options.reconnectInterval=1000] See `reconnectTries` option above.
- * @param {Class} [options.promiseLibrary] Sets the [underlying driver's promise library](http://mongodb.github.io/node-mongodb-native/3.1/api/MongoClient.html).
- * @param {Number} [options.maxPoolSize=5] The maximum number of sockets the MongoDB driver will keep open for this connection. Keep in mind that MongoDB only allows one operation per socket at a time, so you may want to increase this if you find you have a few slow queries that are blocking faster queries from proceeding. See [Slow Trains in MongoDB and Node.js](http://thecodebarbarian.com/slow-trains-in-mongodb-and-nodejs).
- * @param {Number} [options.minPoolSize=1] The minimum number of sockets the MongoDB driver will keep open for this connection. Keep in mind that MongoDB only allows one operation per socket at a time, so you may want to increase this if you find you have a few slow queries that are blocking faster queries from proceeding. See [Slow Trains in MongoDB and Node.js](http://thecodebarbarian.com/slow-trains-in-mongodb-and-nodejs).
+ * @param {Class} [options.promiseLibrary] Sets the [underlying driver's promise library](https://mongodb.github.io/node-mongodb-native/3.1/api/MongoClient.html).
+ * @param {Number} [options.maxPoolSize=5] The maximum number of sockets the MongoDB driver will keep open for this connection. Keep in mind that MongoDB only allows one operation per socket at a time, so you may want to increase this if you find you have a few slow queries that are blocking faster queries from proceeding. See [Slow Trains in MongoDB and Node.js](https://thecodebarbarian.com/slow-trains-in-mongodb-and-nodejs).
+ * @param {Number} [options.minPoolSize=1] The minimum number of sockets the MongoDB driver will keep open for this connection. Keep in mind that MongoDB only allows one operation per socket at a time, so you may want to increase this if you find you have a few slow queries that are blocking faster queries from proceeding. See [Slow Trains in MongoDB and Node.js](https://thecodebarbarian.com/slow-trains-in-mongodb-and-nodejs).
  * @param {Number} [options.connectTimeoutMS=30000] How long the MongoDB driver will wait before killing a socket due to inactivity _during initial connection_. Defaults to 30000. This option is passed transparently to [Node.js' `socket#setTimeout()` function](https://nodejs.org/api/net.html#net_socket_settimeout_timeout_callback).
  * @param {Number} [options.socketTimeoutMS=30000] How long the MongoDB driver will wait before killing a socket due to inactivity _after initial connection_. A socket may be inactive because of either no activity or a long-running operation. This is set to `30000` by default, you should set this to 2-3x your longest running operation if you expect some of your database operations to run longer than 20 seconds. This option is passed to [Node.js `socket#setTimeout()` function](https://nodejs.org/api/net.html#net_socket_settimeout_timeout_callback) after the MongoDB driver successfully completes.
  * @param {Number} [options.family=0] Passed transparently to [Node.js' `dns.lookup()`](https://nodejs.org/api/dns.html#dns_dns_lookup_hostname_options_callback) function. May be either `0`, `4`, or `6`. `4` means use IPv4 only, `6` means use IPv6 only, `0` means try both.
@@ -309,20 +308,20 @@ Mongoose.prototype.createConnection = function(uri, options, callback) {
  *     })
  *
  * @param {String} uri(s)
- * @param {Object} [options] passed down to the [MongoDB driver's `connect()` function](http://mongodb.github.io/node-mongodb-native/3.0/api/MongoClient.html), except for 4 mongoose-specific options explained below.
- * @param {Boolean} [options.bufferCommands=true] Mongoose specific option. Set to false to [disable buffering](http://mongoosejs.com/docs/faq.html#callback_never_executes) on all models associated with this connection.
+ * @param {Object} [options] passed down to the [MongoDB driver's `connect()` function](https://mongodb.github.io/node-mongodb-native/3.0/api/MongoClient.html), except for 4 mongoose-specific options explained below.
+ * @param {Boolean} [options.bufferCommands=true] Mongoose specific option. Set to false to [disable buffering](https://mongoosejs.com/docs/faq.html#callback_never_executes) on all models associated with this connection.
  * @param {Number} [options.bufferTimeoutMS=10000] Mongoose specific option. If `bufferCommands` is true, Mongoose will throw an error after `bufferTimeoutMS` if the operation is still buffered.
  * @param {String} [options.dbName] The name of the database we want to use. If not provided, use database name from connection string.
  * @param {String} [options.user] username for authentication, equivalent to `options.auth.user`. Maintained for backwards compatibility.
  * @param {String} [options.pass] password for authentication, equivalent to `options.auth.password`. Maintained for backwards compatibility.
- * @param {Number} [options.maxPoolSize=100] The maximum number of sockets the MongoDB driver will keep open for this connection. Keep in mind that MongoDB only allows one operation per socket at a time, so you may want to increase this if you find you have a few slow queries that are blocking faster queries from proceeding. See [Slow Trains in MongoDB and Node.js](http://thecodebarbarian.com/slow-trains-in-mongodb-and-nodejs).
+ * @param {Number} [options.maxPoolSize=100] The maximum number of sockets the MongoDB driver will keep open for this connection. Keep in mind that MongoDB only allows one operation per socket at a time, so you may want to increase this if you find you have a few slow queries that are blocking faster queries from proceeding. See [Slow Trains in MongoDB and Node.js](https://thecodebarbarian.com/slow-trains-in-mongodb-and-nodejs).
  * @param {Number} [options.minPoolSize=0] The minimum number of sockets the MongoDB driver will keep open for this connection.
  * @param {Number} [options.serverSelectionTimeoutMS] If `useUnifiedTopology = true`, the MongoDB driver will try to find a server to send any given operation to, and keep retrying for `serverSelectionTimeoutMS` milliseconds before erroring out. If not set, the MongoDB driver defaults to using `30000` (30 seconds).
  * @param {Number} [options.heartbeatFrequencyMS] If `useUnifiedTopology = true`, the MongoDB driver sends a heartbeat every `heartbeatFrequencyMS` to check on the status of the connection. A heartbeat is subject to `serverSelectionTimeoutMS`, so the MongoDB driver will retry failed heartbeats for up to 30 seconds by default. Mongoose only emits a `'disconnected'` event after a heartbeat has failed, so you may want to decrease this setting to reduce the time between when your server goes down and when Mongoose emits `'disconnected'`. We recommend you do **not** set this setting below 1000, too many heartbeats can lead to performance degradation.
  * @param {Boolean} [options.autoIndex=true] Mongoose-specific option. Set to false to disable automatic index creation for all models associated with this connection.
  * @param {Number} [options.reconnectTries=30] If you're connected to a single server or mongos proxy (as opposed to a replica set), the MongoDB driver will try to reconnect every `reconnectInterval` milliseconds for `reconnectTries` times, and give up afterward. When the driver gives up, the mongoose connection emits a `reconnectFailed` event. This option does nothing for replica set connections.
  * @param {Number} [options.reconnectInterval=1000] See `reconnectTries` option above.
- * @param {Class} [options.promiseLibrary] Sets the [underlying driver's promise library](http://mongodb.github.io/node-mongodb-native/3.1/api/MongoClient.html).
+ * @param {Class} [options.promiseLibrary] Sets the [underlying driver's promise library](https://mongodb.github.io/node-mongodb-native/3.1/api/MongoClient.html).
  * @param {Number} [options.connectTimeoutMS=30000] How long the MongoDB driver will wait before killing a socket due to inactivity _during initial connection_. Defaults to 30000. This option is passed transparently to [Node.js' `socket#setTimeout()` function](https://nodejs.org/api/net.html#net_socket_settimeout_timeout_callback).
  * @param {Number} [options.socketTimeoutMS=30000] How long the MongoDB driver will wait before killing a socket due to inactivity _after initial connection_. A socket may be inactive because of either no activity or a long-running operation. This is set to `30000` by default, you should set this to 2-3x your longest running operation if you expect some of your database operations to run longer than 20 seconds. This option is passed to [Node.js `socket#setTimeout()` function](https://nodejs.org/api/net.html#net_socket_settimeout_timeout_callback) after the MongoDB driver successfully completes.
  * @param {Number} [options.family=0] Passed transparently to [Node.js' `dns.lookup()`](https://nodejs.org/api/dns.html#dns_dns_lookup_hostname_options_callback) function. May be either `0`, `4`, or `6`. `4` means use IPv4 only, `6` means use IPv6 only, `0` means try both.
@@ -379,13 +378,13 @@ Mongoose.prototype.disconnect = function(callback) {
 /**
  * _Requires MongoDB >= 3.6.0._ Starts a [MongoDB session](https://docs.mongodb.com/manual/release-notes/3.6/#client-sessions)
  * for benefits like causal consistency, [retryable writes](https://docs.mongodb.com/manual/core/retryable-writes/),
- * and [transactions](http://thecodebarbarian.com/a-node-js-perspective-on-mongodb-4-transactions.html).
+ * and [transactions](https://thecodebarbarian.com/a-node-js-perspective-on-mongodb-4-transactions.html).
  *
  * Calling `mongoose.startSession()` is equivalent to calling `mongoose.connection.startSession()`.
  * Sessions are scoped to a connection, so calling `mongoose.startSession()`
  * starts a session on the [default mongoose connection](/docs/api.html#mongoose_Mongoose-connection).
  *
- * @param {Object} [options] see the [mongodb driver options](http://mongodb.github.io/node-mongodb-native/3.0/api/MongoClient.html#startSession)
+ * @param {Object} [options] see the [mongodb driver options](https://mongodb.github.io/node-mongodb-native/3.0/api/MongoClient.html#startSession)
  * @param {Boolean} [options.causalConsistency=true] set to false to disable causal consistency
  * @param {Function} [callback]
  * @return {Promise<ClientSession>} promise that resolves to a MongoDB driver `ClientSession`
@@ -632,10 +631,8 @@ Mongoose.prototype._applyPlugins = function(schema, options) {
   const _mongoose = this instanceof Mongoose ? this : mongoose;
 
   options = options || {};
-  options.applyPluginsToDiscriminators = get(_mongoose,
-    'options.applyPluginsToDiscriminators', false);
-  options.applyPluginsToChildSchemas = get(_mongoose,
-    'options.applyPluginsToChildSchemas', true);
+  options.applyPluginsToDiscriminators = _mongoose.options && _mongoose.options.applyPluginsToDiscriminators || false;
+  options.applyPluginsToChildSchemas = typeof (_mongoose.options && _mongoose.options.applyPluginsToDiscriminators) === 'boolean' ? _mongoose.options.applyPluginsToDiscriminators : true;
   applyPlugins(schema, _mongoose.plugins, options, '$globalPluginsApplied');
 };
 
@@ -977,7 +974,7 @@ Mongoose.prototype.syncIndexes = function(options) {
 /**
  * The Mongoose Decimal128 [SchemaType](/docs/schematypes.html). Used for
  * declaring paths in your schema that should be
- * [128-bit decimal floating points](http://thecodebarbarian.com/a-nodejs-perspective-on-mongodb-34-decimal.html).
+ * [128-bit decimal floating points](https://thecodebarbarian.com/a-nodejs-perspective-on-mongodb-34-decimal.html).
  * Do not use this to create a new Decimal128 instance, use `mongoose.Types.Decimal128`
  * instead.
  *

package/lib/internal.js

@@ -29,7 +29,15 @@ InternalCache.prototype._id = undefined;
 InternalCache.prototype.ownerDocument = undefined;
 InternalCache.prototype.populate = undefined; // what we want to populate in this doc
 InternalCache.prototype.populated = undefined;// the _ids that have been populated
-InternalCache.prototype.wasPopulated = false; // if this doc was the result of a population
+
+/**
+ * If `false`, this document was not the result of population.
+ * If `true`, this document is a populated doc underneath another doc
+ * If an object, this document is a populated doc and the `value` property of the
+ * object contains the original depopulated value.
+ */
+InternalCache.prototype.wasPopulated = false;
+
 InternalCache.prototype.scope = undefined;
 
 InternalCache.prototype.session = null;