@nullix/zod-mongoose-studio 1.0.13 → 2.1.0

package/.output/server/node_modules/mongoose/lib/connection.js

@@ -132,7 +132,7 @@ Object.defineProperty(Connection.prototype, 'readyState', {
   },
   set: function(val) {
     if (!(val in STATES)) {
-      throw new Error('Invalid connection state: ' + val);
+      throw new MongooseError('Invalid connection state: ' + val);
     }
 
     if (this._readyState !== val) {
@@ -158,7 +158,7 @@ Object.defineProperty(Connection.prototype, 'readyState', {
  *
  *     conn.get('test'); // returns the 'test' value
  *
- * @param {String} key
+ * @param {string} key
  * @method get
  * @api public
  */
@@ -177,7 +177,7 @@ Connection.prototype.get = function getOption(key) {
  * Supported options include:
  *
  * - `maxTimeMS`: Set [`maxTimeMS`](https://mongoosejs.com/docs/api/query.html#Query.prototype.maxTimeMS()) for all queries on this connection.
- * - 'debug': If `true`, prints the operations mongoose sends to MongoDB to the console. If a writable stream is passed, it will log to that stream, without colorization. If a callback function is passed, it will receive the collection name, the method name, then all arugments passed to the method. For example, if you wanted to replicate the default logging, you could output from the callback `Mongoose: ${collectionName}.${methodName}(${methodArgs.join(', ')})`.
+ * - 'debug': If `true`, prints the operations mongoose sends to MongoDB to the console. If a writable stream is passed, it will log to that stream, without colorization. If a callback function is passed, it will receive the collection name, the method name, then all arguments passed to the method. For example, if you wanted to replicate the default logging, you could output from the callback `Mongoose: ${collectionName}.${methodName}(${methodArgs.join(', ')})`.
  *
  * #### Example:
  *
@@ -185,8 +185,8 @@ Connection.prototype.get = function getOption(key) {
  *     conn.get('test'); // 'foo'
  *     conn.options.test; // 'foo'
  *
- * @param {String} key
- * @param {Any} val
+ * @param {string} key
+ * @param {any} val
  * @method set
  * @api public
  */
@@ -410,11 +410,11 @@ Connection.prototype.config;
  * with specified options. Used to create [capped collections](https://www.mongodb.com/docs/manual/core/capped-collections/)
  * and [views](https://www.mongodb.com/docs/manual/core/views/) from mongoose.
  *
- * Options are passed down without modification to the [MongoDB driver's `createCollection()` function](https://mongodb.github.io/node-mongodb-native/4.9/classes/Db.html#createCollection)
+ * Options are passed down without modification to the [MongoDB driver's `createCollection()` function](https://mongodb.github.io/node-mongodb-native/7.0/classes/Db.html#createCollection)
  *
  * @method createCollection
  * @param {string} collection The collection to create
- * @param {Object} [options] see [MongoDB driver docs](https://mongodb.github.io/node-mongodb-native/4.9/classes/Db.html#createCollection)
+ * @param {object} [options] see [MongoDB driver docs](https://mongodb.github.io/node-mongodb-native/7.0/classes/Db.html#createCollection)
  * @return {Promise}
  * @api public
  */
@@ -444,8 +444,8 @@ Connection.prototype.createCollection = async function createCollection(collecti
  *
  * @method bulkWrite
  * @param {Array} ops
- * @param {Object} [options]
- * @param {Boolean} [options.ordered] If false, perform unordered operations. If true, perform ordered operations.
+ * @param {object} [options]
+ * @param {boolean} [options.ordered] If false, perform unordered operations. If true, perform ordered operations.
  * @param {Session} [options.session] The session to use for the operation.
  * @return {Promise}
  * @see MongoDB https://www.mongodb.com/docs/manual/reference/command/bulkWrite/#mongodb-dbcommand-dbcmd.bulkWrite
@@ -606,7 +606,7 @@ Connection.prototype.bulkWrite = async function bulkWrite(ops, options) {
  * Calls `createCollection()` on a models in a series.
  *
  * @method createCollections
- * @param {Boolean} continueOnError When true, will continue to create collections and create a new error class for the collections that errored.
+ * @param {boolean} continueOnError When true, will continue to create collections and create a new error class for the collections that errored.
  * @returns {Promise}
  * @api public
  */
@@ -630,7 +630,7 @@ Connection.prototype.createCollections = async function createCollections(option
     }
   }
 
-  if (!continueOnError && Object.keys(errorsMap).length) {
+  if (!continueOnError && utils.hasOwnKeys(errorsMap)) {
     const message = Object.entries(errorsMap).map(([modelName, err]) => `${modelName}: ${err.message}`).join(', ');
     const createCollectionsError = new CreateCollectionsError(message, errorsMap);
     throw createCollectionsError;
@@ -655,7 +655,7 @@ Connection.prototype.createCollections = async function createCollections(option
 
 Connection.prototype.withSession = async function withSession(executor) {
   if (arguments.length === 0) {
-    throw new Error('Please provide an executor function');
+    throw new MongooseError('Please provide an executor function');
   }
   return await this.client.withSession(executor);
 };
@@ -678,8 +678,8 @@ Connection.prototype.withSession = async function withSession(executor) {
  *
  *
  * @method 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 {object} [options] see the [mongodb driver options](https://mongodb.github.io/node-mongodb-native/7.0/classes/MongoClient.html#startSession)
+ * @param {boolean} [options.causalConsistency=true] set to false to disable causal consistency
  * @return {Promise<ClientSession>} promise that resolves to a MongoDB driver `ClientSession`
  * @api public
  */
@@ -701,7 +701,7 @@ Connection.prototype.startSession = async function startSession(options) {
  * async function executes successfully and attempt to retry if
  * there was a retriable error.
  *
- * Calls the MongoDB driver's [`session.withTransaction()`](https://mongodb.github.io/node-mongodb-native/4.9/classes/ClientSession.html#withTransaction),
+ * Calls the MongoDB driver's [`session.withTransaction()`](https://mongodb.github.io/node-mongodb-native/7.0/classes/ClientSession.html#withTransaction),
  * but also handles resetting Mongoose document state as shown below.
  *
  * #### Example:
@@ -713,7 +713,7 @@ Connection.prototype.startSession = async function startSession(options) {
  *       doc.isNew; // false
  *
  *       // Throw an error to abort the transaction
- *       throw new Error('Oops!');
+ *       throw new MongooseError('Oops!');
  *     },{ readPreference: 'primary' }).catch(() => {});
  *
  *     // true, `transaction()` reset the document's state because the
@@ -723,7 +723,7 @@ Connection.prototype.startSession = async function startSession(options) {
  * @method transaction
  * @param {Function} fn Function to execute in a transaction
  * @param {mongodb.TransactionOptions} [options] Optional settings for the transaction
- * @return {Promise<Any>} promise that is fulfilled if Mongoose successfully committed the transaction, or rejects if the transaction was aborted or if Mongoose failed to commit the transaction. If fulfilled, the promise resolves to a MongoDB command result.
+ * @return {Promise<any>} promise that is fulfilled if Mongoose successfully committed the transaction, or rejects if the transaction was aborted or if Mongoose failed to commit the transaction. If fulfilled, the promise resolves to a MongoDB command result.
  * @api public
  */
 
@@ -824,8 +824,8 @@ Connection.prototype.dropCollection = async function dropCollection(collection)
 /**
  * Waits for connection to be established, so the connection has a `client`
  *
- * @param {Boolean} [noTimeout=false] if set, don't put a timeout on the operation. Used internally so `mongoose.model()` doesn't leave open handles.
- * @return Promise
+ * @param {boolean} [noTimeout=false] if set, don't put a timeout on the operation. Used internally so `mongoose.model()` doesn't leave open handles.
+ * @return {Promise}
  * @api private
  */
 
@@ -883,7 +883,7 @@ Connection.prototype._getBufferTimeoutMS = function _getBufferTimeoutMS() {
   if (this.config.bufferTimeoutMS != null) {
     return this.config.bufferTimeoutMS;
   }
-  if (this.base != null && this.base.get('bufferTimeoutMS') != null) {
+  if (this.base?.get('bufferTimeoutMS') != null) {
     return this.base.get('bufferTimeoutMS');
   }
   return 10000;
@@ -894,7 +894,7 @@ Connection.prototype._getBufferTimeoutMS = function _getBufferTimeoutMS() {
  * Returns an array of collection objects.
  *
  * @method listCollections
- * @return {Promise<Collection[]>}
+ * @return {Promise<Array<Collection>>}
  * @api public
  */
 
@@ -915,7 +915,7 @@ Connection.prototype.listCollections = async function listCollections() {
  *     databases; // [{ name: 'mongoose_test', sizeOnDisk: 0, empty: false }]
  *
  * @method listCollections
- * @return {Promise<{ databases: Array<{ name: string }> }>}
+ * @return {Promise<Array<{ databases: { name: string } }>>}
  * @api public
  */
 
@@ -1005,10 +1005,7 @@ Connection.prototype.error = function error(err, callback) {
 Connection.prototype.onOpen = function() {
   this.readyState = STATES.connected;
 
-  for (const d of this._queue) {
-    d.fn.apply(d.ctx, d.args);
-  }
-  this._queue = [];
+  this._flushQueue();
 
   // avoid having the collection subscribe to our event emitter
   // to prevent 0.3 warning
@@ -1021,25 +1018,39 @@ Connection.prototype.onOpen = function() {
   this.emit('open');
 };
 
+/**
+ * Flush all buffered operations in `_queue`. Called by `onOpen()` and
+ * by the heartbeat handler when a previously-stale connection recovers.
+ *
+ * @api private
+ */
+
+Connection.prototype._flushQueue = function _flushQueue() {
+  const queue = this._queue;
+  this._queue = [];
+  for (const d of queue) {
+    d.fn.apply(d.ctx, d.args);
+  }
+};
+
 /**
  * Opens the connection with a URI using `MongoClient.connect()`.
  *
- * @param {String} uri The URI to connect with.
- * @param {Object} [options] Passed on to [`MongoClient.connect`](https://mongodb.github.io/node-mongodb-native/4.9/classes/MongoClient.html#connect-1)
- * @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.username`. 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](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. 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.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/4.9/interfaces/MongoClientOptions.html#promiseLibrary).
- * @param {Number} [options.socketTimeoutMS=0] 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. `socketTimeoutMS` defaults to 0, which means Node.js will not time out the socket due to inactivity. 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 {string} uri The URI to connect with.
+ * @param {object} [options] Passed on to [`MongoClient.connect`](https://mongodb.github.io/node-mongodb-native/7.0/classes/MongoClient.html#connect)
+ * @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.username`. 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](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. 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.serverSelectionTimeoutMS] 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] 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.socketTimeoutMS=0] 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. `socketTimeoutMS` defaults to 0, which means Node.js will not time out the socket due to inactivity. 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.
  * @returns {Promise<Connection>}
  * @api public
  */
@@ -1106,7 +1117,7 @@ Connection.prototype.openUri = async function openUri(uri, options) {
 /**
  * Listen to events in the Connection
  *
- * @param {String} event The event to listen on
+ * @param {string} event The event to listen on
  * @param {Function} callback
  * @see Connection#readyState https://mongoosejs.com/docs/api/connection.html#Connection.prototype.readyState
  *
@@ -1128,7 +1139,7 @@ Connection.prototype.on = function on(event, callback) {
 /**
  * Listen to a event once in the Connection
  *
- * @param {String} event The event to listen on
+ * @param {string} event The event to listen on
  * @param {Function} callback
  * @see Connection#readyState https://mongoosejs.com/docs/api/connection.html#Connection.prototype.readyState
  *
@@ -1178,7 +1189,7 @@ function _handleConnectionErrors(err) {
  * but also removes the connection from Mongoose's `connections` list and prevents the
  * connection from ever being re-opened.
  *
- * @param {Boolean} [force]
+ * @param {boolean} [force]
  * @returns {Promise}
  */
 
@@ -1199,7 +1210,7 @@ Connection.prototype.destroy = async function destroy(force) {
 /**
  * Closes the connection
  *
- * @param {Boolean} [force] optional
+ * @param {boolean} [force] optional
  * @return {Promise}
  * @api public
  */
@@ -1232,8 +1243,8 @@ Connection.prototype.close = async function close(force) {
 /**
  * Handles closing the connection
  *
- * @param {Boolean} force
- * @param {Boolean} destroy
+ * @param {boolean} force
+ * @param {boolean} destroy
  * @returns {Connection} this
  * @api private
  */
@@ -1250,8 +1261,11 @@ Connection.prototype._close = async function _close(force, destroy) {
   const conn = this;
   switch (this.readyState) {
     case STATES.disconnected:
-      if (destroy && this.base.connections.indexOf(conn) !== -1) {
-        this.base.connections.splice(this.base.connections.indexOf(conn), 1);
+      if (destroy) {
+        const index = this.base.connections.indexOf(conn);
+        if (index !== -1) {
+          this.base.connections.splice(index, 1);
+        }
       }
       if (!closeCalled) {
         await this.doClose(force);
@@ -1262,8 +1276,11 @@ Connection.prototype._close = async function _close(force, destroy) {
     case STATES.connected:
       this.readyState = STATES.disconnecting;
       await this.doClose(force);
-      if (destroy && _this.base.connections.indexOf(conn) !== -1) {
-        this.base.connections.splice(this.base.connections.indexOf(conn), 1);
+      if (destroy) {
+        const index = _this.base.connections.indexOf(conn);
+        if (index !== -1) {
+          this.base.connections.splice(index, 1);
+        }
       }
       this.onClose(force);
 
@@ -1305,7 +1322,7 @@ Connection.prototype._close = async function _close(force, destroy) {
  */
 
 Connection.prototype.doClose = function doClose() {
-  throw new Error('Connection#doClose unimplemented by driver');
+  throw new MongooseError('Connection#doClose unimplemented by driver');
 };
 
 /**
@@ -1341,21 +1358,21 @@ Connection.prototype.onClose = function onClose(force) {
  * Using a Collection bypasses Mongoose middleware, validation, and casting,
  * letting you use [MongoDB Node.js driver](https://mongodb.github.io/node-mongodb-native/) functionality directly.
  *
- * @param {String} name of the collection
- * @param {Object} [options] optional collection options
+ * @param {string} name of the collection
+ * @param {object} [options] optional collection options
  * @return {Collection} collection instance
  * @api public
  */
 
 Connection.prototype.collection = function(name, options) {
   const defaultOptions = {
-    autoIndex: this.config.autoIndex != null ? this.config.autoIndex : this.base.options.autoIndex,
-    autoCreate: this.config.autoCreate != null ? this.config.autoCreate : this.base.options.autoCreate,
-    autoSearchIndex: this.config.autoSearchIndex != null ? this.config.autoSearchIndex : this.base.options.autoSearchIndex
+    autoIndex: this.config.autoIndex ?? this.base.options.autoIndex,
+    autoCreate: this.config.autoCreate ?? this.base.options.autoCreate,
+    autoSearchIndex: this.config.autoSearchIndex ?? this.base.options.autoSearchIndex
   };
   options = Object.assign({}, defaultOptions, options ? clone(options) : {});
   options.$wasForceClosed = this.$wasForceClosed;
-  const Collection = this.base && this.base.__driver && this.base.__driver.Collection || driver.get().Collection;
+  const Collection = this.base?.__driver?.Collection || driver.get().Collection;
   if (!(name in this.collections)) {
     this.collections[name] = new Collection(name, this, options);
   }
@@ -1376,7 +1393,7 @@ Connection.prototype.collection = function(name, options) {
  *     db.model('Test', new Schema({})); // Prints "Applied"
  *
  * @param {Function} fn plugin callback
- * @param {Object} [opts] optional options
+ * @param {object} [opts] optional options
  * @return {Connection} this
  * @see plugins https://mongoosejs.com/docs/plugins.html
  * @api public
@@ -1411,11 +1428,11 @@ Connection.prototype.plugin = function(fn, opts) {
  *     const collectionName = 'actor'
  *     const M = conn.model('Actor', schema, collectionName)
  *
- * @param {String|Function} name the model name or class extending Model
+ * @param {string|Function} name the model name or class extending Model
  * @param {Schema} [schema] a schema. necessary when defining a model
- * @param {String} [collection] name of mongodb collection (optional) if not given it will be induced from model name
- * @param {Object} [options]
- * @param {Boolean} [options.overwriteModels=false] If true, overwrite existing models with the same name to avoid `OverwriteModelError`
+ * @param {string} [collection] name of mongodb collection (optional) if not given it will be induced from model name
+ * @param {object} [options]
+ * @param {boolean} [options.overwriteModels=false] If true, overwrite existing models with the same name to avoid `OverwriteModelError`
  * @see Mongoose#model https://mongoosejs.com/docs/api/mongoose.html#Mongoose.prototype.model()
  * @return {Model} The compiled model
  * @api public
@@ -1448,7 +1465,7 @@ Connection.prototype.model = function model(name, schema, collection, options) {
     }
   }
   if (schema && !schema.instanceOfSchema) {
-    throw new Error('The 2nd parameter to `mongoose.model()` should be a ' +
+    throw new MongooseError('The 2nd parameter to `mongoose.model()` should be a ' +
       'schema or a POJO');
   }
 
@@ -1456,7 +1473,7 @@ Connection.prototype.model = function model(name, schema, collection, options) {
   const opts = Object.assign(defaultOptions, options, { connection: this });
   if (this.models[name] && !collection && opts.overwriteModels !== true) {
     // model exists but we are not subclassing with custom collection
-    if (schema && schema.instanceOfSchema && schema !== this.models[name].schema) {
+    if (schema?.instanceOfSchema && schema !== this.models[name].schema) {
       throw new MongooseError.OverwriteModelError(name);
     }
     return this.models[name];
@@ -1464,7 +1481,7 @@ Connection.prototype.model = function model(name, schema, collection, options) {
 
   let model;
 
-  if (schema && schema.instanceOfSchema) {
+  if (schema?.instanceOfSchema) {
     applyPlugins(schema, this.plugins, null, '$connectionPluginsApplied');
 
     // compile a model
@@ -1537,7 +1554,7 @@ Connection.prototype.model = function model(name, schema, collection, options) {
  *     });
  *
  * @api public
- * @param {String|RegExp} name if string, the name of the model to remove. If regexp, removes all models whose name matches the regexp.
+ * @param {string|RegExp} name if string, the name of the model to remove. If regexp, removes all models whose name matches the regexp.
  * @return {Connection} this
  */
 
@@ -1561,7 +1578,7 @@ Connection.prototype.deleteModel = function deleteModel(name) {
       }
     }
   } else {
-    throw new Error('First parameter to `deleteModel()` must be a string ' +
+    throw new MongooseError('First parameter to `deleteModel()` must be a string ' +
       'or regexp, got "' + name + '"');
   }
 
@@ -1593,27 +1610,14 @@ Connection.prototype.deleteModel = function deleteModel(name) {
  *
  * @api public
  * @param {Array} [pipeline]
- * @param {Object} [options] passed without changes to [the MongoDB driver's `Db#watch()` function](https://mongodb.github.io/node-mongodb-native/4.9/classes/Db.html#watch)
+ * @param {object} [options] passed without changes to [the MongoDB driver's `Db#watch()` function](https://mongodb.github.io/node-mongodb-native/7.0/classes/Db.html#watch)
  * @return {ChangeStream} mongoose-specific change stream wrapper, inherits from EventEmitter
  */
 
 Connection.prototype.watch = function watch(pipeline, options) {
-  const changeStreamThunk = cb => {
-    immediate(() => {
-      if (this.readyState === STATES.connecting) {
-        this.once('open', function() {
-          const driverChangeStream = this.db.watch(pipeline, options);
-          cb(null, driverChangeStream);
-        });
-      } else {
-        const driverChangeStream = this.db.watch(pipeline, options);
-        cb(null, driverChangeStream);
-      }
-    });
-  };
+  const changeStreamPromise = this._waitForConnect().then(() => this.db.watch(pipeline, options));
 
-  const changeStream = new ChangeStream(changeStreamThunk, pipeline, options);
-  return changeStream;
+  return new ChangeStream(changeStreamPromise, pipeline, options);
 };
 
 /**
@@ -1643,7 +1647,7 @@ Connection.prototype.asPromise = async function asPromise() {
 /**
  * Returns an array of model names created on this connection.
  * @api public
- * @return {String[]}
+ * @return {Array<string>}
  */
 
 Connection.prototype.modelNames = function modelNames() {
@@ -1656,7 +1660,7 @@ Connection.prototype.modelNames = function modelNames() {
  * password is not required.
  *
  * @api private
- * @return {Boolean} true if the connection should be authenticated after it is opened, otherwise false.
+ * @return {boolean} true if the connection should be authenticated after it is opened, otherwise false.
  */
 Connection.prototype.shouldAuthenticate = function shouldAuthenticate() {
   return this.user != null &&
@@ -1668,11 +1672,11 @@ Connection.prototype.shouldAuthenticate = function shouldAuthenticate() {
  * password to authenticate according to the auth objects passed into the openUri methods.
  *
  * @api private
- * @return {Boolean} true if the authentication mechanism specified in the options object requires
+ * @return {boolean} true if the authentication mechanism specified in the options object requires
  *  a password, otherwise false.
  */
 Connection.prototype.authMechanismDoesNotRequirePassword = function authMechanismDoesNotRequirePassword() {
-  if (this.options && this.options.auth) {
+  if (this.options?.auth) {
     return noPasswordAuthMechanisms.indexOf(this.options.auth.authMechanism) >= 0;
   }
   return true;
@@ -1684,9 +1688,9 @@ Connection.prototype.authMechanismDoesNotRequirePassword = function authMechanis
  * but in some authentication methods, a password is not required for authentication so only a username
  * is required.
  *
- * @param {Object} [options] the options object passed into the openUri methods.
+ * @param {object} [options] the options object passed into the openUri methods.
  * @api private
- * @return {Boolean} true if the provided options object provides enough data to authenticate with,
+ * @return {boolean} true if the provided options object provides enough data to authenticate with,
  *   otherwise false.
  */
 Connection.prototype.optionsProvideAuthenticationData = function optionsProvideAuthenticationData(options) {
@@ -1696,7 +1700,7 @@ Connection.prototype.optionsProvideAuthenticationData = function optionsProvideA
 };
 
 /**
- * Returns the [MongoDB driver `MongoClient`](https://mongodb.github.io/node-mongodb-native/4.9/classes/MongoClient.html) instance
+ * Returns the [MongoDB driver `MongoClient`](https://mongodb.github.io/node-mongodb-native/7.0/classes/MongoClient.html) instance
  * that this connection uses to talk to MongoDB.
  *
  * #### Example:
@@ -1715,7 +1719,7 @@ Connection.prototype.getClient = function getClient() {
 };
 
 /**
- * Set the [MongoDB driver `MongoClient`](https://mongodb.github.io/node-mongodb-native/4.9/classes/MongoClient.html) instance
+ * Set the [MongoDB driver `MongoClient`](https://mongodb.github.io/node-mongodb-native/7.0/classes/MongoClient.html) instance
  * that this connection uses to talk to MongoDB. This is useful if you already have a MongoClient instance, and want to
  * reuse it.
  *
@@ -1748,9 +1752,9 @@ Connection.prototype.createClient = function createClient() {
 /**
  * Syncs all the indexes for the models registered with this connection.
  *
- * @param {Object} [options]
- * @param {Boolean} [options.continueOnError] `false` by default. If set to `true`, mongoose will not throw an error if one model syncing failed, and will return an object where the keys are the names of the models, and the values are the results/errors for each model.
- * @return {Promise<Object>} Returns a Promise, when the Promise resolves the value is a list of the dropped indexes.
+ * @param {object} [options]
+ * @param {boolean} [options.continueOnError] `false` by default. If set to `true`, mongoose will not throw an error if one model syncing failed, and will return an object where the keys are the names of the models, and the values are the results/errors for each model.
+ * @return {Promise<object>} Returns a Promise, when the Promise resolves the value is a list of the dropped indexes.
  */
 Connection.prototype.syncIndexes = async function syncIndexes(options = {}) {
   const result = {};
@@ -1772,7 +1776,7 @@ Connection.prototype.syncIndexes = async function syncIndexes(options = {}) {
     }
   }
 
-  if (!continueOnError && Object.keys(errorsMap).length) {
+  if (!continueOnError && utils.hasOwnKeys(errorsMap)) {
     const message = Object.entries(errorsMap).map(([modelName, err]) => `${modelName}: ${err.message}`).join(', ');
     const syncIndexesError = new SyncIndexesError(message, errorsMap);
     throw syncIndexesError;
@@ -1782,7 +1786,7 @@ Connection.prototype.syncIndexes = async function syncIndexes(options = {}) {
 };
 
 /**
- * Switches to a different database using the same [connection pool](https://mongoosejs.com/docs/api/connectionshtml#connection_pools).
+ * Switches to a different database using the same [connection pool](https://mongoosejs.com/docs/connections.html#connection_pools).
  *
  * Returns a new connection object, with the new db.
  *
@@ -1799,10 +1803,9 @@ Connection.prototype.syncIndexes = async function syncIndexes(options = {}) {
  *
  * @method useDb
  * @memberOf Connection
- * @param {String} name The database name
- * @param {Object} [options]
- * @param {Boolean} [options.useCache=false] If true, cache results so calling `useDb()` multiple times with the same name only creates 1 connection object.
- * @param {Boolean} [options.noListener=false] If true, the connection object will not make the db listen to events on the original connection. See [issue #9961](https://github.com/Automattic/mongoose/issues/9961).
+ * @param {string} name The database name
+ * @param {object} [options]
+ * @param {boolean} [options.useCache=false] If true, cache results so calling `useDb()` multiple times with the same name only creates 1 connection object.
  * @return {Connection} New Connection Object
  * @api public
  */
@@ -1813,8 +1816,8 @@ Connection.prototype.syncIndexes = async function syncIndexes(options = {}) {
  * @method aggregate
  * @memberOf Connection
  * @param {Array} pipeline
- * @param {Object} [options]
- * @param {Boolean} [options.cursor=false] If true, make the Aggregate resolve to a Mongoose AggregationCursor rather than an array
+ * @param {object} [options]
+ * @param {boolean} [options.cursor=false] If true, make the Aggregate resolve to a Mongoose AggregationCursor rather than an array
  * @return {Aggregate} Aggregation wrapper
  * @api public
  */
@@ -1837,7 +1840,7 @@ Connection.prototype.syncIndexes = async function syncIndexes(options = {}) {
  *
  * @method removeDb
  * @memberOf Connection
- * @param {String} name The database name
+ * @param {string} name The database name
  * @return {Connection} this
  * @api public
  */