mongoose 6.5.2 → 6.5.5

package/lib/helpers/projection/isSubpath.js

@@ -1,11 +1,12 @@
 'use strict';
 
-/*!
+/**
  * Determines if `path2` is a subpath of or equal to `path1`
  *
  * @param {string} path1
  * @param {string} path2
  * @return {Boolean}
+ * @api private
  */
 
 module.exports = function isSubpath(path1, path2) {

package/lib/helpers/query/applyQueryMiddleware.js

@@ -16,11 +16,12 @@ applyQueryMiddleware.middlewareFunctions = validOps.concat([
   'validate'
 ]);
 
-/*!
+/**
  * Apply query middleware
  *
- * @param {Query} query constructor
+ * @param {Query} Query constructor
  * @param {Model} model
+ * @api private
  */
 
 function applyQueryMiddleware(Query, model) {

package/lib/helpers/query/castUpdate.js

@@ -14,16 +14,17 @@ const schemaMixedSymbol = require('../../schema/symbols').schemaMixedSymbol;
 const setDottedPath = require('../path/setDottedPath');
 const utils = require('../../utils');
 
-/*!
+/**
  * Casts an update op based on the given schema
  *
  * @param {Schema} schema
  * @param {Object} obj
- * @param {Object} options
+ * @param {Object} [options]
  * @param {Boolean} [options.overwrite] defaults to false
  * @param {Boolean|String} [options.strict] defaults to true
  * @param {Query} context passed to setters
  * @return {Boolean} true iff the update is non-empty
+ * @api private
  */
 module.exports = function castUpdate(schema, obj, options, context, filter) {
   if (obj == null) {
@@ -150,16 +151,17 @@ function castPipelineOperator(op, val) {
   throw new MongooseError('Invalid update pipeline operator: "' + op + '"');
 }
 
-/*!
+/**
  * Walk each path of obj and cast its values
  * according to its schema.
  *
  * @param {Schema} schema
  * @param {Object} obj part of a query
  * @param {String} op the atomic operator ($pull, $set, etc)
- * @param {Object} options
+ * @param {Object} [options]
  * @param {Boolean|String} [options.strict]
  * @param {Query} context
+ * @param {Object} filter
  * @param {String} pref path prefix (internal only)
  * @return {Bool} true if this path has keys to update
  * @api private
@@ -407,9 +409,10 @@ function _appendError(error, query, key, aggregatedError) {
   return aggregatedError;
 }
 
-/*!
+/**
  * These operators should be cast to numbers instead
  * of their path schema type.
+ * @api private
  */
 
 const numberOps = {
@@ -417,17 +420,19 @@ const numberOps = {
   $inc: 1
 };
 
-/*!
+/**
  * These ops require no casting because the RHS doesn't do anything.
+ * @api private
  */
 
 const noCastOps = {
   $unset: 1
 };
 
-/*!
+/**
  * These operators require casting docs
  * to real Documents for Update operations.
+ * @api private
  */
 
 const castOps = {
@@ -446,7 +451,7 @@ const overwriteOps = {
   $setOnInsert: 1
 };
 
-/*!
+/**
  * Casts `val` according to `schema` and atomic `op`.
  *
  * @param {SchemaType} schema
@@ -454,6 +459,7 @@ const overwriteOps = {
  * @param {String} op the atomic operator ($pull, $set, etc)
  * @param {String} $conditional
  * @param {Query} context
+ * @param {String} path
  * @api private
  */
 

package/lib/helpers/query/completeMany.js

@@ -5,7 +5,7 @@ const immediate = require('../immediate');
 
 module.exports = completeMany;
 
-/*!
+/**
  * Given a model and an array of docs, hydrates all the docs to be instances
  * of the model. Used to initialize docs returned from the db from `find()`
  *
@@ -13,10 +13,11 @@ module.exports = completeMany;
  * @param {Array} docs
  * @param {Object} fields the projection used, including `select` from schemas
  * @param {Object} userProvidedFields the user-specified projection
- * @param {Object} opts
+ * @param {Object} [opts]
  * @param {Array} [opts.populated]
  * @param {ClientSession} [opts.session]
  * @param {Function} callback
+ * @api private
  */
 
 function completeMany(model, docs, fields, userProvidedFields, opts, callback) {

package/lib/helpers/query/getEmbeddedDiscriminatorPath.js

@@ -5,9 +5,15 @@ const get = require('../get');
 const getDiscriminatorByValue = require('../discriminator/getDiscriminatorByValue');
 const updatedPathsByArrayFilter = require('../update/updatedPathsByArrayFilter');
 
-/*!
+/**
  * Like `schema.path()`, except with a document, because impossible to
  * determine path type without knowing the embedded discriminator key.
+ * @param {Schema} schema
+ * @param {Object} [update]
+ * @param {Object} [filter]
+ * @param {String} path
+ * @param {Object} [options]
+ * @api private
  */
 
 module.exports = function getEmbeddedDiscriminatorPath(schema, update, filter, path, options) {

package/lib/helpers/query/wrapThunk.js

@@ -2,13 +2,15 @@
 
 const MongooseError = require('../../error/mongooseError');
 
-/*!
+/**
  * A query thunk is the function responsible for sending the query to MongoDB,
  * like `Query#_findOne()` or `Query#_execUpdate()`. The `Query#exec()` function
  * calls a thunk. The term "thunk" here is the traditional Node.js definition:
  * a function that takes exactly 1 parameter, a callback.
  *
  * This function defines common behavior for all query thunks.
+ * @param {Function} fn
+ * @api private
  */
 
 module.exports = function wrapThunk(fn) {

package/lib/helpers/schema/getIndexes.js

@@ -4,9 +4,11 @@ const get = require('../get');
 const helperIsObject = require('../isObject');
 const decorateDiscriminatorIndexOptions = require('../indexes/decorateDiscriminatorIndexOptions');
 
-/*!
+/**
  * Gather all indexes defined in the schema, including single nested,
  * document arrays, and embedded discriminators.
+ * @param {Schema} schema
+ * @api private
  */
 
 module.exports = function getIndexes(schema) {
@@ -120,11 +122,14 @@ module.exports = function getIndexes(schema) {
     }
   }
 
-  /*!
+  /**
    * Checks for indexes added to subdocs using Schema.index().
    * These indexes need their paths prefixed properly.
    *
    * schema._indexes = [ [indexObj, options], [indexObj, options] ..]
+   * @param {Schema} schema
+   * @param {String} prefix
+   * @api private
    */
 
   function fixSubIndexPaths(schema, prefix) {

package/lib/helpers/schema/getPath.js

@@ -1,12 +1,13 @@
 'use strict';
 
-/*!
+const numberRE = /^\d+$/;
+
+/**
  * Behaves like `Schema#path()`, except for it also digs into arrays without
  * needing to put `.0.`, so `getPath(schema, 'docArr.elProp')` works.
+ * @api private
  */
 
-const numberRE = /^\d+$/;
-
 module.exports = function getPath(schema, path) {
   let schematype = schema.path(path);
   if (schematype != null) {

package/lib/helpers/schema/idGetter.js

@@ -18,8 +18,9 @@ module.exports = function addIdGetter(schema) {
   return schema;
 };
 
-/*!
+/**
  * Returns this documents _id cast to a string.
+ * @api private
  */
 
 function idGetter() {

package/lib/helpers/setDefaultsOnInsert.js

@@ -105,6 +105,8 @@ function isModified(modified, path) {
   if (modified[path]) {
     return true;
   }
+
+  // Is any parent path of `path` modified?
   const sp = path.split('.');
   let cur = sp[0];
   for (let i = 1; i < sp.length; ++i) {
@@ -113,5 +115,18 @@ function isModified(modified, path) {
     }
     cur += '.' + sp[i];
   }
+
+  // Is any child of `path` modified?
+  const modifiedKeys = Object.keys(modified);
+  if (modifiedKeys.length) {
+    const parentPath = path + '.';
+
+    for (const modifiedPath of modifiedKeys) {
+      if (modifiedPath.slice(0, path.length + 1) === parentPath) {
+        return true;
+      }
+    }
+  }
+
   return false;
 }

package/lib/index.js

@@ -293,20 +293,20 @@ Mongoose.prototype.get = Mongoose.prototype.set;
  *     db = mongoose.createConnection();
  *     db.openUri('localhost', 'database', port, [opts]);
  *
- * @param {String} [uri] a mongodb:// URI
- * @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 {String} uri mongodb URI to connect to
+ * @param {Object} [options] passed down to the [MongoDB driver's `connect()` function](https://mongodb.github.io/node-mongodb-native/4.9/interfaces/MongoClientOptions.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 {Class} [options.promiseLibrary] Sets the [underlying driver's promise library](https://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/4.9/interfaces/MongoClientOptions.html#promiseLibrary).
  * @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.
- * @return {Connection} the created Connection object. Connections are not thenable, so you can't do `await mongoose.createConnection()`. To await use mongoose.createConnection(uri).asPromise() instead.
+ * @return {Connection} the created Connection object. Connections are not thenable, so you can't do `await mongoose.createConnection()`. To await use `mongoose.createConnection(uri).asPromise()` instead.
  * @api public
  */
 
@@ -349,8 +349,8 @@ Mongoose.prototype.createConnection = function(uri, options, callback) {
  *       // if error is truthy, the initial connection failed.
  *     })
  *
- * @param {String} uri(s)
- * @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 {String} uri mongodb URI to connect to
+ * @param {Object} [options] passed down to the [MongoDB driver's `connect()` function](https://mongodb.github.io/node-mongodb-native/4.9/interfaces/MongoClientOptions.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.
@@ -361,13 +361,13 @@ Mongoose.prototype.createConnection = function(uri, options, callback) {
  * @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 {Class} [options.promiseLibrary] Sets the [underlying driver's promise library](https://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/4.9/interfaces/MongoClientOptions.html#promiseLibrary).
  * @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.
  * @param {Boolean} [options.autoCreate=false] Set to `true` to make Mongoose automatically call `createCollection()` on every model created on this connection.
  * @param {Function} [callback]
- * @see Mongoose#createConnection #index_Mongoose-createConnection
+ * @see Mongoose#createConnection /docs/api.html#mongoose_Mongoose-createConnection
  * @api public
  * @return {Promise} resolves to `this` if connection succeeded
  */
@@ -424,7 +424,7 @@ Mongoose.prototype.disconnect = function(callback) {
  * 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](https://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/4.9/classes/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`
@@ -514,6 +514,14 @@ Mongoose.prototype.model = function(name, schema, collection, options) {
     schema = false;
   }
 
+  if (arguments.length === 1) {
+    const model = _mongoose.models[name];
+    if (!model) {
+      throw new MongooseError.MissingSchemaError(name);
+    }
+    return model;
+  }
+
   if (utils.isObject(schema) && !(schema instanceof Schema)) {
     schema = new Schema(schema);
   }
@@ -862,7 +870,7 @@ Mongoose.prototype.SchemaType = SchemaType;
  * _Alias of mongoose.Schema.Types for backwards compatibility._
  *
  * @property SchemaTypes
- * @see Schema.SchemaTypes #schema_Schema-Types
+ * @see Schema.SchemaTypes /docs/schematypes
  * @api public
  */
 
@@ -1262,10 +1270,10 @@ Mongoose.prototype.skipMiddlewareFunction = Kareem.skipWrappedFunction;
 
 Mongoose.prototype.overwriteMiddlewareResult = Kareem.overwriteResult;
 
-/*!
+/**
  * The exports object is an instance of Mongoose.
  *
- * @api public
+ * @api private
  */
 
 const mongoose = module.exports = exports = new Mongoose({