mongoose 7.3.1 → 7.3.3

package/lib/connection.js

@@ -703,8 +703,7 @@ Connection.prototype.onOpen = function() {
  * @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.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.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>}

package/lib/cursor/QueryCursor.js

@@ -84,25 +84,33 @@ function QueryCursor(query, options) {
       this.options._populateBatchSize = Math.min(this.options.batchSize, 5000);
     }
     Object.assign(this.options, query._optionsForExec());
-    model.collection.find(query._conditions, this.options, (err, cursor) => {
-      if (err != null) {
-        this._markError(err);
-        this.listeners('error').length > 0 && this.emit('error', this._error);
-        return;
-      }
-
-      if (this._error) {
-        cursor.close(function() {});
-        this.listeners('error').length > 0 && this.emit('error', this._error);
-      }
-      this.cursor = cursor;
-      this.emit('cursor', cursor);
-    });
+    if (model.collection._shouldBufferCommands() && model.collection.buffer) {
+      model.collection.queue.push([
+        () => _getRawCursor(query, this)
+      ]);
+    } else {
+      _getRawCursor(query, this);
+    }
   });
 }
 
 util.inherits(QueryCursor, Readable);
 
+/*!
+ * ignore
+ */
+
+function _getRawCursor(query, queryCursor) {
+  try {
+    const cursor = query.model.collection.find(query._conditions, queryCursor.options);
+    queryCursor.cursor = cursor;
+    queryCursor.emit('cursor', cursor);
+  } catch (err) {
+    queryCursor._markError(err);
+    queryCursor.listeners('error').length > 0 && queryCursor.emit('error', queryCursor._error);
+  }
+}
+
 /**
  * Necessary to satisfy the Readable API
  * @method _read

package/lib/document.js

@@ -741,6 +741,10 @@ function init(self, obj, doc, opts, prefix) {
 
   function _init(index) {
     i = keys[index];
+    // avoid prototype pollution
+    if (i === '__proto__' || i === 'constructor') {
+      return;
+    }
     path = prefix + i;
     schemaType = docSchema.path(path);
 
@@ -2684,7 +2688,7 @@ function _getPathsToValidate(doc, pathsToValidate, pathsToSkip) {
 
     // Optimization: if primitive path with no validators, or array of primitives
     // with no validators, skip validating this path entirely.
-    if (!_pathType.caster && _pathType.validators.length === 0) {
+    if (!_pathType.caster && _pathType.validators.length === 0 && !_pathType.$parentSchemaDocArray) {
       paths.delete(path);
     } else if (_pathType.$isMongooseArray &&
       !_pathType.$isMongooseDocumentArray && // Skip document arrays...
@@ -2771,7 +2775,19 @@ function _getPathsToValidate(doc, pathsToValidate, pathsToSkip) {
 
   for (const path of paths) {
     const _pathType = doc.$__schema.path(path);
-    if (!_pathType || !_pathType.$isSchemaMap) {
+
+    if (!_pathType) {
+      continue;
+    }
+
+    // If underneath a document array, may need to re-validate the parent
+    // array re: gh-6818. Do this _after_ adding subpaths, because
+    // we don't want to add every array subpath.
+    if (_pathType.$parentSchemaDocArray && typeof _pathType.$parentSchemaDocArray.path === 'string') {
+      paths.add(_pathType.$parentSchemaDocArray.path);
+    }
+
+    if (!_pathType.$isSchemaMap) {
       continue;
     }
 
@@ -3318,14 +3334,7 @@ Document.prototype.$__reset = function reset() {
     if (this.isModified(fullPathWithIndexes) || isParentInit(fullPathWithIndexes)) {
       subdoc.$__reset();
       if (subdoc.$isDocumentArrayElement) {
-        if (!resetArrays.has(subdoc.parentArray())) {
-          const array = subdoc.parentArray();
-          this.$__.activePaths.clearPath(fullPathWithIndexes.replace(/\.\d+$/, '').slice(-subdoc.$basePath - 1));
-          array[arrayAtomicsBackupSymbol] = array[arrayAtomicsSymbol];
-          array[arrayAtomicsSymbol] = {};
-
-          resetArrays.add(array);
-        }
+        resetArrays.add(subdoc.parentArray());
       } else {
         if (subdoc.$parent() === this) {
           this.$__.activePaths.clearPath(subdoc.$basePath);
@@ -3338,6 +3347,12 @@ Document.prototype.$__reset = function reset() {
     }
   }
 
+  for (const array of resetArrays) {
+    this.$__.activePaths.clearPath(array.$path());
+    array[arrayAtomicsBackupSymbol] = array[arrayAtomicsSymbol];
+    array[arrayAtomicsSymbol] = {};
+  }
+
   function isParentInit(path) {
     path = path.indexOf('.') === -1 ? [path] : path.split('.');
     let cur = '';

package/lib/helpers/populate/getModelsMapForPopulate.js

@@ -64,7 +64,7 @@ module.exports = function getModelsMapForPopulate(model, docs, options) {
         schema.options.refPath == null) {
       continue;
     }
-    const isUnderneathDocArray = schema && schema.$isUnderneathDocArray;
+    const isUnderneathDocArray = schema && schema.$parentSchemaDocArray;
     if (isUnderneathDocArray && get(options, 'options.sort') != null) {
       return new MongooseError('Cannot populate with `sort` on path ' + options.path +
         ' because it is a subproperty of a document array');
@@ -540,6 +540,7 @@ function addModelNamesToMap(model, map, available, modelNames, options, data, re
       // Used internally for checking what model was used to populate this
       // path.
       options[populateModelSymbol] = Model;
+      currentOptions[populateModelSymbol] = Model;
       available[modelName] = {
         model: Model,
         options: currentOptions,

package/lib/helpers/populate/getSchemaTypes.js

@@ -101,8 +101,8 @@ module.exports = function getSchemaTypes(model, schema, doc, path) {
               nestedPath.concat(parts.slice(0, p))
             );
             if (ret) {
-              ret.$isUnderneathDocArray = ret.$isUnderneathDocArray ||
-                !foundschema.schema.$isSingleNested;
+              ret.$parentSchemaDocArray = ret.$parentSchemaDocArray ||
+                (foundschema.schema.$isSingleNested ? null : foundschema);
             }
             return ret;
           }
@@ -117,10 +117,10 @@ module.exports = function getSchemaTypes(model, schema, doc, path) {
                 nestedPath.concat(parts.slice(0, p))
               );
               if (_ret != null) {
-                _ret.$isUnderneathDocArray = _ret.$isUnderneathDocArray ||
-                  !foundschema.schema.$isSingleNested;
-                if (_ret.$isUnderneathDocArray) {
-                  ret.$isUnderneathDocArray = true;
+                _ret.$parentSchemaDocArray = _ret.$parentSchemaDocArray ||
+                  (foundschema.schema.$isSingleNested ? null : foundschema);
+                if (_ret.$parentSchemaDocArray) {
+                  ret.$parentSchemaDocArray = _ret.$parentSchemaDocArray;
                 }
                 ret.push(_ret);
               }
@@ -135,8 +135,8 @@ module.exports = function getSchemaTypes(model, schema, doc, path) {
             );
 
             if (ret) {
-              ret.$isUnderneathDocArray = ret.$isUnderneathDocArray ||
-                !foundschema.schema.$isSingleNested;
+              ret.$parentSchemaDocArray = ret.$parentSchemaDocArray ||
+                (foundschema.schema.$isSingleNested ? null : foundschema);
             }
             return ret;
           }
@@ -188,10 +188,6 @@ module.exports = function getSchemaTypes(model, schema, doc, path) {
             nestedPath.concat(parts.slice(0, p))
           );
 
-          if (ret) {
-            ret.$isUnderneathDocArray = ret.$isUnderneathDocArray ||
-              !model.schema.$isSingleNested;
-          }
           return ret;
         }
       }
@@ -212,8 +208,8 @@ module.exports = function getSchemaTypes(model, schema, doc, path) {
           );
 
           if (ret != null) {
-            ret.$isUnderneathDocArray = ret.$isUnderneathDocArray ||
-              !schema.$isSingleNested;
+            ret.$parentSchemaDocArray = ret.$parentSchemaDocArray ||
+              (schema.$isSingleNested ? null : schema);
             return ret;
           }
         }

package/lib/index.js

@@ -329,8 +329,7 @@ Mongoose.prototype.get = Mongoose.prototype.set;
  * @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.socketTimeoutMS=0] How long the MongoDB driver will wait before killing a socket due to inactivity _after initial connection_. Defaults to 0, which means Node.js will not time out the socket due to inactivity. A socket may be inactive because of either no activity or a long-running operation. 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.
  * @api public
@@ -385,8 +384,7 @@ Mongoose.prototype.createConnection = function(uri, options) {
  * @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.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.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 {Function} [callback]

package/lib/model.js

@@ -1046,16 +1046,18 @@ Model.prototype.$__deleteOne = function $__deleteOne(options, cb) {
     options.session = session;
   }
 
-  this[modelCollectionSymbol].deleteOne(where, options, err => {
-    if (!err) {
+  this[modelCollectionSymbol].deleteOne(where, options).then(
+    () => {
       this.$__.isDeleted = true;
       this.$emit('deleteOne', this);
       this.constructor.emit('deleteOne', this);
       return cb(null, this);
+    },
+    err => {
+      this.$__.isDeleted = false;
+      cb(err);
     }
-    this.$__.isDeleted = false;
-    cb(err);
-  });
+  );
 };
 
 /**
@@ -3232,16 +3234,19 @@ Model.$__insertMany = function(arr, options, callback) {
         }
 
         // `insertedDocs` is a Mongoose-specific property
+        const hasWriteErrors = error && error.writeErrors;
         const erroredIndexes = new Set((error && error.writeErrors || []).map(err => err.index));
 
-        for (let i = 0; i < error.writeErrors.length; ++i) {
-          const originalIndex = validDocIndexToOriginalIndex.get(error.writeErrors[i].index);
-          error.writeErrors[i] = {
-            ...error.writeErrors[i],
-            index: originalIndex
-          };
-          if (!ordered) {
-            results[originalIndex] = error.writeErrors[i];
+        if (error.writeErrors != null) {
+          for (let i = 0; i < error.writeErrors.length; ++i) {
+            const originalIndex = validDocIndexToOriginalIndex.get(error.writeErrors[i].index);
+            error.writeErrors[i] = {
+              ...error.writeErrors[i],
+              index: originalIndex
+            };
+            if (!ordered) {
+              results[originalIndex] = error.writeErrors[i];
+            }
           }
         }
 
@@ -3258,7 +3263,7 @@ Model.$__insertMany = function(arr, options, callback) {
         let firstErroredIndex = -1;
         error.insertedDocs = docAttributes.
           filter((doc, i) => {
-            const isErrored = erroredIndexes.has(i);
+            const isErrored = !hasWriteErrors || erroredIndexes.has(i);
 
             if (ordered) {
               if (firstErroredIndex > -1) {
@@ -4262,7 +4267,7 @@ const excludeIdReg = /\s?-_id\s?/;
 const excludeIdRegGlobal = /\s?-_id\s?/g;
 
 function populate(model, docs, options, callback) {
-  const populateOptions = { ...options };
+  const populateOptions = options;
   if (options.strictPopulate == null) {
     if (options._localModel != null && options._localModel.schema._userProvidedOptions.strictPopulate != null) {
       populateOptions.strictPopulate = options._localModel.schema._userProvidedOptions.strictPopulate;

package/lib/query.js

@@ -3281,6 +3281,12 @@ Query.prototype.findOneAndUpdate = function(filter, doc, options) {
  */
 
 Query.prototype._findOneAndUpdate = async function _findOneAndUpdate() {
+  // For backwards compability with Mongoose 6 re: #13550
+  if (this._mongooseOptions.overwrite) {
+    this.op = 'findOneAndReplace';
+    return this._findOneAndReplace();
+  }
+
   this._castConditions();
 
   _castArrayFilters(this);
@@ -4354,7 +4360,10 @@ Query.prototype.exec = async function exec(op) {
   }
 
   if (this.op == null) {
-    throw new Error('Query must have `op` before executing');
+    throw new MongooseError('Query must have `op` before executing');
+  }
+  if (this.model == null) {
+    throw new MongooseError('Query must have an associated model before executing');
   }
   this._validateOp();
 
@@ -4434,6 +4443,13 @@ function _executePostExecHooks(query) {
  */
 
 function _executePostHooks(query, res, error, op) {
+  if (query._queryMiddleware == null) {
+    if (error != null) {
+      throw error;
+    }
+    return res;
+  }
+
   return new Promise((resolve, reject) => {
     const opts = error ? { error } : {};
 
@@ -4467,6 +4483,10 @@ function _executePreExecHooks(query) {
  */
 
 function _executePreHooks(query, op) {
+  if (query._queryMiddleware == null) {
+    return;
+  }
+
   return new Promise((resolve, reject) => {
     query._queryMiddleware.execPre(op || query.op, query, [], (error) => {
       if (error != null) {

package/lib/schema.js

@@ -1131,22 +1131,22 @@ Schema.prototype.path = function(path, obj) {
     for (const key of Object.keys(schemaType.schema.paths)) {
       const _schemaType = schemaType.schema.paths[key];
       this.subpaths[path + '.' + key] = _schemaType;
-      if (typeof _schemaType === 'object' && _schemaType != null) {
-        _schemaType.$isUnderneathDocArray = true;
+      if (typeof _schemaType === 'object' && _schemaType != null && _schemaType.$parentSchemaDocArray == null) {
+        _schemaType.$parentSchemaDocArray = schemaType;
       }
     }
     for (const key of Object.keys(schemaType.schema.subpaths)) {
       const _schemaType = schemaType.schema.subpaths[key];
       this.subpaths[path + '.' + key] = _schemaType;
-      if (typeof _schemaType === 'object' && _schemaType != null) {
-        _schemaType.$isUnderneathDocArray = true;
+      if (typeof _schemaType === 'object' && _schemaType != null && _schemaType.$parentSchemaDocArray == null) {
+        _schemaType.$parentSchemaDocArray = schemaType;
       }
     }
     for (const key of Object.keys(schemaType.schema.singleNestedPaths)) {
       const _schemaType = schemaType.schema.singleNestedPaths[key];
       this.subpaths[path + '.' + key] = _schemaType;
-      if (typeof _schemaType === 'object' && _schemaType != null) {
-        _schemaType.$isUnderneathDocArray = true;
+      if (typeof _schemaType === 'object' && _schemaType != null && _schemaType.$parentSchemaDocArray == null) {
+        _schemaType.$parentSchemaDocArray = schemaType;
       }
     }
   }
@@ -2556,16 +2556,16 @@ Schema.prototype._getSchema = function(path) {
                 // comments.$.comments.$.title
                 ret = search(parts.slice(p + 1), foundschema.schema);
                 if (ret) {
-                  ret.$isUnderneathDocArray = ret.$isUnderneathDocArray ||
-                    !foundschema.schema.$isSingleNested;
+                  ret.$parentSchemaDocArray = ret.$parentSchemaDocArray ||
+                    (foundschema.schema.$isSingleNested ? null : foundschema);
                 }
                 return ret;
               }
               // this is the last path of the selector
               ret = search(parts.slice(p), foundschema.schema);
               if (ret) {
-                ret.$isUnderneathDocArray = ret.$isUnderneathDocArray ||
-                  !foundschema.schema.$isSingleNested;
+                ret.$parentSchemaDocArray = ret.$parentSchemaDocArray ||
+                  (foundschema.schema.$isSingleNested ? null : foundschema);
               }
               return ret;
             }

package/lib/types/array/methods/index.js

@@ -226,6 +226,9 @@ const methods = {
     if (populated && value !== null && value !== undefined) {
       // cast to the populated Models schema
       Model = populated.options[populateModelSymbol];
+      if (Model == null) {
+        throw new MongooseError('No populated model found for path `' + this[arrayPathSymbol] + '`. This is likely a bug in Mongoose, please report an issue on github.com/Automattic/mongoose.');
+      }
 
       // only objects are permitted so we can safely assume that
       // non-objects are to be interpreted as _id

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "7.3.1",
+  "version": "7.3.3",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -28,10 +28,10 @@
     "sift": "16.0.1"
   },
   "devDependencies": {
-    "@babel/core": "7.22.1",
-    "@babel/preset-env": "7.22.4",
-    "@typescript-eslint/eslint-plugin": "5.59.8",
-    "@typescript-eslint/parser": "5.59.8",
+    "@babel/core": "7.22.5",
+    "@babel/preset-env": "7.22.5",
+    "@typescript-eslint/eslint-plugin": "5.61.0",
+    "@typescript-eslint/parser": "5.61.0",
     "acquit": "1.3.0",
     "acquit-ignore": "0.2.1",
     "acquit-require": "0.1.1",
@@ -44,31 +44,32 @@
     "buffer": "^5.6.0",
     "cheerio": "1.0.0-rc.12",
     "crypto-browserify": "3.12.0",
-    "dotenv": "16.1.3",
+    "dotenv": "16.3.1",
     "dox": "1.0.0",
-    "eslint": "8.41.0",
+    "eslint": "8.44.0",
     "eslint-plugin-markdown": "^3.0.0",
     "eslint-plugin-mocha-no-only": "1.1.1",
     "express": "^4.18.1",
+    "fs-extra": "~11.1.1",
     "highlight.js": "11.8.0",
     "lodash.isequal": "4.5.0",
     "lodash.isequalwith": "4.4.0",
+    "markdownlint-cli2": "^0.8.1",
     "marked": "4.3.0",
-    "mkdirp": "^2.1.3",
+    "mkdirp": "^3.0.1",
     "mocha": "10.2.0",
     "moment": "2.x",
-    "mongodb-memory-server": "8.12.2",
+    "mongodb-memory-server": "8.13.0",
     "ncp": "^2.0.0",
     "nyc": "15.1.0",
     "pug": "3.0.2",
     "q": "1.5.1",
-    "sinon": "15.1.0",
+    "sinon": "15.2.0",
     "stream-browserify": "3.0.0",
     "tsd": "0.28.1",
-    "typescript": "5.1.3",
+    "typescript": "5.1.6",
     "uuid": "9.0.0",
-    "webpack": "5.85.0",
-    "fs-extra": "~11.1.1"
+    "webpack": "5.88.1"
   },
   "directories": {
     "lib": "./lib/mongoose"
@@ -98,9 +99,9 @@
     "docs:prepare:publish:6x": "npm run docs:checkout:6x && npm run docs:merge:6x && npm run docs:clean:stable && env DOCS_DEPLOY=true npm run docs:generate && npm run docs:move:6x:tmp && npm run docs:checkout:gh-pages && npm run docs:copy:tmp:6x",
     "docs:check-links": "blc http://127.0.0.1:8089 -ro",
     "lint": "eslint .",
-    "lint-js": "eslint . --ext .js",
+    "lint-js": "eslint . --ext .js --ext .cjs",
     "lint-ts": "eslint . --ext .ts",
-    "lint-md": "eslint . --ext .md",
+    "lint-md": "markdownlint-cli2 \"**/*.md\"",
     "build-browser": "(rm ./dist/* || true) && node ./scripts/build-browser.js",
     "prepublishOnly": "npm run build-browser",
     "release": "git pull && git push origin master --tags && npm publish",

package/types/index.d.ts

@@ -141,12 +141,16 @@ declare module 'mongoose' {
   > = IfAny<
     DocType,
     any,
-    Document<unknown, TQueryHelpers, DocType> & MergeType<
-      Require_id<DocType>,
-      TOverrides extends Record<string, never> ?
-        {} :
-        IfAny<TOverrides, {}>
-    >
+    TOverrides extends Record<string, never> ?
+      Document<unknown, TQueryHelpers, DocType> & Require_id<DocType> :
+      IfAny<
+        TOverrides,
+        Document<unknown, TQueryHelpers, DocType> & Require_id<DocType>,
+        Document<unknown, TQueryHelpers, DocType> & MergeType<
+          Require_id<DocType>,
+          TOverrides
+        >
+      >
   >;
   export type HydratedSingleSubdocument<DocType, TOverrides = {}> = Types.Subdocument<unknown> & Require_id<DocType> & TOverrides;
   export type HydratedArraySubdocument<DocType, TOverrides = {}> = Types.ArraySubdocument<unknown> & Require_id<DocType> & TOverrides;
@@ -197,7 +201,7 @@ declare module 'mongoose' {
 
   export type DiscriminatorSchema<DocType, M, TInstanceMethods, TQueryHelpers, TVirtuals, TStaticMethods, DisSchema> =
     DisSchema extends Schema<infer DisSchemaEDocType, infer DisSchemaM, infer DisSchemaInstanceMethods, infer DisSchemaQueryhelpers, infer DisSchemaVirtuals, infer DisSchemaStatics>
-      ? Schema<Omit<DocType, keyof DisSchemaEDocType> & DisSchemaEDocType, DiscriminatorModel<DisSchemaM, M>, DisSchemaInstanceMethods | TInstanceMethods, DisSchemaQueryhelpers | TQueryHelpers, DisSchemaVirtuals | TVirtuals, DisSchemaStatics & TStaticMethods>
+      ? Schema<MergeType<DocType, DisSchemaEDocType>, DiscriminatorModel<DisSchemaM, M>, DisSchemaInstanceMethods | TInstanceMethods, DisSchemaQueryhelpers | TQueryHelpers, DisSchemaVirtuals | TVirtuals, DisSchemaStatics & TStaticMethods>
       : Schema<DocType, M, TInstanceMethods, TQueryHelpers, TVirtuals, TStaticMethods>;
 
   type QueryResultType<T> = T extends Query<infer ResultType, any> ? ResultType : never;
@@ -212,7 +216,7 @@ declare module 'mongoose' {
 
   export class Schema<
     EnforcedDocType = any,
-    M = Model<EnforcedDocType, any, any, any>,
+    TModelType = Model<EnforcedDocType, any, any, any>,
     TInstanceMethods = {},
     TQueryHelpers = {},
     TVirtuals = {},
@@ -225,13 +229,13 @@ declare module 'mongoose' {
       ObtainDocumentType<any, EnforcedDocType, ResolveSchemaOptions<TSchemaOptions>>,
       ResolveSchemaOptions<TSchemaOptions>
     >,
-    THydratedDocumentType = HydratedDocument<FlatRecord<DocType>, TVirtuals & TInstanceMethods>
+    THydratedDocumentType = HydratedDocument<DocType, TVirtuals & TInstanceMethods>
   >
     extends events.EventEmitter {
     /**
      * Create a new schema
      */
-    constructor(definition?: SchemaDefinition<SchemaDefinitionType<EnforcedDocType>> | DocType, options?: SchemaOptions<FlatRecord<DocType>, TInstanceMethods, TQueryHelpers, TStaticMethods, TVirtuals, THydratedDocumentType> | ResolveSchemaOptions<TSchemaOptions>);
+    constructor(definition?: SchemaDefinition<SchemaDefinitionType<EnforcedDocType>> | DocType, options?: SchemaOptions<DocType, TInstanceMethods, TQueryHelpers, TStaticMethods, TVirtuals, THydratedDocumentType> | ResolveSchemaOptions<TSchemaOptions>);
 
     /** Adds key path / schema type pairs to this schema. */
     add(obj: SchemaDefinition<SchemaDefinitionType<EnforcedDocType>> | Schema, prefix?: string): this;
@@ -311,7 +315,7 @@ declare module 'mongoose' {
     pathType(path: string): string;
 
     /** Registers a plugin for this schema. */
-    plugin<PFunc extends PluginFunction<DocType, M, any, any, any, any>, POptions extends Parameters<PFunc>[1] = Parameters<PFunc>[1]>(fn: PFunc, opts?: POptions): this;
+    plugin<PFunc extends PluginFunction<DocType, TModelType, any, any, any, any>, POptions extends Parameters<PFunc>[1] = Parameters<PFunc>[1]>(fn: PFunc, opts?: POptions): this;
 
     /** Defines a post hook for the model. */
 
@@ -320,7 +324,7 @@ declare module 'mongoose' {
     post<T = Query<any, any>>(method: MongooseQueryMiddleware | MongooseQueryMiddleware[] | RegExp, options: SchemaPostOptions & { errorHandler: true }, fn: ErrorHandlingMiddlewareWithOption<T>): this;
     post<T = THydratedDocumentType>(method: MongooseDocumentMiddleware | MongooseDocumentMiddleware[] | RegExp, options: SchemaPostOptions & { errorHandler: true }, fn: ErrorHandlingMiddlewareWithOption<T>): this;
     post<T extends Aggregate<any>>(method: 'aggregate' | RegExp, options: SchemaPostOptions & { errorHandler: true }, fn: ErrorHandlingMiddlewareWithOption<T, Array<any>>): this;
-    post<T = M>(method: 'insertMany' | RegExp, options: SchemaPostOptions & { errorHandler: true }, fn: ErrorHandlingMiddlewareWithOption<T>): this;
+    post<T = TModelType>(method: 'insertMany' | RegExp, options: SchemaPostOptions & { errorHandler: true }, fn: ErrorHandlingMiddlewareWithOption<T>): this;
 
     // this = never since it never happens
     post<T = never>(method: MongooseQueryOrDocumentMiddleware | MongooseQueryOrDocumentMiddleware[] | RegExp, options: SchemaPostOptions & { document: false, query: false }, fn: PostMiddlewareFunction<never, never>): this;
@@ -358,14 +362,14 @@ declare module 'mongoose' {
     // method aggregate and insertMany with PostMiddlewareFunction
     post<T extends Aggregate<any>>(method: 'aggregate' | RegExp, fn: PostMiddlewareFunction<T, Array<AggregateExtract<T>>>): this;
     post<T extends Aggregate<any>>(method: 'aggregate' | RegExp, options: SchemaPostOptions, fn: PostMiddlewareFunction<T, Array<AggregateExtract<T>>>): this;
-    post<T = M>(method: 'insertMany' | RegExp, fn: PostMiddlewareFunction<T, T>): this;
-    post<T = M>(method: 'insertMany' | RegExp, options: SchemaPostOptions, fn: PostMiddlewareFunction<T, T>): this;
+    post<T = TModelType>(method: 'insertMany' | RegExp, fn: PostMiddlewareFunction<T, T>): this;
+    post<T = TModelType>(method: 'insertMany' | RegExp, options: SchemaPostOptions, fn: PostMiddlewareFunction<T, T>): this;
 
     // method aggregate and insertMany with ErrorHandlingMiddlewareFunction
     post<T extends Aggregate<any>>(method: 'aggregate' | RegExp, fn: ErrorHandlingMiddlewareFunction<T, Array<any>>): this;
     post<T extends Aggregate<any>>(method: 'aggregate' | RegExp, options: SchemaPostOptions, fn: ErrorHandlingMiddlewareFunction<T, Array<any>>): this;
-    post<T = M>(method: 'insertMany' | RegExp, fn: ErrorHandlingMiddlewareFunction<T>): this;
-    post<T = M>(method: 'insertMany' | RegExp, options: SchemaPostOptions, fn: ErrorHandlingMiddlewareFunction<T>): this;
+    post<T = TModelType>(method: 'insertMany' | RegExp, fn: ErrorHandlingMiddlewareFunction<T>): this;
+    post<T = TModelType>(method: 'insertMany' | RegExp, options: SchemaPostOptions, fn: ErrorHandlingMiddlewareFunction<T>): this;
 
     /** Defines a pre hook for the model. */
     // this = never since it never happens
@@ -390,8 +394,8 @@ declare module 'mongoose' {
     pre<T extends Aggregate<any>>(method: 'aggregate' | RegExp, fn: PreMiddlewareFunction<T>): this;
     pre<T extends Aggregate<any>>(method: 'aggregate' | RegExp, options: SchemaPreOptions, fn: PreMiddlewareFunction<T>): this;
     /* method insertMany */
-    pre<T = M>(method: 'insertMany' | RegExp, fn: (this: T, next: (err?: CallbackError) => void, docs: any | Array<any>) => void | Promise<void>): this;
-    pre<T = M>(method: 'insertMany' | RegExp, options: SchemaPreOptions, fn: (this: T, next: (err?: CallbackError) => void, docs: any | Array<any>) => void | Promise<void>): this;
+    pre<T = TModelType>(method: 'insertMany' | RegExp, fn: (this: T, next: (err?: CallbackError) => void, docs: any | Array<any>) => void | Promise<void>): this;
+    pre<T = TModelType>(method: 'insertMany' | RegExp, options: SchemaPreOptions, fn: (this: T, next: (err?: CallbackError) => void, docs: any | Array<any>) => void | Promise<void>): this;
 
     /** Object of currently defined query helpers on this schema. */
     query: TQueryHelpers;
@@ -413,11 +417,12 @@ declare module 'mongoose' {
 
     /** Adds static "class" methods to Models compiled from this schema. */
     static<K extends keyof TStaticMethods>(name: K, fn: TStaticMethods[K]): this;
-    static(obj: { [F in keyof TStaticMethods]: TStaticMethods[F] } & { [name: string]: (this: M, ...args: any[]) => any }): this;
-    static(name: string, fn: (this: M, ...args: any[]) => any): this;
+    static(obj: { [F in keyof TStaticMethods]: TStaticMethods[F] } & { [name: string]: (this: TModelType, ...args: any[]) => any }): this;
+    static(name: string, fn: (this: TModelType, ...args: any[]) => any): this;
 
     /** Object of currently defined statics on this schema. */
-    statics: { [F in keyof TStaticMethods]: TStaticMethods[F] } & { [name: string]: (this: M, ...args: any[]) => any };
+    statics: { [F in keyof TStaticMethods]: TStaticMethods[F] } &
+    { [name: string]: (this: TModelType, ...args: any[]) => unknown };
 
     /** Creates a virtual type with the given name. */
     virtual<T = HydratedDocument<DocType, TVirtuals & TInstanceMethods, TQueryHelpers>>(
@@ -430,6 +435,8 @@ declare module 'mongoose' {
 
     /** Returns the virtual type with the given `name`. */
     virtualpath<T = THydratedDocumentType>(name: string): VirtualType<T> | null;
+
+    static ObjectId: typeof Schema.Types.ObjectId;
   }
 
   export type NumberSchemaDefinition = typeof Number | 'number' | 'Number' | typeof Schema.Types.Number;