mongoose 9.0.1 → 9.1.0

package/lib/types/arraySubdocument.js

@@ -73,7 +73,7 @@ for (const i in EventEmitter.prototype) {
 ArraySubdocument.prototype.$setIndex = function(index) {
   this.__index = index;
 
-  if (this.$__ != null && this.$__.validationError != null) {
+  if (this.$__?.validationError != null) {
     const keys = Object.keys(this.$__.validationError.errors);
     for (const key of keys) {
       this.invalidate(key, this.$__.validationError.errors[key]);
@@ -145,7 +145,7 @@ ArraySubdocument.prototype.$__fullPath = function(path, skipIndex) {
  */
 
 ArraySubdocument.prototype.$__pathRelativeToParent = function(path, skipIndex) {
-  if (this.__index == null || (!this.__parentArray || !this.__parentArray.$path)) {
+  if (this.__index == null || !this.__parentArray?.$path) {
     return null;
   }
   if (skipIndex) {
@@ -169,6 +169,16 @@ ArraySubdocument.prototype.$parent = function() {
   return this[documentArrayParent];
 };
 
+/*!
+ * Sets this sub-documents parent document.
+ *
+ * @api private
+ */
+
+ArraySubdocument.prototype.$__setParent = function $__setParent(parent) {
+  this[documentArrayParent] = parent;
+};
+
 /**
  * Returns this subdocument's parent array.
  *

package/lib/types/buffer.js

@@ -131,7 +131,7 @@ MongooseBuffer.mixin = {
   copy: function(target) {
     const ret = Buffer.prototype.copy.apply(this, arguments);
 
-    if (target && target.isMongooseBuffer) {
+    if (target?.isMongooseBuffer) {
       target._markModified();
     }
 

package/lib/types/documentArray/index.js

@@ -50,7 +50,7 @@ function MongooseDocumentArray(values, path, doc, schematype) {
   internals[arrayPathSymbol] = path;
   internals.__array = __array;
 
-  if (doc && doc.$__) {
+  if (doc?.$__) {
     internals[arrayParentSymbol] = doc;
     internals[arraySchemaSymbol] = doc.$__schema.path(path);
 
@@ -79,7 +79,7 @@ function MongooseDocumentArray(values, path, doc, schematype) {
       if (Object.hasOwn(DocumentArrayMethods, prop)) {
         return DocumentArrayMethods[prop];
       }
-      if (schematype && schematype.virtuals && Object.hasOwn(schematype.virtuals, prop)) {
+      if (schematype?.virtuals && Object.hasOwn(schematype.virtuals, prop)) {
         return schematype.virtuals[prop].applyGetters(undefined, target);
       }
       if (Object.hasOwn(ArrayMethods, prop)) {

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

@@ -25,7 +25,7 @@ const methods = {
 
   toString() {
     return _baseToString.call(this.__array.map(subdoc => {
-      if (subdoc != null && subdoc.$__ != null) {
+      if (subdoc?.$__ != null) {
         return subdoc.toString();
       }
       return subdoc;
@@ -65,7 +65,7 @@ const methods = {
       value instanceof Constructor;
     if (isInstance ||
         // Hack re: #5001, see #5005
-        (value && value.constructor && value.constructor.baseCasterConstructor === Constructor)) {
+        value?.constructor?.baseCasterConstructor === Constructor) {
       if (!(value[documentArrayParent] && value.__parentArray)) {
         // value may have been created using array.create()
         value[documentArrayParent] = this[arrayParentSymbol];
@@ -75,7 +75,7 @@ const methods = {
       return value;
     }
 
-    if (value === undefined || value === null) {
+    if (value == null) {
       return null;
     }
 
@@ -133,9 +133,9 @@ const methods = {
     const schemaType = this[arraySchemaSymbol];
     let idSchemaType = null;
 
-    if (schemaType && schemaType.schema) {
+    if (schemaType?.schema) {
       idSchemaType = schemaType.schema.path('_id');
-    } else if (schemaType && schemaType.casterConstructor && schemaType.casterConstructor.schema) {
+    } else if (schemaType?.casterConstructor?.schema) {
       idSchemaType = schemaType.casterConstructor.schema.path('_id');
     }
 

package/lib/types/map.js

@@ -22,7 +22,7 @@ class MongooseMap extends Map {
       v = Object.keys(v).reduce((arr, key) => arr.concat([[key, v[key]]]), []);
     }
     super(v);
-    this.$__parent = doc != null && doc.$__ != null ? doc : null;
+    this.$__parent = doc?.$__ != null ? doc : null;
 
     // Calculate the full path from the root document
     // Priority: parent.$basePath (from subdoc) > options.path (from parent map/structure) > path (schema path)
@@ -50,7 +50,7 @@ class MongooseMap extends Map {
 
     super.set(key, value);
 
-    if (value != null && value.$isSingleNested) {
+    if (value?.$isSingleNested) {
       value.$basePath = this.$__path + '.' + key;
       // Store the path relative to parent subdoc for efficient markModified()
       if (this.$__pathRelativeToParent != null) {
@@ -129,7 +129,7 @@ class MongooseMap extends Map {
 
     let _fullPath;
     const parent = this.$__parent;
-    const populated = parent != null && parent.$__ && parent.$__.populated ?
+    const populated = parent?.$__?.populated ?
       parent.$populated(fullPath.call(this), true) || parent.$populated(this.$__path, true) :
       null;
     const priorVal = this.get(key);
@@ -177,7 +177,7 @@ class MongooseMap extends Map {
           options
         );
       } catch (error) {
-        if (this.$__parent != null && this.$__parent.$__ != null) {
+        if (this.$__parent?.$__ != null) {
           this.$__parent.invalidate(fullPath.call(this), error);
           return;
         }
@@ -189,7 +189,7 @@ class MongooseMap extends Map {
 
     // Set relative path on subdocuments to avoid string operations in markModified()
     // The path should be relative to the parent subdocument (if any), not just the key
-    if (value != null && value.$isSingleNested) {
+    if (value?.$isSingleNested) {
       if (this.$__pathRelativeToParent != null) {
         // Map's parent is a subdocument, store path relative to that subdoc (e.g., 'items.i2')
         value.$pathRelativeToParent = this.$__pathRelativeToParent + '.' + key;
@@ -199,7 +199,7 @@ class MongooseMap extends Map {
       }
     }
 
-    if (parent != null && parent.$__ != null && !deepEqual(value, priorVal)) {
+    if (parent?.$__ != null && !deepEqual(value, priorVal)) {
       // Optimization: if parent is a subdocument, use precalculated relative path
       // to avoid building a full path just to strip the parent's prefix
       let pathToMark;
@@ -275,7 +275,7 @@ class MongooseMap extends Map {
   }
 
   toObject(options) {
-    if (options && options.flattenMaps) {
+    if (options?.flattenMaps) {
       const ret = {};
       const keys = this.keys();
       for (const key of keys) {
@@ -308,7 +308,7 @@ class MongooseMap extends Map {
    */
 
   toJSON(options) {
-    if (typeof (options && options.flattenMaps) === 'boolean' ? options.flattenMaps : true) {
+    if (typeof options?.flattenMaps === 'boolean' ? options.flattenMaps : true) {
       const ret = {};
       const keys = this.keys();
       for (const key of keys) {

package/lib/types/subdocument.js

@@ -23,10 +23,10 @@ function Subdocument(value, fields, parent, options) {
     }
     options = Object.assign(parentOptions, options);
   }
-  if (options != null && options.path != null) {
+  if (options?.path != null) {
     this.$basePath = options.path;
   }
-  if (options != null && options.pathRelativeToParent != null) {
+  if (options?.pathRelativeToParent != null) {
     this.$pathRelativeToParent = options.pathRelativeToParent;
   }
 
@@ -35,7 +35,7 @@ function Subdocument(value, fields, parent, options) {
   // subdocuments use relative paths (relative to the parent document) to track changes.
   // This avoids the subdocument's fields receiving the subdocument's path as options.path.
   let documentOptions = options;
-  if (options != null && options.path != null) {
+  if (options?.path != null) {
     documentOptions = Object.assign({}, options);
     delete documentOptions.path;
   }
@@ -356,6 +356,16 @@ Subdocument.prototype.parent = function() {
 
 Subdocument.prototype.$parent = Subdocument.prototype.parent;
 
+/*!
+ * Sets this sub-documents parent document.
+ *
+ * @api private
+ */
+
+Subdocument.prototype.$__setParent = function $__setParent(parent) {
+  this.$__parent = parent;
+};
+
 /**
  * ignore
  * @method $__removeFromParent
@@ -378,7 +388,7 @@ Subdocument.prototype.deleteOne = function deleteOne(options) {
   registerRemoveListener(this);
 
   // If removing entire doc, no need to remove subdoc
-  if (!options || !options.noop) {
+  if (!options?.noop) {
     this.$__removeFromParent();
 
     const owner = this.ownerDocument();
@@ -422,7 +432,7 @@ Subdocument.prototype.$toObject = function $toObject(options, json) {
 
   // If `$toObject()` was called recursively, respect the minimize option, including schematype level minimize.
   // If minimize is set, then we can minimize out the whole object.
-  if (Object.keys(ret).length === 0 && options?._calledWithOptions != null) {
+  if (utils.hasOwnKeys(ret) === false && options?._calledWithOptions != null) {
     const minimize = options._calledWithOptions?.minimize ?? this?.$__schemaTypeOptions?.minimize ?? options.minimize;
     if (minimize && !this.constructor.$__required) {
       return undefined;

package/lib/utils.js

@@ -436,10 +436,26 @@ exports.isNativeObject = function(arg) {
  * @param {Any} val
  */
 
-exports.isEmptyObject = function(val) {
-  return val != null &&
-    typeof val === 'object' &&
-    Object.keys(val).length === 0;
+exports.isEmptyObject = function isEmptyObject(val) {
+  if (val == null || typeof val !== 'object') {
+    return false;
+  }
+  return exports.hasOwnKeys(val) === false;
+};
+
+/**
+ * Determines if `obj` has any own keys. Assumes obj is already an object.
+ * Faster than Object.keys(obj).length > 0.
+ * @param {Object} obj
+ */
+
+exports.hasOwnKeys = function hasOwnKeys(obj) {
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      return true;
+    }
+  }
+  return false;
 };
 
 /**
@@ -665,7 +681,7 @@ function getValueLookup(obj, part) {
     return obj;
   }
   let _from = obj?._doc || obj;
-  if (_from != null && _from.isMongooseArrayProxy) {
+  if (_from?.isMongooseArrayProxy) {
     _from = _from.__array;
   }
   return _from instanceof Map ?
@@ -720,7 +736,7 @@ exports.object.vals = function vals(o) {
  */
 
 exports.isNullOrUndefined = function(val) {
-  return val === null || val === undefined;
+  return val == null;
 };
 
 /*!
@@ -919,7 +935,7 @@ exports.mergeClone = function(to, fromObj) {
       });
     } else {
       let val = fromObj[key];
-      if (val != null && val.valueOf && !(val instanceof Date)) {
+      if (val?.valueOf && !(val instanceof Date)) {
         val = val.valueOf();
       }
       if (exports.isObject(val)) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "9.0.1",
+  "version": "9.1.0",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -50,7 +50,7 @@
     "mkdirp": "^3.0.1",
     "mocha": "11.7.5",
     "moment": "2.30.1",
-    "mongodb-memory-server": "10.3.0",
+    "mongodb-memory-server": "11.0.0",
     "mongodb-runner": "^6.0.0",
     "mongodb-client-encryption": "~7.0",
     "ncp": "^2.0.0",
@@ -102,6 +102,7 @@
     "tdd": "mocha --watch --inspect --recursive ./test/*.test.js --watch-files lib/**/*.js test/**/*.js",
     "test-coverage": "nyc --reporter=html --reporter=text npm test",
     "ts-benchmark": "cd ./benchmarks/typescript/simple && npm install && npm run benchmark | node ../../../scripts/tsc-diagnostics-check",
+    "ts-benchmark:local": "node ./scripts/create-tarball && cd ./benchmarks/typescript/simple && rm -rf ./node_modules && npm install && npm run benchmark | node ../../../scripts/tsc-diagnostics-check",
     "attest-benchmark": "node ./benchmarks/typescript/infer.bench.mts"
   },
   "main": "./index.js",

package/types/index.d.ts

@@ -177,7 +177,7 @@ declare module 'mongoose' {
     HydratedDocPathsType,
     any,
     TOverrides extends Record<string, never> ?
-      Document<unknown, TQueryHelpers, RawDocType, TVirtuals, TSchemaOptions> & Default__v<Require_id<HydratedDocPathsType>, TSchemaOptions> :
+      Document<unknown, TQueryHelpers, RawDocType, TVirtuals, TSchemaOptions> & Default__v<Require_id<HydratedDocPathsType>, TSchemaOptions> & AddDefaultId<HydratedDocPathsType, {}, TSchemaOptions> :
       IfAny<
         TOverrides,
         Document<unknown, TQueryHelpers, RawDocType, TVirtuals, TSchemaOptions> & Default__v<Require_id<HydratedDocPathsType>, TSchemaOptions>,
@@ -345,7 +345,8 @@ declare module 'mongoose' {
         TSchemaOptions extends { methods: infer M } ? M : {},
         TSchemaOptions extends { query: any } ? TSchemaOptions['query'] : {},
         TSchemaOptions extends { virtuals: any } ? TSchemaOptions['virtuals'] : {},
-        RawDocType
+        RawDocType,
+        ResolveSchemaOptions<TSchemaOptions>
       >
     >(def: TSchemaDefinition): Schema<
       RawDocType,
@@ -374,7 +375,14 @@ declare module 'mongoose' {
         InferRawDocType<TSchemaDefinition, ResolveSchemaOptions<TSchemaOptions>>,
         ResolveSchemaOptions<TSchemaOptions>
       >,
-      THydratedDocumentType extends AnyObject = HydratedDocument<InferHydratedDocType<TSchemaDefinition, ResolveSchemaOptions<TSchemaOptions>>>
+      THydratedDocumentType extends AnyObject = HydratedDocument<
+        InferHydratedDocType<TSchemaDefinition, ResolveSchemaOptions<TSchemaOptions>>,
+        TSchemaOptions extends { methods: infer M } ? M : {},
+        TSchemaOptions extends { query: any } ? TSchemaOptions['query'] : {},
+        TSchemaOptions extends { virtuals: any } ? TSchemaOptions['virtuals'] : {},
+        RawDocType,
+        ResolveSchemaOptions<TSchemaOptions>
+      >
     >(def: TSchemaDefinition, options: TSchemaOptions): Schema<
       RawDocType,
       Model<RawDocType, any, any, any>,
@@ -552,9 +560,14 @@ declare module 'mongoose' {
     pre<T = never>(method: MongooseDistinctDocumentMiddleware | MongooseDistinctDocumentMiddleware[] | RegExp, options: SchemaPreOptions & { document: false, query: boolean }, fn: PreMiddlewareFunction<T>): this;
     // this = Union of Document and Query, could be called with any of them
     pre<T = THydratedDocumentType | Query<any, any>>(
-      method: MongooseQueryAndDocumentMiddleware | MongooseQueryAndDocumentMiddleware[] | RegExp,
+      method: 'updateOne' | RegExp,
+      options: SchemaPreOptions & { document: true, query: true },
+      fn: PreUpdateOneMiddlewareFunction<T>
+    ): this;
+    pre<T = THydratedDocumentType | Query<any, any>>(
+      method: 'deleteOne' | RegExp,
       options: SchemaPreOptions & { document: true, query: true },
-      fn: PreMiddlewareFunction<T>
+      fn: PreDeleteOneMiddlewareFunction<T>
     ): this;
     // this = Document
     pre<T = THydratedDocumentType>(method: 'save', fn: PreSaveMiddlewareFunction<T>): this;
@@ -562,9 +575,14 @@ declare module 'mongoose' {
     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>(
-      method: MongooseQueryAndDocumentMiddleware | MongooseQueryAndDocumentMiddleware[] | RegExp,
+      method: 'updateOne' | RegExp,
+      options: SchemaPreOptions & { document: true },
+      fn: PreUpdateOneMiddlewareFunction<T>
+    ): this;
+    pre<T = THydratedDocumentType>(
+      method: 'deleteOne' | RegExp,
       options: SchemaPreOptions & { document: true },
-      fn: PreMiddlewareFunction<T>
+      fn: PreDeleteOneMiddlewareFunction<T>
     ): this;
     pre<T = THydratedDocumentType>(method: MongooseQueryOrDocumentMiddleware | MongooseQueryOrDocumentMiddleware[] | RegExp, options: SchemaPreOptions & { document: true, query: false }, fn: PreMiddlewareFunction<T>): this;
     // this = Query
@@ -623,8 +641,7 @@ 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] }): this;
-    static(obj: { [F in keyof TStaticMethods]: TStaticMethods[F] } & { [name: string]: (this: TModelType, ...args: any[]) => any }): this;
+    static(obj: Partial<TStaticMethods> & { [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. */

package/types/inferrawdoctype.d.ts

@@ -12,18 +12,24 @@ declare module 'mongoose' {
     ? ObtainSchemaGeneric<TSchema, 'EnforcedDocType'>
     : FlattenMaps<SubdocsToPOJOs<ObtainSchemaGeneric<TSchema, 'DocType'>>>;
 
-  export type InferRawDocType<
+  export type InferRawDocTypeWithout_id<
     SchemaDefinition,
     TSchemaOptions extends Record<any, any> = DefaultSchemaOptions,
     TTransformOptions = { bufferToBinary: false }
-  > = Require_id<ApplySchemaOptions<{
+  > = ApplySchemaOptions<{
     [
     K in keyof (RequiredPaths<SchemaDefinition, TSchemaOptions['typeKey']> &
     OptionalPaths<SchemaDefinition, TSchemaOptions['typeKey']>)
     ]: IsPathRequired<SchemaDefinition[K], TSchemaOptions['typeKey']> extends true
       ? ObtainRawDocumentPathType<SchemaDefinition[K], TSchemaOptions['typeKey'], TTransformOptions>
       : ObtainRawDocumentPathType<SchemaDefinition[K], TSchemaOptions['typeKey'], TTransformOptions> | null;
-  }, TSchemaOptions>>;
+  }, TSchemaOptions>;
+
+  export type InferRawDocType<
+    SchemaDefinition,
+    TSchemaOptions extends Record<any, any> = DefaultSchemaOptions,
+    TTransformOptions = { bufferToBinary: false }
+  > = Require_id<InferRawDocTypeWithout_id<SchemaDefinition, TSchemaOptions, TTransformOptions>>;
 
   /**
    * @summary Allows users to optionally choose their own type for a schema field for stronger typing.

package/types/inferschematype.d.ts

@@ -100,10 +100,10 @@ declare module 'mongoose' {
       {
         EnforcedDocType: EnforcedDocType;
         M: M;
-        TInstanceMethods: TInstanceMethods;
-        TQueryHelpers: TQueryHelpers;
-        TVirtuals: AddDefaultId<DocType, TVirtuals, TSchemaOptions>;
-        TStaticMethods: TStaticMethods;
+        TInstanceMethods: IfEquals<TInstanceMethods, {}, TSchemaOptions extends { methods: infer M } ? M : {}, TInstanceMethods>;
+        TQueryHelpers: IfEquals<TQueryHelpers, {}, TSchemaOptions extends { query: infer Q } ? Q : {}, TQueryHelpers>;
+        TVirtuals: AddDefaultId<DocType, IfEquals<TVirtuals, {}, TSchemaOptions extends { virtuals: infer V } ? V : {}, TVirtuals>, TSchemaOptions>;
+        TStaticMethods: IfEquals<TStaticMethods, {}, TSchemaOptions extends { statics: infer S } ? S : {}, TStaticMethods>;
         TSchemaOptions: TSchemaOptions;
         DocType: DocType;
         THydratedDocumentType: THydratedDocumentType;
@@ -136,11 +136,6 @@ declare module 'mongoose' {
     : T;
 }
 
-type IsPathDefaultUndefined<PathType> =
-  PathType extends { default: undefined } ? true
-  : PathType extends { default: (...args: any[]) => undefined } ? true
-  : false;
-
 type RequiredPropertyDefinition =
   | {
       required: true | string | [true, string | undefined] | { isRequired: true };
@@ -159,16 +154,17 @@ type IsPathRequired<P, TypeKey extends string = DefaultTypeKey> =
     P extends { required: false } ?
       false
     : true
-  : P extends Record<TypeKey, ArrayConstructor | any[]> ?
-    IsPathDefaultUndefined<P> extends true ?
-      false
-    : true
-  : P extends Record<TypeKey, any> ?
-    P extends { default: any } ?
-      IfEquals<P['default'], undefined, false, true>
-    : false
+  : P extends { default: undefined | null | ((...args: any[]) => undefined) | ((...args: any[]) => null) } ? false
+  : P extends { default: any } ? true
+  : P extends Record<TypeKey, ArrayConstructor | any[]> ? true
   : false;
 
+// Internal type used to efficiently check for never or any types
+// can be efficiently checked like:
+// `[T] extends [neverOrAny] ? T : ...`
+// to avoid edge cases
+type neverOrAny = ' ~neverOrAny~';
+
 /**
  * @summary A Utility to obtain schema's required path keys.
  * @param {T} T A generic refers to document definition.
@@ -251,6 +247,7 @@ type UnionToType<T extends readonly any[]> = T[number] extends infer U
 
 type IsSchemaTypeFromBuiltinClass<T> =
   T extends typeof String ? true
+  : unknown extends Buffer ? false
   : T extends typeof Number ? true
   : T extends typeof Boolean ? true
   : T extends typeof Buffer ? true
@@ -268,7 +265,6 @@ type IsSchemaTypeFromBuiltinClass<T> =
   : T extends NativeDate ? true
   : T extends typeof Schema.Types.Mixed ? true
   : T extends Types.UUID ? true
-  : unknown extends Buffer ? false
   : T extends Buffer ? true
   : false;
 
@@ -284,12 +280,10 @@ type ResolvePathType<
   Options extends SchemaTypeOptions<PathValueType> = {},
   TypeKey extends string = DefaultSchemaOptions['typeKey'],
   TypeHint = never
-> = IfEquals<
-  TypeHint,
-  never,
-  PathValueType extends Schema ? InferSchemaType<PathValueType>
+> = [TypeHint] extends [never]
+  ? PathValueType extends Schema ? InferSchemaType<PathValueType>
   : PathValueType extends AnyArray<infer Item> ?
-    IfEquals<Item, never> extends true
+    [Item] extends [never]
       ? any[]
       : Item extends Schema ?
         // If Item is a schema, infer its type.
@@ -328,7 +322,7 @@ type ResolvePathType<
     : never
   : PathValueType extends ArrayConstructor ? any[]
   : PathValueType extends typeof Schema.Types.Mixed ? any
-  : IfEquals<PathValueType, ObjectConstructor> extends true ? any
+  : PathValueType extends ObjectConstructor ? any
   : IfEquals<PathValueType, {}> extends true ? any
   : PathValueType extends typeof SchemaType ? PathValueType['prototype']
   : PathValueType extends Record<string, any> ?
@@ -339,6 +333,5 @@ type ResolvePathType<
         typeKey: TypeKey;
       }
     >
-  : unknown,
-  TypeHint
->;
+  : unknown
+  : TypeHint;

package/types/middlewares.d.ts

@@ -38,6 +38,17 @@ declare module 'mongoose' {
     this: ThisType,
     opts?: Record<string, any>
   ) => void | Promise<void> | Kareem.SkipWrappedFunction;
+  type PreDeleteOneMiddlewareFunction<ThisType = any> = (
+    this: ThisType,
+    doc: ThisType,
+    opts?: Record<string, any>
+  ) => void | Promise<void> | Kareem.SkipWrappedFunction;
+  type PreUpdateOneMiddlewareFunction<ThisType = any> = (
+    this: ThisType,
+    doc: ThisType,
+    update?: Record<string, any>,
+    opts?: Record<string, any>
+  ) => void | Promise<void> | Kareem.SkipWrappedFunction;
   type PreSaveMiddlewareFunction<ThisType = any> = (
     this: ThisType,
     opts: SaveOptions

package/types/models.d.ts

@@ -190,19 +190,27 @@ declare module 'mongoose' {
     mongodb.InsertOneModel<TSchema> & MongooseBulkWritePerOperationOptions;
 
   export type ReplaceOneModel<TSchema extends mongodb.Document = mongodb.Document> =
-    mongodb.ReplaceOneModel<TSchema> & MongooseBulkWritePerOperationOptions;
+    Omit<mongodb.ReplaceOneModel<TSchema>, 'filter'> &
+    { filter: QueryFilter<TSchema> } &
+    MongooseBulkUpdatePerOperationOptions;
 
   export type UpdateOneModel<TSchema extends mongodb.Document = mongodb.Document> =
-    mongodb.UpdateOneModel<TSchema> & MongooseBulkUpdatePerOperationOptions;
+    Omit<mongodb.UpdateOneModel<TSchema>, 'filter'> &
+    { filter: QueryFilter<TSchema> } &
+    MongooseBulkUpdatePerOperationOptions;
 
   export type UpdateManyModel<TSchema extends mongodb.Document = mongodb.Document> =
-    mongodb.UpdateManyModel<TSchema> & MongooseBulkUpdatePerOperationOptions;
+    Omit<mongodb.UpdateManyModel<TSchema>, 'filter'> &
+    { filter: QueryFilter<TSchema> } &
+    MongooseBulkUpdatePerOperationOptions;
 
   export type DeleteOneModel<TSchema extends mongodb.Document = mongodb.Document> =
-    mongodb.DeleteOneModel<TSchema>;
+    Omit<mongodb.DeleteOneModel<TSchema>, 'filter'> &
+    { filter: QueryFilter<TSchema> };
 
   export type DeleteManyModel<TSchema extends mongodb.Document = mongodb.Document> =
-    mongodb.DeleteManyModel<TSchema>;
+    Omit<mongodb.DeleteManyModel<TSchema>, 'filter'> &
+    { filter: QueryFilter<TSchema> };
 
   export type AnyBulkWriteOperation<TSchema extends mongodb.Document = mongodb.Document> =
     | { insertOne: InsertOneModel<TSchema> }
@@ -335,6 +343,8 @@ declare module 'mongoose' {
 
     /** Creates a new document or documents */
     create(): Promise<null>;
+    create(doc: Partial<TRawDocType>): Promise<THydratedDocumentType>;
+    create(docs: Array<Partial<TRawDocType>>): Promise<THydratedDocumentType[]>;
     create(docs: Array<DeepPartial<ApplyBasicCreateCasting<Require_id<TRawDocType>>>>, options: CreateOptions & { aggregateErrors: true }): Promise<(THydratedDocumentType | Error)[]>;
     create(docs: Array<DeepPartial<ApplyBasicCreateCasting<Require_id<TRawDocType>>>>, options?: CreateOptions): Promise<THydratedDocumentType[]>;
     create(doc: DeepPartial<ApplyBasicCreateCasting<Require_id<TRawDocType>>>): Promise<THydratedDocumentType>;

package/types/query.d.ts

@@ -20,7 +20,7 @@ declare module 'mongoose' {
 
   export type ApplyBasicQueryCasting<T> = QueryTypeCasting<T> | QueryTypeCasting<T[]> | (T extends (infer U)[] ? QueryTypeCasting<U> : T) | null;
 
-  type _QueryFilter<T> = ({ [P in keyof T]?: mongodb.Condition<ApplyBasicQueryCasting<T[P]>>; } & mongodb.RootFilterOperators<{ [P in keyof T]?: ApplyBasicQueryCasting<T[P]>; }>);
+  type _QueryFilter<T> = ({ [P in keyof T]?: mongodb.Condition<ApplyBasicQueryCasting<T[P]>>; } & mongodb.RootFilterOperators<{ [P in keyof mongodb.WithId<T>]?: ApplyBasicQueryCasting<mongodb.WithId<T>[P]>; }>);
   type QueryFilter<T> = IsItRecordAndNotAny<T> extends true ? _QueryFilter<WithLevel1NestedPaths<T>> : _QueryFilter<Record<string, any>>;
 
   type MongooseBaseQueryOptionKeys =

package/types/schemaoptions.d.ts

@@ -111,8 +111,10 @@ declare module 'mongoose' {
     /**
      * Optimistic concurrency is a strategy to ensure the document you're updating didn't change between when you
      * loaded it using find() or findOne(), and when you update it using save(). Set to `true` to enable
-     * optimistic concurrency. Set to string array to enable optimistic concurrency for only certain fields,
-     * or `{ exclude: string[] }` to define a list of fields to ignore for optimistic concurrency.
+     * optimistic concurrency for all fields. Set to a string array to enable optimistic concurrency only for
+     * the specified fields; note that this **replaces** the default array versioning behavior. Set to
+     * `{ exclude: string[] }` to enable optimistic concurrency for all fields except the specified ones;
+     * this also **replaces** the default array versioning.
      */
     optimisticConcurrency?: boolean | string[] | { exclude: string[] };
     /**

package/types/utility.d.ts

@@ -146,7 +146,7 @@ declare module 'mongoose' {
    * @param {T} T Function type to extract 'this' parameter from.
    * @param {F} F Fallback type to return if 'this' parameter does not exist.
    */
-  type ThisParameter<T, F> = T extends { (this: infer This): void } ? This : F;
+  type ThisParameter<T, F> = T extends { (this: infer This, ...args: never): void } ? This : F;
 
   /**
    * @summary Decorates all functions in an object with 'this' parameter.

package/types/virtuals.d.ts

@@ -8,7 +8,7 @@ declare module 'mongoose' {
   type TVirtualPathFN<DocType = {}, PathType = unknown, TInstanceMethods = {}, TReturn = unknown> =
     <T = HydratedDocument<DocType, TInstanceMethods>>(this: Document<any, any, DocType> & DocType, value: PathType, virtual: VirtualType<T>, doc: Document<any, any, DocType> & DocType) => TReturn;
 
-    type SchemaOptionsVirtualsPropertyType<DocType = any, VirtualPaths = Record<any, unknown>, TInstanceMethods = {}> = {
-      [K in keyof VirtualPaths]: VirtualPathFunctions<IsItRecordAndNotAny<DocType> extends true ? DocType : any, VirtualPaths[K], TInstanceMethods>
-    };
+  type SchemaOptionsVirtualsPropertyType<DocType = any, VirtualPaths = Record<any, unknown>, TInstanceMethods = {}> = {
+    [K in keyof VirtualPaths]: VirtualPathFunctions<IsItRecordAndNotAny<DocType> extends true ? DocType : any, VirtualPaths[K], TInstanceMethods>
+  };
 }