mongoose 8.2.4 → 8.3.0

package/lib/document.js

@@ -2756,47 +2756,7 @@ function _getPathsToValidate(doc, pathsToValidate, pathsToSkip) {
 
   // gh-661: if a whole array is modified, make sure to run validation on all
   // the children as well
-  for (const path of paths) {
-    const _pathType = doc.$__schema.path(path);
-    if (!_pathType) {
-      continue;
-    }
-
-    if (!_pathType.$isMongooseArray ||
-        // To avoid potential performance issues, skip doc arrays whose children
-        // are not required. `getPositionalPathType()` may be slow, so avoid
-        // it unless we have a case of #6364
-        (!Array.isArray(_pathType) &&
-          _pathType.$isMongooseDocumentArray &&
-          !(_pathType && _pathType.schemaOptions && _pathType.schemaOptions.required))) {
-      continue;
-    }
-
-    // gh-11380: optimization. If the array isn't a document array and there's no validators
-    // on the array type, there's no need to run validation on the individual array elements.
-    if (_pathType.$isMongooseArray &&
-        !_pathType.$isMongooseDocumentArray && // Skip document arrays...
-        !_pathType.$embeddedSchemaType.$isMongooseArray && // and arrays of arrays
-        _pathType.$embeddedSchemaType.validators.length === 0) {
-      continue;
-    }
-
-    const val = doc.$__getValue(path);
-    _pushNestedArrayPaths(val, paths, path);
-  }
-
-  function _pushNestedArrayPaths(val, paths, path) {
-    if (val != null) {
-      const numElements = val.length;
-      for (let j = 0; j < numElements; ++j) {
-        if (Array.isArray(val[j])) {
-          _pushNestedArrayPaths(val[j], paths, path + '.' + j);
-        } else {
-          paths.add(path + '.' + j);
-        }
-      }
-    }
-  }
+  _addArrayPathsToValidate(doc, paths);
 
   const flattenOptions = { skipArrays: true };
   for (const pathToCheck of paths) {
@@ -2841,12 +2801,58 @@ function _getPathsToValidate(doc, pathsToValidate, pathsToSkip) {
   return [paths, doValidateOptions];
 }
 
+function _addArrayPathsToValidate(doc, paths) {
+  for (const path of paths) {
+    const _pathType = doc.$__schema.path(path);
+    if (!_pathType) {
+      continue;
+    }
+
+    if (!_pathType.$isMongooseArray ||
+        // To avoid potential performance issues, skip doc arrays whose children
+        // are not required. `getPositionalPathType()` may be slow, so avoid
+        // it unless we have a case of #6364
+        (!Array.isArray(_pathType) &&
+          _pathType.$isMongooseDocumentArray &&
+          !(_pathType && _pathType.schemaOptions && _pathType.schemaOptions.required))) {
+      continue;
+    }
+
+    // gh-11380: optimization. If the array isn't a document array and there's no validators
+    // on the array type, there's no need to run validation on the individual array elements.
+    if (_pathType.$isMongooseArray &&
+        !_pathType.$isMongooseDocumentArray && // Skip document arrays...
+        !_pathType.$embeddedSchemaType.$isMongooseArray && // and arrays of arrays
+        _pathType.$embeddedSchemaType.validators.length === 0) {
+      continue;
+    }
+
+    const val = doc.$__getValue(path);
+    _pushNestedArrayPaths(val, paths, path);
+  }
+}
+
+function _pushNestedArrayPaths(val, paths, path) {
+  if (val != null) {
+    const numElements = val.length;
+    for (let j = 0; j < numElements; ++j) {
+      if (Array.isArray(val[j])) {
+        _pushNestedArrayPaths(val[j], paths, path + '.' + j);
+      } else {
+        paths.add(path + '.' + j);
+      }
+    }
+  }
+}
+
 /*!
  * ignore
  */
 
 Document.prototype.$__validate = function(pathsToValidate, options, callback) {
-  if (typeof pathsToValidate === 'function') {
+  if (this.$__.saveOptions && this.$__.saveOptions.pathsToSave && !pathsToValidate) {
+    pathsToValidate = [...this.$__.saveOptions.pathsToSave];
+  } else if (typeof pathsToValidate === 'function') {
     callback = pathsToValidate;
     options = null;
     pathsToValidate = null;
@@ -2868,6 +2874,19 @@ Document.prototype.$__validate = function(pathsToValidate, options, callback) {
     shouldValidateModifiedOnly = this.$__schema.options.validateModifiedOnly;
   }
 
+  const validateAllPaths = options && options.validateAllPaths;
+  if (validateAllPaths) {
+    if (pathsToSkip) {
+      throw new TypeError('Cannot set both `validateAllPaths` and `pathsToSkip`');
+    }
+    if (pathsToValidate) {
+      throw new TypeError('Cannot set both `validateAllPaths` and `pathsToValidate`');
+    }
+    if (hasValidateModifiedOnlyOption && shouldValidateModifiedOnly) {
+      throw new TypeError('Cannot set both `validateAllPaths` and `validateModifiedOnly`');
+    }
+  }
+
   const _this = this;
   const _complete = () => {
     let validationError = this.$__.validationError;
@@ -2905,11 +2924,33 @@ Document.prototype.$__validate = function(pathsToValidate, options, callback) {
   };
 
   // only validate required fields when necessary
-  const pathDetails = _getPathsToValidate(this, pathsToValidate, pathsToSkip);
-  const paths = shouldValidateModifiedOnly ?
-    pathDetails[0].filter((path) => this.$isModified(path)) :
-    pathDetails[0];
-  const doValidateOptionsByPath = pathDetails[1];
+  let paths;
+  let doValidateOptionsByPath;
+  if (validateAllPaths) {
+    paths = new Set(Object.keys(this.$__schema.paths));
+    // gh-661: if a whole array is modified, make sure to run validation on all
+    // the children as well
+    for (const path of paths) {
+      const schemaType = this.$__schema.path(path);
+      if (!schemaType || !schemaType.$isMongooseArray) {
+        continue;
+      }
+      const val = this.$__getValue(path);
+      if (!val) {
+        continue;
+      }
+      _pushNestedArrayPaths(val, paths, path);
+    }
+    paths = [...paths];
+    doValidateOptionsByPath = {};
+  } else {
+    const pathDetails = _getPathsToValidate(this, pathsToValidate, pathsToSkip);
+    paths = shouldValidateModifiedOnly ?
+      pathDetails[0].filter((path) => this.$isModified(path)) :
+      pathDetails[0];
+    doValidateOptionsByPath = pathDetails[1];
+  }
+
   if (typeof pathsToValidate === 'string') {
     pathsToValidate = pathsToValidate.split(' ');
   }
@@ -2929,8 +2970,19 @@ Document.prototype.$__validate = function(pathsToValidate, options, callback) {
   const validated = {};
   let total = 0;
 
-  for (const path of paths) {
-    validatePath(path);
+  let pathsToSave = this.$__.saveOptions?.pathsToSave;
+  if (Array.isArray(pathsToSave)) {
+    pathsToSave = new Set(pathsToSave);
+    for (const path of paths) {
+      if (!pathsToSave.has(path)) {
+        continue;
+      }
+      validatePath(path);
+    }
+  } else {
+    for (const path of paths) {
+      validatePath(path);
+    }
   }
 
   function validatePath(path) {
@@ -2979,7 +3031,8 @@ Document.prototype.$__validate = function(pathsToValidate, options, callback) {
       const doValidateOptions = {
         ...doValidateOptionsByPath[path],
         path: path,
-        validateModifiedOnly: shouldValidateModifiedOnly
+        validateModifiedOnly: shouldValidateModifiedOnly,
+        validateAllPaths
       };
 
       schemaType.doValidate(val, function(err) {
@@ -3097,6 +3150,16 @@ Document.prototype.validateSync = function(pathsToValidate, options) {
 
   let pathsToSkip = options && options.pathsToSkip;
 
+  const validateAllPaths = options && options.validateAllPaths;
+  if (validateAllPaths) {
+    if (pathsToSkip) {
+      throw new TypeError('Cannot set both `validateAllPaths` and `pathsToSkip`');
+    }
+    if (pathsToValidate) {
+      throw new TypeError('Cannot set both `validateAllPaths` and `pathsToValidate`');
+    }
+  }
+
   if (typeof pathsToValidate === 'string') {
     const isOnePathOnly = pathsToValidate.indexOf(' ') === -1;
     pathsToValidate = isOnePathOnly ? [pathsToValidate] : pathsToValidate.split(' ');
@@ -3105,11 +3168,32 @@ Document.prototype.validateSync = function(pathsToValidate, options) {
   }
 
   // only validate required fields when necessary
-  const pathDetails = _getPathsToValidate(this, pathsToValidate, pathsToSkip);
-  const paths = shouldValidateModifiedOnly ?
-    pathDetails[0].filter((path) => this.$isModified(path)) :
-    pathDetails[0];
-  const skipSchemaValidators = pathDetails[1];
+  let paths;
+  let skipSchemaValidators;
+  if (validateAllPaths) {
+    paths = new Set(Object.keys(this.$__schema.paths));
+    // gh-661: if a whole array is modified, make sure to run validation on all
+    // the children as well
+    for (const path of paths) {
+      const schemaType = this.$__schema.path(path);
+      if (!schemaType || !schemaType.$isMongooseArray) {
+        continue;
+      }
+      const val = this.$__getValue(path);
+      if (!val) {
+        continue;
+      }
+      _pushNestedArrayPaths(val, paths, path);
+    }
+    paths = [...paths];
+    skipSchemaValidators = {};
+  } else {
+    const pathDetails = _getPathsToValidate(this, pathsToValidate, pathsToSkip);
+    paths = shouldValidateModifiedOnly ?
+      pathDetails[0].filter((path) => this.$isModified(path)) :
+      pathDetails[0];
+    skipSchemaValidators = pathDetails[1];
+  }
 
   const validating = {};
 
@@ -3134,7 +3218,8 @@ Document.prototype.validateSync = function(pathsToValidate, options) {
     const err = p.doValidateSync(val, _this, {
       skipSchemaValidators: skipSchemaValidators[path],
       path: path,
-      validateModifiedOnly: shouldValidateModifiedOnly
+      validateModifiedOnly: shouldValidateModifiedOnly,
+      validateAllPaths
     });
     if (err) {
       const isSubdoc = p.$isSingleNested ||

package/lib/model.js

@@ -298,7 +298,6 @@ Model.prototype.$__handleSave = function(options, callback) {
   if (!saveOptions.hasOwnProperty('session') && session != null) {
     saveOptions.session = session;
   }
-
   if (this.$isNew) {
     // send entire doc
     const obj = this.toObject(saveToObjectOptions);
@@ -335,6 +334,18 @@ Model.prototype.$__handleSave = function(options, callback) {
   // since it already exists
   this.$__.inserting = false;
   const delta = this.$__delta();
+
+  if (options.pathsToSave) {
+    for (const key in delta[1]['$set']) {
+      if (options.pathsToSave.includes(key)) {
+        continue;
+      } else if (options.pathsToSave.some(pathToSave => key.slice(0, pathToSave.length) === pathToSave && key.charAt(pathToSave.length) === '.')) {
+        continue;
+      } else {
+        delete delta[1]['$set'][key];
+      }
+    }
+  }
   if (delta) {
     if (delta instanceof MongooseError) {
       callback(delta);
@@ -521,6 +532,7 @@ function generateVersionError(doc, modifiedPaths) {
  * @param {Number} [options.wtimeout] sets a [timeout for the write concern](https://www.mongodb.com/docs/manual/reference/write-concern/#wtimeout). Overrides the [schema-level `writeConcern` option](https://mongoosejs.com/docs/guide.html#writeConcern).
  * @param {Boolean} [options.checkKeys=true] the MongoDB driver prevents you from saving keys that start with '$' or contain '.' by default. Set this option to `false` to skip that check. See [restrictions on field names](https://docs.mongodb.com/manual/reference/limits/#mongodb-limit-Restrictions-on-Field-Names)
  * @param {Boolean} [options.timestamps=true] if `false` and [timestamps](https://mongoosejs.com/docs/guide.html#timestamps) are enabled, skip timestamps for this `save()`.
+ * @param {Array} [options.pathsToSave] An array of paths that tell mongoose to only validate and save the paths in `pathsToSave`.
  * @throws {DocumentNotFoundError} if this [save updates an existing document](https://mongoosejs.com/docs/api/document.html#Document.prototype.isNew) but the document doesn't exist in the database. For example, you will get this error if the document is [deleted between when you retrieved the document and when you saved it](documents.html#updating).
  * @return {Promise}
  * @api public
@@ -747,7 +759,6 @@ function handleAtomics(self, where, delta, data, value) {
 
 Model.prototype.$__delta = function() {
   const dirty = this.$__dirty();
-
   const optimisticConcurrency = this.$__schema.options.optimisticConcurrency;
   if (optimisticConcurrency) {
     if (Array.isArray(optimisticConcurrency)) {

package/lib/query.js

@@ -2861,19 +2861,27 @@ Query.prototype.distinct = function(field, conditions) {
  * Cannot be used with `distinct()`
  *
  * @param {Object|String|Array<Array<(string | number)>>} arg
+ * @param {Object} [options]
+ * @param {Boolean} [options.override=false] If true, replace existing sort options with `arg`
  * @return {Query} this
  * @see cursor.sort https://www.mongodb.com/docs/manual/reference/method/cursor.sort/
  * @api public
  */
 
-Query.prototype.sort = function(arg) {
-  if (arguments.length > 1) {
-    throw new Error('sort() only takes 1 Argument');
+Query.prototype.sort = function(arg, options) {
+  if (arguments.length > 2) {
+    throw new Error('sort() takes at most 2 arguments');
+  }
+  if (options != null && typeof options !== 'object') {
+    throw new Error('sort() options argument must be an object or nullish');
   }
 
   if (this.options.sort == null) {
     this.options.sort = {};
   }
+  if (options && options.override) {
+    this.options.sort = {};
+  }
   const sort = this.options.sort;
   if (typeof arg === 'string') {
     const properties = arg.indexOf(' ') === -1 ? [arg] : arg.split(' ');

package/lib/schema/documentArray.js

@@ -279,7 +279,7 @@ SchemaDocumentArray.prototype.doValidate = function(array, fn, scope, options) {
         continue;
       }
 
-      doc.$__validate(callback);
+      doc.$__validate(null, options, callback);
     }
   }
 };
@@ -330,7 +330,7 @@ SchemaDocumentArray.prototype.doValidateSync = function(array, scope, options) {
       continue;
     }
 
-    const subdocValidateError = doc.validateSync();
+    const subdocValidateError = doc.validateSync(options);
 
     if (subdocValidateError && resultError == null) {
       resultError = subdocValidateError;

package/lib/schema.js

@@ -1300,6 +1300,7 @@ Schema.prototype.interpretAsType = function(path, obj, options) {
     return clone;
   }
 
+
   // If this schema has an associated Mongoose object, use the Mongoose object's
   // copy of SchemaTypes re: gh-7158 gh-6933
   const MongooseTypes = this.base != null ? this.base.Schema.Types : Schema.Types;
@@ -1365,9 +1366,13 @@ Schema.prototype.interpretAsType = function(path, obj, options) {
       }
       return new MongooseTypes.DocumentArray(path, cast[options.typeKey], obj, cast);
     }
-
-    if (Array.isArray(cast)) {
-      return new MongooseTypes.Array(path, this.interpretAsType(path, cast, options), obj);
+    if (typeof cast !== 'undefined') {
+      if (Array.isArray(cast) || cast.type === Array || cast.type == 'Array') {
+        if (cast && cast.type == 'Array') {
+          cast.type = Array;
+        }
+        return new MongooseTypes.Array(path, this.interpretAsType(path, cast, options), obj);
+      }
     }
 
     // Handle both `new Schema({ arr: [{ subpath: String }] })` and `new Schema({ arr: [{ type: { subpath: string } }] })`
@@ -1418,7 +1423,6 @@ Schema.prototype.interpretAsType = function(path, obj, options) {
       type = cast[options.typeKey] && (options.typeKey !== 'type' || !cast.type.type)
         ? cast[options.typeKey]
         : cast;
-
       if (Array.isArray(type)) {
         return new MongooseTypes.Array(path, this.interpretAsType(path, type, options), obj);
       }

package/lib/schemaType.js

@@ -803,6 +803,21 @@ SchemaType.prototype.get = function(fn) {
   return this;
 };
 
+/**
+ * Adds multiple validators for this document path.
+ * Calls `validate()` for every element in validators.
+ *
+ * @param {Array<RegExp|Function|Object>} validators
+ * @returns this
+ */
+
+SchemaType.prototype.validateAll = function(validators) {
+  for (let i = 0; i < validators.length; i++) {
+    this.validate(validators[i]);
+  }
+  return this;
+};
+
 /**
  * Adds validator(s) for this document path.
  *
@@ -1285,6 +1300,9 @@ SchemaType.prototype.select = function select(val) {
 SchemaType.prototype.doValidate = function(value, fn, scope, options) {
   let err = false;
   const path = this.path;
+  if (typeof fn !== 'function') {
+    throw new TypeError(`Must pass callback function to doValidate(), got ${typeof fn}`);
+  }
 
   // Avoid non-object `validators`
   const validators = this.validators.
@@ -1419,7 +1437,6 @@ SchemaType.prototype.doValidateSync = function(value, scope, options) {
   let i = 0;
   const len = validators.length;
   for (i = 0; i < len; ++i) {
-
     const v = validators[i];
 
     if (v === null || typeof v !== 'object') {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "8.2.4",
+  "version": "8.3.0",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -19,17 +19,17 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "bson": "^6.2.0",
-    "kareem": "2.5.1",
-    "mongodb": "6.3.0",
+    "bson": "^6.5.0",
+    "kareem": "2.6.0",
+    "mongodb": "6.5.0",
     "mpath": "0.9.0",
     "mquery": "5.0.0",
     "ms": "2.1.3",
     "sift": "16.0.1"
   },
   "devDependencies": {
-    "@babel/core": "7.24.0",
-    "@babel/preset-env": "7.24.0",
+    "@babel/core": "7.24.3",
+    "@babel/preset-env": "7.24.3",
     "@typescript-eslint/eslint-plugin": "^6.2.1",
     "@typescript-eslint/parser": "^6.2.1",
     "acquit": "1.3.0",
@@ -46,7 +46,7 @@
     "dotenv": "16.4.5",
     "dox": "1.0.0",
     "eslint": "8.57.0",
-    "eslint-plugin-markdown": "^3.0.1",
+    "eslint-plugin-markdown": "^4.0.1",
     "eslint-plugin-mocha-no-only": "1.1.1",
     "express": "^4.18.1",
     "fs-extra": "~11.2.0",
@@ -56,7 +56,7 @@
     "markdownlint-cli2": "^0.12.1",
     "marked": "4.3.0",
     "mkdirp": "^3.0.1",
-    "mocha": "10.3.0",
+    "mocha": "10.4.0",
     "moment": "2.x",
     "mongodb-memory-server": "8.15.1",
     "ncp": "^2.0.0",
@@ -65,10 +65,10 @@
     "q": "1.5.1",
     "sinon": "17.0.1",
     "stream-browserify": "3.0.0",
-    "tsd": "0.30.7",
-    "typescript": "5.3.3",
+    "tsd": "0.31.0",
+    "typescript": "5.4.3",
     "uuid": "9.0.1",
-    "webpack": "5.90.3"
+    "webpack": "5.91.0"
   },
   "directories": {
     "lib": "./lib/mongoose"

package/types/index.d.ts

@@ -27,6 +27,7 @@
 declare class NativeDate extends global.Date { }
 
 declare module 'mongoose' {
+  import Kareem = require('kareem');
   import events = require('events');
   import mongodb = require('mongodb');
   import mongoose = require('mongoose');
@@ -397,7 +398,6 @@ declare module 'mongoose' {
     ): this;
     // this = Document
     pre<T = THydratedDocumentType>(method: 'save', fn: PreSaveMiddlewareFunction<T>): this;
-    pre<T = THydratedDocumentType>(method: 'save', options: SchemaPreOptions, fn: PreSaveMiddlewareFunction<T>): this;
     pre<T = THydratedDocumentType>(method: MongooseDistinctDocumentMiddleware|MongooseDistinctDocumentMiddleware[], fn: PreMiddlewareFunction<T>): this;
     pre<T = THydratedDocumentType>(method: MongooseDistinctDocumentMiddleware|MongooseDistinctDocumentMiddleware[], options: SchemaPreOptions, fn: PreMiddlewareFunction<T>): this;
     pre<T = THydratedDocumentType>(
@@ -415,7 +415,6 @@ declare module 'mongoose' {
     pre<T = THydratedDocumentType|Query<any, any>>(method: MongooseQueryOrDocumentMiddleware | MongooseQueryOrDocumentMiddleware[] | RegExp, fn: PreMiddlewareFunction<T>): this;
     // method aggregate
     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 = TModelType>(
       method: 'insertMany' | RegExp,
@@ -426,16 +425,6 @@ declare module 'mongoose' {
         options?: InsertManyOptions & { lean?: boolean }
       ) => void | Promise<void>
     ): this;
-    pre<T = TModelType>(
-      method: 'insertMany' | RegExp,
-      options: SchemaPreOptions,
-      fn: (
-        this: T,
-        next: (err?: CallbackError) => void,
-        docs: any | Array<any>,
-        options?: InsertManyOptions & { lean?: boolean }
-      ) => void | Promise<void>
-    ): this;
     /* method bulkWrite */
     pre<T = TModelType>(
       method: 'bulkWrite' | RegExp,
@@ -446,16 +435,6 @@ declare module 'mongoose' {
         options?: mongodb.BulkWriteOptions & MongooseBulkWriteOptions
       ) => void | Promise<void>
     ): this;
-    pre<T = TModelType>(
-      method: 'bulkWrite' | RegExp,
-      options: SchemaPreOptions,
-      fn: (
-        this: T,
-        next: (err?: CallbackError) => void,
-        ops: Array<mongodb.AnyBulkWriteOperation<any> & MongooseBulkWritePerWriteOptions>,
-        options?: mongodb.BulkWriteOptions & MongooseBulkWriteOptions
-      ) => void | Promise<void>
-    ): this;
     /* method createCollection */
     pre<T = TModelType>(
       method: 'createCollection' | RegExp,
@@ -465,15 +444,6 @@ declare module 'mongoose' {
         options?: mongodb.CreateCollectionOptions & Pick<SchemaOptions, 'expires'>
       ) => void | Promise<void>
     ): this;
-    pre<T = TModelType>(
-      method: 'createCollection' | RegExp,
-      options: SchemaPreOptions,
-      fn: (
-        this: T,
-        next: (err?: CallbackError) => void,
-        options?: mongodb.CreateCollectionOptions & Pick<SchemaOptions, 'expires'>
-      ) => void | Promise<void>
-    ): this;
 
     /** Object of currently defined query helpers on this schema. */
     query: TQueryHelpers;
@@ -722,5 +692,9 @@ declare module 'mongoose' {
   /* for ts-mongoose */
   export class mquery { }
 
+  export function overwriteMiddlewareResult(val: any): Kareem.OverwriteMiddlewareResult;
+
+  export function skipMiddlewareFunction(val: any): Kareem.SkipWrappedFunction;
+
   export default mongoose;
 }

package/types/middlewares.d.ts

@@ -1,4 +1,5 @@
 declare module 'mongoose' {
+  import Kareem = require('kareem');
 
   type MongooseQueryAndDocumentMiddleware = 'updateOne' | 'deleteOne';
 
@@ -37,13 +38,13 @@ declare module 'mongoose' {
     this: ThisType,
     next: CallbackWithoutResultAndOptionalError,
     opts?: Record<string, any>
-  ) => void | Promise<void>;
+  ) => void | Promise<void> | Kareem.SkipWrappedFunction;
   type PreSaveMiddlewareFunction<ThisType = any> = (
     this: ThisType,
     next: CallbackWithoutResultAndOptionalError,
     opts: SaveOptions
-  ) => void | Promise<void>;
-  type PostMiddlewareFunction<ThisType = any, ResType = any> = (this: ThisType, res: ResType, next: CallbackWithoutResultAndOptionalError) => void | Promise<void>;
+  ) => void | Promise<void> | Kareem.SkipWrappedFunction;
+  type PostMiddlewareFunction<ThisType = any, ResType = any> = (this: ThisType, res: ResType, next: CallbackWithoutResultAndOptionalError) => void | Promise<void> | Kareem.OverwriteMiddlewareResult;
   type ErrorHandlingMiddlewareFunction<ThisType = any, ResType = any> = (this: ThisType, err: NativeError, res: ResType, next: CallbackWithoutResultAndOptionalError) => void;
-  type ErrorHandlingMiddlewareWithOption<ThisType = any, ResType = any> = (this: ThisType, err: NativeError, res: ResType | null, next: CallbackWithoutResultAndOptionalError) => void | Promise<void>;
+  type ErrorHandlingMiddlewareWithOption<ThisType = any, ResType = any> = (this: ThisType, err: NativeError, res: ResType | null, next: CallbackWithoutResultAndOptionalError) => void | Promise<void> | Kareem.OverwriteMiddlewareResult;
 }

package/types/query.d.ts

@@ -741,7 +741,10 @@ declare module 'mongoose' {
     slice(val: number | Array<number>): this;
 
     /** Sets the sort order. If an object is passed, values allowed are `asc`, `desc`, `ascending`, `descending`, `1`, and `-1`. */
-    sort(arg?: string | { [key: string]: SortOrder | { $meta: any } } | [string, SortOrder][] | undefined | null): this;
+    sort(
+      arg?: string | { [key: string]: SortOrder | { $meta: any } } | [string, SortOrder][] | undefined | null,
+      options?: { override?: boolean }
+    ): this;
 
     /** Sets the tailable option (for use with capped collections). */
     tailable(bool?: boolean, opts?: {

package/types/schematypes.d.ts

@@ -192,10 +192,14 @@ declare module 'mongoose' {
     [other: string]: any;
   }
 
-  interface Validator {
-    message?: string; type?: string; validator?: Function
+  interface Validator<DocType = any> {
+    message?: string;
+    type?: string;
+    validator?: ValidatorFunction<DocType>;
   }
 
+  type ValidatorFunction<DocType = any> = (this: DocType, value: any, validatorProperties?: Validator) => any;
+
   class SchemaType<T = any, DocType = any> {
     /** SchemaType constructor */
     constructor(path: string, options?: AnyObject, instance?: string);
@@ -281,7 +285,10 @@ declare module 'mongoose' {
     validators: Validator[];
 
     /** Adds validator(s) for this document path. */
-    validate(obj: RegExp | ((this: DocType, value: any, validatorProperties?: Validator) => any), errorMsg?: string, type?: string): this;
+    validate(obj: RegExp | ValidatorFunction<DocType> | Validator<DocType>, errorMsg?: string, type?: string): this;
+
+    /** Adds multiple validators for this document path. */
+    validateAll(validators: Array<RegExp | ValidatorFunction<DocType> | Validator<DocType>>): this;
 
     /** Default options for this SchemaType */
     defaultOptions?: Record<string, any>;