mongoose 7.3.3 → 7.4.0

package/lib/cast.js

@@ -10,12 +10,12 @@ const Types = require('./schema/index');
 const cast$expr = require('./helpers/query/cast$expr');
 const castTextSearch = require('./schema/operators/text');
 const get = require('./helpers/get');
-const getConstructorName = require('./helpers/getConstructorName');
 const getSchemaDiscriminatorByValue = require('./helpers/discriminator/getSchemaDiscriminatorByValue');
 const isOperator = require('./helpers/query/isOperator');
 const util = require('util');
 const isObject = require('./helpers/isObject');
 const isMongooseObject = require('./helpers/isMongooseObject');
+const utils = require('./utils');
 
 const ALLOWED_GEOWITHIN_GEOJSON_TYPES = ['Polygon', 'MultiPolygon'];
 
@@ -291,7 +291,7 @@ module.exports = function cast(schema, obj, options, context) {
         }
       } else if (val == null) {
         continue;
-      } else if (getConstructorName(val) === 'Object') {
+      } else if (utils.isPOJO(val)) {
         any$conditionals = Object.keys(val).some(isOperator);
 
         if (!any$conditionals) {

package/lib/connection.js

@@ -16,10 +16,7 @@ const clone = require('./helpers/clone');
 const driver = require('./driver');
 const get = require('./helpers/get');
 const immediate = require('./helpers/immediate');
-const mongodb = require('mongodb');
-const pkg = require('../package.json');
 const utils = require('./utils');
-const processConnectionOptions = require('./helpers/processConnectionOptions');
 const CreateCollectionsError = require('./error/createCollectionsError');
 
 const arrayAtomicsSymbol = require('./helpers/symbols').arrayAtomicsSymbol;
@@ -738,7 +735,7 @@ Connection.prototype.openUri = async function openUri(uri, options) {
     throw err;
   }
 
-  this.$initialConnection = _createMongoClient(this, uri, options).
+  this.$initialConnection = this.createClient(uri, options).
     then(() => this).
     catch(err => {
       this.readyState = STATES.disconnected;
@@ -795,184 +792,6 @@ function _handleConnectionErrors(err) {
   return err;
 }
 
-/*!
- * ignore
- */
-
-async function _createMongoClient(conn, uri, options) {
-  if (typeof uri !== 'string') {
-    throw new MongooseError('The `uri` parameter to `openUri()` must be a ' +
-      `string, got "${typeof uri}". Make sure the first parameter to ` +
-      '`mongoose.connect()` or `mongoose.createConnection()` is a string.');
-  }
-
-  if (conn._destroyCalled) {
-    throw new MongooseError(
-      'Connection has been closed and destroyed, and cannot be used for re-opening the connection. ' +
-      'Please create a new connection with `mongoose.createConnection()` or `mongoose.connect()`.'
-    );
-  }
-
-  if (conn.readyState === STATES.connecting || conn.readyState === STATES.connected) {
-    if (conn._connectionString !== uri) {
-      throw new MongooseError('Can\'t call `openUri()` on an active connection with ' +
-        'different connection strings. Make sure you aren\'t calling `mongoose.connect()` ' +
-        'multiple times. See: https://mongoosejs.com/docs/connections.html#multiple_connections');
-    }
-  }
-
-  options = processConnectionOptions(uri, options);
-
-  if (options) {
-
-    const autoIndex = options.config && options.config.autoIndex != null ?
-      options.config.autoIndex :
-      options.autoIndex;
-    if (autoIndex != null) {
-      conn.config.autoIndex = autoIndex !== false;
-      delete options.config;
-      delete options.autoIndex;
-    }
-
-    if ('autoCreate' in options) {
-      conn.config.autoCreate = !!options.autoCreate;
-      delete options.autoCreate;
-    }
-
-    if ('sanitizeFilter' in options) {
-      conn.config.sanitizeFilter = options.sanitizeFilter;
-      delete options.sanitizeFilter;
-    }
-
-    // Backwards compat
-    if (options.user || options.pass) {
-      options.auth = options.auth || {};
-      options.auth.username = options.user;
-      options.auth.password = options.pass;
-
-      conn.user = options.user;
-      conn.pass = options.pass;
-    }
-    delete options.user;
-    delete options.pass;
-
-    if (options.bufferCommands != null) {
-      conn.config.bufferCommands = options.bufferCommands;
-      delete options.bufferCommands;
-    }
-  } else {
-    options = {};
-  }
-
-  conn._connectionOptions = options;
-  const dbName = options.dbName;
-  if (dbName != null) {
-    conn.$dbName = dbName;
-  }
-  delete options.dbName;
-
-  if (!utils.hasUserDefinedProperty(options, 'driverInfo')) {
-    options.driverInfo = {
-      name: 'Mongoose',
-      version: pkg.version
-    };
-  }
-
-  conn.readyState = STATES.connecting;
-  conn._connectionString = uri;
-
-  let client;
-  try {
-    client = new mongodb.MongoClient(uri, options);
-  } catch (error) {
-    conn.readyState = STATES.disconnected;
-    throw error;
-  }
-  conn.client = client;
-
-  client.setMaxListeners(0);
-  await client.connect();
-
-  _setClient(conn, client, options, dbName);
-
-  for (const db of conn.otherDbs) {
-    _setClient(db, client, {}, db.name);
-  }
-  return conn;
-}
-
-/*!
- * ignore
- */
-
-function _setClient(conn, client, options, dbName) {
-  const db = dbName != null ? client.db(dbName) : client.db();
-  conn.db = db;
-  conn.client = client;
-  conn.host = client &&
-    client.s &&
-    client.s.options &&
-    client.s.options.hosts &&
-    client.s.options.hosts[0] &&
-    client.s.options.hosts[0].host || void 0;
-  conn.port = client &&
-    client.s &&
-    client.s.options &&
-    client.s.options.hosts &&
-    client.s.options.hosts[0] &&
-    client.s.options.hosts[0].port || void 0;
-  conn.name = dbName != null ? dbName : client && client.s && client.s.options && client.s.options.dbName || void 0;
-  conn._closeCalled = client._closeCalled;
-
-  const _handleReconnect = () => {
-    // If we aren't disconnected, we assume this reconnect is due to a
-    // socket timeout. If there's no activity on a socket for
-    // `socketTimeoutMS`, the driver will attempt to reconnect and emit
-    // this event.
-    if (conn.readyState !== STATES.connected) {
-      conn.readyState = STATES.connected;
-      conn.emit('reconnect');
-      conn.emit('reconnected');
-      conn.onOpen();
-    }
-  };
-
-  const type = client &&
-  client.topology &&
-  client.topology.description &&
-  client.topology.description.type || '';
-
-  if (type === 'Single') {
-    client.on('serverDescriptionChanged', ev => {
-      const newDescription = ev.newDescription;
-      if (newDescription.type === 'Unknown') {
-        conn.readyState = STATES.disconnected;
-      } else {
-        _handleReconnect();
-      }
-    });
-  } else if (type.startsWith('ReplicaSet')) {
-    client.on('topologyDescriptionChanged', ev => {
-      // Emit disconnected if we've lost connectivity to the primary
-      const description = ev.newDescription;
-      if (conn.readyState === STATES.connected && description.type !== 'ReplicaSetWithPrimary') {
-        // Implicitly emits 'disconnected'
-        conn.readyState = STATES.disconnected;
-      } else if (conn.readyState === STATES.disconnected && description.type === 'ReplicaSetWithPrimary') {
-        _handleReconnect();
-      }
-    });
-  }
-
-  conn.onOpen();
-
-  for (const i in conn.collections) {
-    if (utils.object.hasOwnProperty(conn.collections, i)) {
-      conn.collections[i].onOpen();
-    }
-  }
-}
-
 /**
  * Destroy the connection. Similar to [`.close`](https://mongoosejs.com/docs/api/connection.html#Connection.prototype.close()),
  * but also removes the connection from Mongoose's `connections` list and prevents the
@@ -1525,26 +1344,16 @@ Connection.prototype.getClient = function getClient() {
  * @return {Connection} this
  */
 
-Connection.prototype.setClient = function setClient(client) {
-  if (!(client instanceof mongodb.MongoClient)) {
-    throw new MongooseError('Must call `setClient()` with an instance of MongoClient');
-  }
-  if (this.readyState !== STATES.disconnected) {
-    throw new MongooseError('Cannot call `setClient()` on a connection that is already connected.');
-  }
-  if (client.topology == null) {
-    throw new MongooseError('Cannot call `setClient()` with a MongoClient that you have not called `connect()` on yet.');
-  }
-
-  this._connectionString = client.s.url;
-  _setClient(this, client, {}, client.s.options.dbName);
+Connection.prototype.setClient = function setClient() {
+  throw new MongooseError('Connection#setClient not implemented by driver');
+};
 
-  for (const model of Object.values(this.models)) {
-    // Errors handled internally, so safe to ignore error
-    model.init().catch(function $modelInitNoop() {});
-  }
+/*!
+ * Called internally by `openUri()` to create a MongoClient instance.
+ */
 
-  return this;
+Connection.prototype.createClient = function createClient() {
+  throw new MongooseError('Connection#createClient not implemented by driver');
 };
 
 /**
@@ -1609,6 +1418,29 @@ Connection.prototype.syncIndexes = async function syncIndexes(options = {}) {
  * @api public
  */
 
+/**
+ * Removes the database connection with the given name created with with `useDb()`.
+ *
+ * Throws an error if the database connection was not found.
+ *
+ * #### Example:
+ *
+ *     // Connect to `initialdb` first
+ *     const conn = await mongoose.createConnection('mongodb://127.0.0.1:27017/initialdb').asPromise();
+ *
+ *     // Creates an un-cached connection to `mydb`
+ *     const db = conn.useDb('mydb');
+ *
+ *     // Closes `db`, and removes `db` from `conn.relatedDbs` and `conn.otherDbs`
+ *     await conn.removeDb('mydb');
+ *
+ * @method removeDb
+ * @memberOf Connection
+ * @param {String} name The database name
+ * @return {Connection} this
+ * @api public
+ */
+
 /*!
  * Module exports.
  */

package/lib/document.js

@@ -22,7 +22,6 @@ const clone = require('./helpers/clone');
 const compile = require('./helpers/document/compile').compile;
 const defineKey = require('./helpers/document/compile').defineKey;
 const flatten = require('./helpers/common').flatten;
-const flattenObjectWithDottedPaths = require('./helpers/path/flattenObjectWithDottedPaths');
 const get = require('./helpers/get');
 const getEmbeddedDiscriminatorPath = require('./helpers/document/getEmbeddedDiscriminatorPath');
 const getKeysInSchemaOrder = require('./helpers/schema/getKeysInSchemaOrder');
@@ -473,8 +472,6 @@ function $applyDefaultsToNested(val, path, doc) {
     return;
   }
 
-  flattenObjectWithDottedPaths(val);
-
   const paths = Object.keys(doc.$__schema.paths);
   const plen = paths.length;
 
@@ -1079,9 +1076,11 @@ Document.prototype.$set = function $set(path, val, type, options) {
       return this;
     }
 
+    options = Object.assign({}, options, { _skipMinimizeTopLevel: false });
+
     for (let i = 0; i < len; ++i) {
       key = keys[i];
-      const pathName = prefix + key;
+      const pathName = prefix ? prefix + key : key;
       pathtype = this.$__schema.pathType(pathName);
       const valForKey = path[key];
 
@@ -1093,20 +1092,15 @@ Document.prototype.$set = function $set(path, val, type, options) {
           pathtype === 'nested' &&
           this._doc[key] != null) {
         delete this._doc[key];
-        // Make sure we set `{}` back even if we minimize re: gh-8565
-        options = Object.assign({}, options, { _skipMinimizeTopLevel: true });
-      } else {
-        // Make sure we set `{_skipMinimizeTopLevel: false}` if don't have overwrite: gh-10441
-        options = Object.assign({}, options, { _skipMinimizeTopLevel: false });
       }
 
       if (utils.isNonBuiltinObject(valForKey) && pathtype === 'nested') {
-        this.$set(prefix + key, path[key], constructing, Object.assign({}, options, { _skipMarkModified: true }));
-        $applyDefaultsToNested(this.$get(prefix + key), prefix + key, this);
+        this.$set(pathName, valForKey, constructing, Object.assign({}, options, { _skipMarkModified: true }));
+        $applyDefaultsToNested(this.$get(pathName), pathName, this);
         continue;
       } else if (strict) {
         // Don't overwrite defaults with undefined keys (gh-3981) (gh-9039)
-        if (constructing && path[key] === void 0 &&
+        if (constructing && valForKey === void 0 &&
             this.$get(pathName) !== void 0) {
           continue;
         }
@@ -1116,20 +1110,19 @@ Document.prototype.$set = function $set(path, val, type, options) {
         }
 
         if (pathtype === 'real' || pathtype === 'virtual') {
-          const p = path[key];
-          this.$set(prefix + key, p, constructing, options);
-        } else if (pathtype === 'nested' && path[key] instanceof Document) {
-          this.$set(prefix + key,
-            path[key].toObject({ transform: false }), constructing, options);
+          this.$set(pathName, valForKey, constructing, options);
+        } else if (pathtype === 'nested' && valForKey instanceof Document) {
+          this.$set(pathName,
+            valForKey.toObject({ transform: false }), constructing, options);
         } else if (strict === 'throw') {
           if (pathtype === 'nested') {
-            throw new ObjectExpectedError(key, path[key]);
+            throw new ObjectExpectedError(key, valForKey);
           } else {
             throw new StrictModeError(key);
           }
         }
-      } else if (path[key] !== void 0) {
-        this.$set(prefix + key, path[key], constructing, options);
+      } else if (valForKey !== void 0) {
+        this.$set(pathName, valForKey, constructing, options);
       }
     }
 
@@ -2217,16 +2210,17 @@ Document.prototype[documentModifiedPaths] = Document.prototype.modifiedPaths;
 
 Document.prototype.isModified = function(paths, modifiedPaths) {
   if (paths) {
-    if (!Array.isArray(paths)) {
-      paths = paths.indexOf(' ') === -1 ? [paths] : paths.split(' ');
-    }
-
     const directModifiedPathsObj = this.$__.activePaths.states.modify;
     if (directModifiedPathsObj == null) {
       return false;
     }
+
+    if (typeof paths === 'string') {
+      paths = [paths];
+    }
+
     for (const path of paths) {
-      if (Object.prototype.hasOwnProperty.call(directModifiedPathsObj, path)) {
+      if (directModifiedPathsObj[path] != null) {
         return true;
       }
     }
@@ -2652,14 +2646,14 @@ function _getPathsToValidate(doc, pathsToValidate, pathsToSkip) {
   const modifiedPaths = doc.modifiedPaths();
   for (const subdoc of subdocs) {
     if (subdoc.$basePath) {
-      // Remove child paths for now, because we'll be validating the whole
-      // subdoc
       const fullPathToSubdoc = subdoc.$__fullPathWithIndexes();
 
-      for (const p of paths) {
-        if (p == null || p.startsWith(fullPathToSubdoc + '.')) {
-          paths.delete(p);
-        }
+      // Remove child paths for now, because we'll be validating the whole
+      // subdoc.
+      // The following is a faster take on looping through every path in `paths`
+      // and checking if the path starts with `fullPathToSubdoc` re: gh-13191
+      for (const modifiedPath of subdoc.modifiedPaths()) {
+        paths.delete(fullPathToSubdoc + '.' + modifiedPath);
       }
 
       if (doc.$isModified(fullPathToSubdoc, modifiedPaths) &&
@@ -3336,12 +3330,13 @@ Document.prototype.$__reset = function reset() {
       if (subdoc.$isDocumentArrayElement) {
         resetArrays.add(subdoc.parentArray());
       } else {
-        if (subdoc.$parent() === this) {
+        const parent = subdoc.$parent();
+        if (parent === this) {
           this.$__.activePaths.clearPath(subdoc.$basePath);
-        } else if (subdoc.$parent() != null && subdoc.$parent().$isSubdocument) {
+        } else if (parent != null && parent.$isSubdocument) {
           // If map path underneath subdocument, may end up with a case where
           // map path is modified but parent still needs to be reset. See gh-10295
-          subdoc.$parent().$__reset();
+          parent.$__reset();
         }
       }
     }
@@ -4074,6 +4069,7 @@ function applyGetters(self, json, options) {
     path = paths[i];
 
     const parts = path.split('.');
+
     const plen = parts.length;
     const last = plen - 1;
     let branch = json;